Vercel AI SDK

import { Fail, guardrailBlocked, serve, stream } from "@agentos/sdk";
import { agentosModel, runWithApprovals } from "@agentos/sdk/ai-sdk";
import { convertToModelMessages, stepCountIs, streamText, tool, type UIMessage } from "ai";
import { z } from "zod";

const pay = tool({
  description: "Pay a supplier. Amounts are text, e.g. \"120.00\".",
  inputSchema: z.object({ payee: z.string(), amount: z.string() }),
  execute: async ({ payee, amount }) => `paid ${amount} to ${payee}`,
});

await serve({
  // Streams a UI message stream that useChat reads as it is, when the caller starts the run with ?passthrough=true.
  chat: async (inv) => {
    let failure: unknown;
    const result = streamText({
      model: agentosModel(inv),
      system: inv.config.prompts?.system,
      messages: await convertToModelMessages(inv.input.messages as UIMessage[]),
      onError: ({ error }) => { failure = error; },
    });
    const response = result.toUIMessageStreamResponse({
      onError: (error) => {
        failure = error;
        return guardrailBlocked(error)?.message ?? "The model call failed.";
      },
    });
    const headers = Object.fromEntries([...response.headers].filter(([name]) => !["content-type", "connection"].includes(name)));

    async function* chunks() {
      for await (const chunk of response.body!) yield chunk;
      // the run's outcome, reported before the stream ends
      if (failure) throw guardrailBlocked(failure) ?? new Fail("model_call_failed", String(failure));
      inv.setOutput({ text: await result.text });
    }
    return stream(chunks(), { contentType: "text/event-stream", headers });
  },

  // A tool that needs approval: the run is held until a person decides, then continues where it stopped.
  pay_supplier: async (inv) => {
    const result = await runWithApprovals(inv, {
      model: agentosModel(inv),
      system: "Pay suppliers with the pay tool.",
      messages: [{ role: "user", content: inv.input.request }],
      tools: { pay },
      toolApproval: { pay: "user-approval" },
      stopWhen: stepCountIs(5),
      intent: "Pay a supplier",
    });
    return { answer: result.text };
  },
}, { port: 8080 });

name: support-agent
title: Support Agent (Vercel AI SDK)
description: Streams chat answers to a useChat frontend, and pays suppliers once a person approves.
runtime: stateless
port: 8080
capabilities:
  chat:
    description: One chat turn, streamed as an AI SDK UI message stream.
    input:
      type: object
      properties:
        messages: {type: array, items: {type: object}}
      required: [messages]
    output:
      type: object
      properties: {text: {type: string}}
      required: [text]
    timeout: 60s
  pay_supplier:
    description: Pays a supplier with the pay tool; every payment waits for a person's approval.
    input:
      type: object
      properties: {request: {type: string}}
      required: [request]
    output:
      type: object
      properties: {answer: {type: string}}
      required: [answer]
    timeout: 60s
config:
  models:
    main: anthropic/claude-sonnet-4-5
  prompts:
    system: You are a concise support assistant.

{
  "name": "support-agent",
  "private": true,
  "type": "module",
  "dependencies": {
    "@agentos/sdk": "file:vendor/agentos-sdk-0.1.0.tgz",
    "@ai-sdk/openai-compatible": "3.0.68",
    "ai": "7.0.138",
    "zod": "4.6.7"
  }
}

FROM node:24-slim
WORKDIR /app
COPY package.json .
COPY vendor/ vendor/
RUN npm install --omit=dev --no-audit --no-fund
COPY agent.ts .
USER node
EXPOSE 8080
CMD ["node", "agent.ts"]

// Your Next.js backend: forwards one chat turn to AgentOS and streams the answer back.
export async function POST(req: Request) {
  const { messages } = await req.json();
  const upstream = await fetch(
    `${process.env.AGENTOS}/v0/envs/default/agents/support-agent/capabilities/chat/runs?passthrough=true`,
    {
      method: "POST",
      headers: { Authorization: `Bearer ${process.env.AGENTOS_API_KEY}`, "Content-Type": "application/json" },
      body: JSON.stringify({ input: { messages } }),
    },
  );
  const headers = new Headers();
  for (const name of ["content-type", "cache-control", "x-vercel-ai-ui-message-stream", "x-agentos-run-id"]) {
    const value = upstream.headers.get(name);
    if (value) headers.set(name, value);
  }
  return new Response(upstream.body, { status: upstream.status, headers });
}

"use client";
import { useChat } from "@ai-sdk/react";
import { useState } from "react";

export default function Chat() {
  const { messages, sendMessage } = useChat(); // posts to /api/chat
  const [text, setText] = useState("");
  return (
    <div>
      {messages.map((m) => (
        <p key={m.id}>
          <b>{m.role}:</b> {m.parts.map((p) => (p.type === "text" ? p.text : "")).join("")}
        </p>
      ))}
      <form onSubmit={(e) => { e.preventDefault(); sendMessage({ text }); setText(""); }}>
        <input value={text} onChange={(e) => setText(e.target.value)} />
      </form>
    </div>
  );
}