From Vercel AI SDK

// app/chat.tsx
'use client'
import { useChat } from 'ai/react'

export default function Chat() {
  const { messages, input, handleInputChange, handleSubmit } = useChat({
    api: '/api/chat',
  })

  return (
    <form onSubmit={handleSubmit}>
      {messages.map(m => (
        <div key={m.id}>{m.role}: {m.content}</div>
      ))}
      <input value={input} onChange={handleInputChange} />
    </form>
  )
}

// app/api/chat/route.ts
import { streamText } from 'ai'
import { openai } from '@ai-sdk/openai'

export async function POST(req: Request) {
  const { messages } = await req.json()
  const result = streamText({ model: openai('gpt-4o'), messages })
  return result.toDataStreamResponse()
}

// app/chat.tsx
'use client'
import { useChat, ChatContainer, Message, InputBar } from '@agentskit/react'
import { openai } from '@agentskit/adapters'
import '@agentskit/react/theme'

const adapter = openai({ apiKey: KEY, model: 'gpt-4o' })

export default function Chat() {
  const chat = useChat({ adapter })

  return (
    <ChatContainer>
      {chat.messages.map(m => <Message key={m.id} message={m} />)}
      <InputBar chat={chat} />
    </ChatContainer>
  )
}

// app/actions.ts
'use server'
import { openai } from '@agentskit/adapters'
import { createRuntime } from '@agentskit/runtime'

const runtime = createRuntime({
  adapter: openai({ apiKey: process.env.OPENAI_API_KEY!, model: 'gpt-4o' }),
})

export async function ask(prompt: string) {
  const result = await runtime.run(prompt)
  return result.content
}

// app/page.tsx
'use client'
import { ask } from './actions'
// Call ask(prompt) from a form or event handler; stream via RSC Suspense

import { tool, streamText } from 'ai'
import { z } from 'zod'

const weatherTool = tool({
  description: 'Get the weather for a city',
  parameters: z.object({ city: z.string() }),
  execute: async ({ city }) => {
    const res = await fetch(`https://wttr.in/${city}?format=j1`)
    return await res.json()
  },
})

const result = streamText({
  model: openai('gpt-4o'),
  messages,
  tools: { weather: weatherTool },
  maxSteps: 5,
})

import type { ToolDefinition } from '@agentskit/core'
import { createRuntime } from '@agentskit/runtime'
import { openai } from '@agentskit/adapters'

const weatherTool: ToolDefinition = {
  name: 'weather',
  description: 'Get the weather for a city',
  schema: {
    type: 'object',
    properties: { city: { type: 'string' } },
    required: ['city'],
  },
  async execute(args) {
    const res = await fetch(`https://wttr.in/${args.city}?format=j1`)
    return await res.json()
  },
}

const runtime = createRuntime({
  adapter: openai({ apiKey: KEY, model: 'gpt-4o' }),
  tools: [weatherTool],
  maxSteps: 5,
})

// route handler has to know which SDK to import
import { openai } from '@ai-sdk/openai'
import { anthropic } from '@ai-sdk/anthropic'

const model = useClaude ? anthropic('claude-sonnet-4-6') : openai('gpt-4o')
const result = streamText({ model, messages })

import { openai, anthropic } from '@agentskit/adapters'

const adapter = useClaude
  ? anthropic({ apiKey, model: 'claude-sonnet-4-6' })
  : openai({ apiKey, model: 'gpt-4o' })

useChat({ adapter })   // or createRuntime({ adapter })

// You write this yourself — ~50 lines, easy to get wrong
async function runAgent(task: string) {
  const messages = [{ role: 'user', content: task }]
  for (let step = 0; step < 10; step++) {
    const result = await generateText({ model, messages, tools })
    // parse tool calls, execute, append results, decide when to stop...
  }
}

import { createRuntime } from '@agentskit/runtime'
import { openai } from '@agentskit/adapters'
import { webSearch, filesystem } from '@agentskit/tools'
import { sqliteChatMemory } from '@agentskit/memory'
import { createRAG } from '@agentskit/rag'
import { fileVectorMemory } from '@agentskit/memory'
import { openaiEmbed } from '@agentskit/adapters'

const rag = createRAG({
  store: fileVectorMemory({ path: './embeddings.json' }),
  embed: openaiEmbed({ apiKey: KEY, model: 'text-embedding-3-small' }),
})

const runtime = createRuntime({
  adapter: openai({ apiKey: KEY, model: 'gpt-4o' }),
  tools: [webSearch(), ...filesystem({ basePath: './workspace' })],
  memory: sqliteChatMemory({ path: './sessions/user-42.db' }),
  retriever: rag,
  maxSteps: 10,
})

const result = await runtime.run('Research the top 3 AI frameworks and save a summary')

import { planner, researcher, coder } from '@agentskit/skills'

await runtime.run('Build a landing page about quantum computing', {
  skill: planner,
  delegates: {
    researcher: { skill: researcher, tools: [webSearch()], maxSteps: 3 },
    coder:      { skill: coder, tools: [...filesystem({ basePath: './src' })], maxSteps: 8 },
  },
})

const result = streamText({
  model,
  messages,
  onFinish: ({ usage }) => console.log(usage),
  experimental_telemetry: { isEnabled: true },
})

import type { Observer } from '@agentskit/core'

const telemetry: Observer = {
  onModelStart: () => console.time('model'),
  onRunEnd: (result) => {
    console.timeEnd('model')
    console.log(`${result.steps} steps, ${result.toolCalls.length} tool calls`)
  },
  onChunk: (chunk) => {
    if (chunk.metadata?.usage) console.log('usage:', chunk.metadata.usage)
  },
}

createRuntime({ adapter, tools, observers: [telemetry] })