Vercel AI SDK

• The model layer — one generateText / streamText interface across OpenAI, Anthropic, Google, and dozens of other providers.
• The tool-calling loop — define tool()s with a schema and an execute, set stopWhen, and the SDK runs multi-step tool calls until the job is done.
• Streaming + UI — streamText, useChat, and structured output for full-stack apps.

​

How the pairing works

• Naive’s SDK exposes a small, drop-in toolset via agentTools() — a discover-then-run meta-toolset (search apps/primitives, then run them) instead of thousands of schemas.
• Each Naive tool ships an Anthropic-style input_schema (plain JSON Schema). The AI SDK’s tool() accepts a raw JSON schema via the jsonSchema() helper — so the adapter is a few lines, with no manual Zod rewrites.
• Every call stays gated by the user’s Account Kit on Naive’s servers; sensitive actions resolve to a pending_approval payload.

  Vercel AI SDK (generateText)          Naive
  ───────────────────────────          ─────
  model ── tool call ──▶ loop
        │  model picks a tool
        ▼
  tool.execute(input)  ──────────▶  kit.handle(name, input)
                                          │  AccountKit-gated, scoped to one user
                                          ▼
                                    connect Gmail · issue a $50 card · run a capability
                                          │
                                    sensitive? → 202 pending_approval (human-in-the-loop)

​

Prerequisites

• A Naive API key (nv_sk_...) — get one from the dashboard.
• An OPENAI_API_KEY (or any other AI SDK provider key) for the model that runs the agent.
• Node ≥ 20.

npm install @usenaive-sdk/server ai @ai-sdk/openai @ai-sdk/mcp

export NAIVE_API_KEY=nv_sk_live_...
export OPENAI_API_KEY=sk-...

​

Minimal viable integration

import { Naive } from "@usenaive-sdk/server";

const naive = new Naive({ apiKey: process.env.NAIVE_API_KEY! });

// Control plane: a reusable policy template.
const pro = await naive.accountKits.create({
  name: "Pro",
  primitives_config: {
    cards: { enabled: true, requiresApproval: true, defaults: { spending_limit_cents: 50000 } },
    vault: { enabled: true },
  },
  connections_config: { mode: "allowlist", toolkits: ["github", "gmail", "stripe"] },
});

// Provision one of your end-users and assign the kit.
const alice = await naive.users.create({
  external_id: "user_123",
  email: "alice@acme.com",
  account_kit_id: pro.id,
});

// Data plane: a client bound to Alice. No call here takes a userId — the scope is fixed.
const client = naive.forUser(alice.id);

import { tool, jsonSchema } from "ai";
import type { NaiveAgentToolset } from "@usenaive-sdk/server";

function naiveToolsForAISDK(kit: NaiveAgentToolset) {
  return Object.fromEntries(
    kit.tools.map((t) => [
      t.name,
      tool({
        description: t.description,
        // Anthropic-style JSON Schema passed straight through — no Zod rewrite.
        inputSchema: jsonSchema(t.input_schema),
        execute: (input) => kit.handle(t.name, input as Record<string, unknown>),
      }),
    ]),
  );
}

import { generateText, stepCountIs } from "ai";
import { openai } from "@ai-sdk/openai";

const { text, steps } = await generateText({
  model: openai("gpt-5.1"), // adjust to a model you have access to
  tools: naiveToolsForAISDK(client.agentTools()),
  stopWhen: stepCountIs(10), // cap tool-call rounds — required for agentic loops
  system: "You are Alice's operations agent. Use Naive tools to act on her real account.",
  prompt:
    "Connect my GitHub, then issue a $50 virtual card called 'Ads budget' for our marketing spend.",
});

console.log(text);

​

Extension: human-in-the-loop spend (two gates)

• On the server (the real boundary) — Naive freezes the action and returns a pending approval (HTTP 202) instead of a live card. This holds no matter what runtime calls it, and is enforced server-side regardless of prompt or agent configuration.
• In the loop (optional early interrupt) — AI SDK v7 supports tool approval at the generateText / streamText level via the toolApproval option, which pauses before a flagged tool runs so you can surface it in your UI. Treat this as a UX convenience; the enforcement that matters is Naive’s server-side gate.

{
  "status": "pending_approval",
  "approval_id": "65589c8b-e033-4a65-b16c-379211c94429",
  "action": "cards.create",
  "primitive": "cards",
  "title": "Issue virtual card \"Ads budget\"",
  "message": "This action requires human approval before it executes."
}

import { isPendingApproval } from "@usenaive-sdk/server";

// Find what the agent queued for Alice.
const { approvals } = await client.approvals.list({ status: "pending" });

for (const a of approvals) {
  // ...show a.title / a.action_type to a human in your UI...
  await client.approvals.approve(a.id); // API replays cards.create → real card
  // or: await client.approvals.deny(a.id, { reason: "over budget" });
}

​

Alternative: hand a scoped MCP session to the agent

import { generateText, stepCountIs } from "ai";
import { createMCPClient } from "@ai-sdk/mcp";
import { openai } from "@ai-sdk/openai";

const session = await client.session({ ttlMs: 15 * 60 * 1000 });

const mcp = await createMCPClient({
  transport: {
    type: "sse",
    url: session.mcp.url,        // scoped, per-user endpoint
    headers: session.mcp.headers, // scoped bearer — never in the URL
  },
});

try {
  const { text } = await generateText({
    model: openai("gpt-5.1"),
    tools: await mcp.tools(),     // Naive's tools, discovered over MCP
    stopWhen: stepCountIs(10),
    prompt: "Issue a $50 virtual card called 'Ads budget'.",
  });
  console.log(text);
} finally {
  await mcp.close();
}

• Same Account Kit, same approval gates — just delivered as a remote MCP server instead of in-process tools.
• The session is scoped to one user and expires (default 15 min, max 24h); revoke early with client.sessions.revoke(session.id).

​

What stays enforced

• Identity — every action runs as a specific tenant user, fully isolated from your other users.
• Capability bounds — the Account Kit decides which primitives and which apps the agent can touch (allowlist / blocklist / per-tool).
• Scoped spend — virtual cards are capped per card and per user; the model can’t raise its own limit.
• Human-in-the-loop — sensitive actions (cards, domains, KYC, formation, connecting an app) freeze as approvals until a human says yes.

​

Next steps

• SDK overview — the full Naive client surface
• Agent tools — what agentTools() exposes and how handle() works
• Account Kits — author spend/capability policy
• Approvals — the human-in-the-loop lifecycle
• Sessions — per-user MCP sessions for untrusted runtimes