develop-ai-functions-example

Develop examples for AI SDK functions. Use when creating, running, or modifying examples under examples/ai-functions/src to validate provider support, demonstrate features, or create test fixtures.

Install with Tessl CLI

npx tessl i github:vercel/ai --skill develop-ai-functions-example

What are skills?

Review — 73%

Does it follow best practices?

If you maintain this skill, you can automatically optimize it using the tessl CLI to improve its score:

npx tessl skill review --optimize ./path/to/skill

Learn more

Validation — 13 / 16 Passed

Validation for skill structure

SKILL.md

Review

Evals

AI Functions Examples

The examples/ai-functions/ directory contains scripts for validating, testing, and iterating on AI SDK functions across providers.

Example Categories

Examples are organized by AI SDK function in examples/ai-functions/src/:

Directory	Purpose
`generate-text/`	Non-streaming text generation with `generateText()`
`stream-text/`	Streaming text generation with `streamText()`
`generate-object/`	Structured output generation with `generateObject()`
`stream-object/`	Streaming structured output with `streamObject()`
`agent/`	`ToolLoopAgent` examples for agentic workflows
`embed/`	Single embedding generation with `embed()`
`embed-many/`	Batch embedding generation with `embedMany()`
`generate-image/`	Image generation with `generateImage()`
`generate-speech/`	Text-to-speech with `generateSpeech()`
`transcribe/`	Audio transcription with `transcribe()`
`rerank/`	Document reranking with `rerank()`
`middleware/`	Custom middleware implementations
`registry/`	Provider registry setup and usage
`telemetry/`	OpenTelemetry integration
`complex/`	Multi-component examples (agents, routers)
`lib/`	Shared utilities (not examples)
`tools/`	Reusable tool definitions

File Naming Convention

Examples follow the pattern: {provider}-{feature}.ts

Pattern	Example	Description
`{provider}.ts`	`openai.ts`	Basic provider usage
`{provider}-{feature}.ts`	`openai-tool-call.ts`	Specific feature
`{provider}-{sub-provider}.ts`	`amazon-bedrock-anthropic.ts`	Provider with sub-provider
`{provider}-{sub-provider}-{feature}.ts`	`google-vertex-anthropic-cache-control.ts`	Sub-provider with feature

Example Structure

All examples use the run() wrapper from lib/run.ts which:

Loads environment variables from .env
Provides error handling with detailed API error logging

Basic Template

import { providerName } from '@ai-sdk/provider-name';
import { generateText } from 'ai';
import { run } from '../lib/run';

run(async () => {
  const result = await generateText({
    model: providerName('model-id'),
    prompt: 'Your prompt here.',
  });

  console.log(result.text);
  console.log('Token usage:', result.usage);
  console.log('Finish reason:', result.finishReason);
});

Streaming Template

import { providerName } from '@ai-sdk/provider-name';
import { streamText } from 'ai';
import { printFullStream } from '../lib/print-full-stream';
import { run } from '../lib/run';

run(async () => {
  const result = streamText({
    model: providerName('model-id'),
    prompt: 'Your prompt here.',
  });

  await printFullStream({ result });
});

Tool Calling Template

import { providerName } from '@ai-sdk/provider-name';
import { generateText, tool } from 'ai';
import { z } from 'zod';
import { run } from '../lib/run';

run(async () => {
  const result = await generateText({
    model: providerName('model-id'),
    tools: {
      myTool: tool({
        description: 'Tool description',
        inputSchema: z.object({
          param: z.string().describe('Parameter description'),
        }),
        execute: async ({ param }) => {
          return { result: `Processed: ${param}` };
        },
      }),
    },
    prompt: 'Use the tool to...',
  });

  console.log(JSON.stringify(result, null, 2));
});

Structured Output Template

import { providerName } from '@ai-sdk/provider-name';
import { generateObject } from 'ai';
import { z } from 'zod';
import { run } from '../lib/run';

run(async () => {
  const result = await generateObject({
    model: providerName('model-id'),
    schema: z.object({
      name: z.string(),
      items: z.array(z.string()),
    }),
    prompt: 'Generate a...',
  });

  console.log(JSON.stringify(result.object, null, 2));
  console.log('Token usage:', result.usage);
});

Running Examples

From the examples/ai-functions directory:

pnpm tsx src/generate-text/openai.ts
pnpm tsx src/stream-text/openai-tool-call.ts
pnpm tsx src/agent/openai-generate.ts

When to Write Examples

Write examples when:

Adding a new provider: Create basic examples for each supported API (generateText, streamText, generateObject, etc.)
Implementing a new feature: Demonstrate the feature with at least one provider example
Reproducing a bug: Create an example that shows the issue for debugging
Adding provider-specific options: Show how to use providerOptions for provider-specific settings
Creating test fixtures: Use examples to generate API response fixtures (see capture-api-response-test-fixture skill)

Utility Helpers

The lib/ directory contains shared utilities:

File	Purpose
`run.ts`	Error-handling wrapper with `.env` loading
`print.ts`	Clean object printing (removes undefined values)
`print-full-stream.ts`	Colored streaming output for tool calls, reasoning, text
`save-raw-chunks.ts`	Save streaming chunks for test fixtures
`present-image.ts`	Display images in terminal
`save-audio.ts`	Save audio files to disk

Using print utilities

import { print } from '../lib/print';

// Pretty print objects without undefined values
print('Result:', result);
print('Usage:', result.usage, { depth: 2 });

Using printFullStream

import { printFullStream } from '../lib/print-full-stream';

const result = streamText({ ... });
await printFullStream({ result }); // Colored output for text, tool calls, reasoning

Reusable Tools

The tools/ directory contains reusable tool definitions:

import { weatherTool } from '../tools/weather-tool';

const result = await generateText({
  model: openai('gpt-4o'),
  tools: { weather: weatherTool },
  prompt: 'What is the weather in San Francisco?',
});

Best Practices

Keep examples focused: Each example should demonstrate one feature or use case
Use descriptive prompts: Make it clear what the example is testing
Handle errors gracefully: The run() wrapper handles this automatically
Use realistic model IDs: Use actual model IDs that work with the provider
Add comments for complex logic: Explain non-obvious code patterns
Reuse tools when appropriate: Use weatherTool or create new reusable tools in tools/

Repository: vercel/ai
Commit: f9f667c
Last updated: about 1 month ago
Created: about 1 month ago

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.