🤖 AI SDK Dart #

A Dart/Flutter port of Vercel AI SDK v6 — provider-agnostic APIs for text generation, streaming, structured output, tool use, embeddings, image generation, speech, and more.

What is this? #

AI SDK Dart brings the full power of Vercel AI SDK v6 to Dart and Flutter. Write your AI logic once, swap providers without changing a line of business code, and ship on every platform — mobile, web, and server. Every API mirrors its JavaScript counterpart so the official Vercel docs apply directly to your Dart code.

Screenshots #

Flutter Chat App (`examples/flutter_chat`) #

Multi-turn Chat	Streaming Response

Completion	Object Stream

Advanced App (`examples/advanced_app`) #

Provider Chat	Tools Chat

Image Generation	Multimodal

✨ Features #

🗣️ Text Generation & Streaming #

generateText — single-turn or multi-step text generation with full result envelope
streamText — real-time token streaming with typed event taxonomy
smoothStream transform — configurable chunk-size smoothing for UX
Multi-step agentic loops with maxSteps, prepareStep, and stopConditions
Callbacks: onFinish, onStepFinish, onChunk, onError, experimentalOnStart

🧩 Structured Output #

Output.object(schema) — parse model output into a typed Dart object
Output.array(schema) — parse model output into a typed Dart list
Output.choice(options) — constrain output to a fixed set of string values
Output.json() — raw JSON without schema validation
Automatic code-fence stripping (```json ... ```)

🔧 Type-Safe Tools & Multi-Step Agents #

tool<Input, Output>() — fully typed tool definitions with JSON schema
dynamicTool() — tools with unknown input type for dynamic use cases
Tool choice: auto, required, none, or specific tool
Tool approval workflow with needsApproval
Multi-step agentic loops with automatic tool result injection
onInputStart, onInputDelta, onInputAvailable lifecycle hooks

🖼️ Multimodal #

generateImage — image generation (DALL-E 3 via OpenAI)
generateSpeech — text-to-speech audio synthesis
transcribe — speech-to-text transcription
Image inputs in prompts (multimodal vision)

🧮 Embeddings & Cosine Similarity #

embed() — single value embedding with usage tracking
embedMany() — batch embedding for multiple values
cosineSimilarity() — built-in similarity computation

🧱 Middleware System #

wrapLanguageModel(model, middlewares) — composable middleware pipeline
extractReasoningMiddleware — strips <think> tags into ReasoningPart
extractJsonMiddleware — strips ```json ``` fences
simulateStreamingMiddleware — converts non-streaming models to streaming
defaultSettingsMiddleware — applies default temperature/top-p/etc.
addToolInputExamplesMiddleware — enriches tool descriptions with examples

🌐 Provider Registry #

createProviderRegistry — map provider aliases to model factories
Resolve models by 'provider:modelId' string at runtime
Mix providers in a single registry for multi-provider apps

📱 Flutter UI Controllers #

ChatController — multi-turn streaming chat with message history
CompletionController — single-turn text completion with status
ObjectStreamController — streaming typed JSON object updates

🔌 MCP Client (Model Context Protocol) #

MCPClient — connect to MCP servers, discover tools, invoke them
SseClientTransport — HTTP SSE transport
StdioMCPTransport — stdio process transport
Discovered tools are directly compatible with generateText/streamText

🧪 Conformance Suite #

178+ tests covering every public API
Spec-driven JSON fixtures as the source of truth
Provider wire-format conformance tests for OpenAI, Anthropic, and Google

📦 Packages #

Package	pub.dev	What it gives you
`ai_sdk_dart`	`dart pub add ai`	`generateText`, `streamText`, tools, middleware, embeddings, registry
`ai_sdk_openai`	`dart pub add ai_sdk_openai`	`openai('gpt-4.1-mini')`, embeddings, image gen, speech, transcription
`ai_sdk_anthropic`	`dart pub add ai_sdk_anthropic`	`anthropic('claude-sonnet-4-5')`, extended thinking
`ai_sdk_google`	`dart pub add ai_sdk_google`	`google('gemini-2.0-flash')`, embeddings
`ai_sdk_flutter_ui`	`dart pub add ai_sdk_flutter_ui`	`ChatController`, `CompletionController`, `ObjectStreamController`
`ai_sdk_mcp`	`dart pub add ai_sdk_mcp`	`MCPClient`, `SseClientTransport`, `StdioMCPTransport`
`ai_sdk_provider`	(transitive)	Provider interfaces for building custom providers

ai_sdk_provider is a transitive dependency — you do not need to add it directly.

🚀 Quick Start #

Dart CLI #

dart pub add ai_sdk_dart ai_sdk_openai
export OPENAI_API_KEY=sk-...

import 'package:ai_sdk_dart/ai_sdk_dart.dart';
import 'package:ai_sdk_openai/ai_sdk_openai.dart';

void main() async {
  // Text generation
  final result = await generateText(
    model: openai('gpt-4.1-mini'),
    prompt: 'Say hello from AI SDK Dart!',
  );
  print(result.text);
}

Streaming #

final result = await streamText(
  model: openai('gpt-4.1-mini'),
  prompt: 'Count from 1 to 5.',
);
await for (final chunk in result.textStream) {
  stdout.write(chunk);
}

Structured Output #

final result = await generateText<Map<String, dynamic>>(
  model: openai('gpt-4.1-mini'),
  prompt: 'Return the capital and currency of Japan as JSON.',
  output: Output.object(
    schema: Schema<Map<String, dynamic>>(
      jsonSchema: const {
        'type': 'object',
        'properties': {
          'capital': {'type': 'string'},
          'currency': {'type': 'string'},
        },
      },
      fromJson: (json) => json,
    ),
  ),
);
print(result.output); // {capital: Tokyo, currency: JPY}

Type-Safe Tools #

final result = await generateText(
  model: openai('gpt-4.1-mini'),
  prompt: 'What is the weather in Paris?',
  maxSteps: 5,
  tools: {
    'getWeather': tool<Map<String, dynamic>, String>(
      description: 'Get current weather for a city.',
      inputSchema: Schema(
        jsonSchema: const {
          'type': 'object',
          'properties': {'city': {'type': 'string'}},
        },
        fromJson: (json) => json,
      ),
      execute: (input, _) async => 'Sunny, 18°C',
    ),
  },
);
print(result.text);

Flutter Chat UI #

dart pub add ai_sdk_dart ai_sdk_openai ai_sdk_flutter

import 'package:ai_sdk_flutter_ui/ai_sdk_flutter_ui.dart';

final chat = ChatController(model: openai('gpt-4.1-mini'));

// In your widget:
await chat.append('Tell me a joke');
print(chat.messages.last.content);

🤖 Providers #

Capability	OpenAI	Anthropic	Google
Text generation	✅	✅	✅
Streaming	✅	✅	✅
Structured output	✅	✅	✅
Tool use	✅	✅	✅
Embeddings	✅	—	✅
Image generation	✅	—	—
Speech synthesis	✅	—	—
Transcription	✅	—	—
Extended thinking	—	✅	—
Multimodal (image input)	✅	✅	✅

🛠️ Flutter UI Controllers #

The ai_sdk_flutter_ui package provides three reactive controllers that integrate with any Flutter state management approach.

ChatController — Multi-turn streaming chat #

final chat = ChatController(model: openai('gpt-4.1-mini'));

// In your widget:
ListenableBuilder(
  listenable: chat,
  builder: (context, _) {
    return Column(
      children: [
        for (final msg in chat.messages)
          Text('${msg.role}: ${msg.content}'),
        if (chat.isLoading) const CircularProgressIndicator(),
      ],
    );
  },
);

// Send a message:
await chat.append('What is the capital of France?');

CompletionController — Single-turn completion #

final completion = CompletionController(model: openai('gpt-4.1-mini'));
await completion.complete('Write a haiku about Dart.');
print(completion.text);

ObjectStreamController — Streaming typed JSON #

final controller = ObjectStreamController<Map<String, dynamic>>(
  model: openai('gpt-4.1-mini'),
  schema: Schema<Map<String, dynamic>>(
    jsonSchema: const {'type': 'object'},
    fromJson: (json) => json,
  ),
);
await controller.submit('Describe Japan as a JSON object.');
print(controller.object); // Partial updates arrive in real-time

🔌 MCP Support #

Connect to any Model Context Protocol server and use its tools directly in your AI calls:

import 'package:ai_sdk_mcp/ai_sdk_mcp.dart';

final client = MCPClient(
  transport: SseClientTransport(
    url: Uri.parse('http://localhost:3000/mcp'),
  ),
);

await client.initialize();
final tools = await client.tools(); // Returns a ToolSet

final result = await generateText(
  model: openai('gpt-4.1-mini'),
  prompt: 'What files are in the project?',
  tools: tools,
  maxSteps: 5,
);

For stdio-based MCP servers (local processes):

final client = MCPClient(
  transport: StdioMCPTransport(
    command: 'npx',
    args: ['-y', '@modelcontextprotocol/server-filesystem', '/path/to/dir'],
  ),
);

🗺️ Roadmap #

✅ Implemented #

✅ generateText — full result envelope (text, steps, usage, reasoning, sources, files)
✅ streamText — complete event taxonomy (22 typed event types)
✅ generateObject / structured output (object, array, choice, json)
✅ embed / embedMany + cosineSimilarity
✅ generateImage (OpenAI DALL-E 3)
✅ generateSpeech (OpenAI TTS)
✅ transcribe (OpenAI Whisper)
✅ rerank
✅ Middleware system with 5 built-in middlewares
✅ Provider registry (createProviderRegistry)
✅ Multi-step agentic loops with tool approval
✅ Flutter UI controllers (Chat, Completion, ObjectStream)
✅ MCP client (SSE + stdio transports)
✅ OpenAI, Anthropic, Google providers
✅ 178+ conformance tests

🔜 Planned #

🔜 Video generation support
🔜 Streaming MCP tool outputs + automatic reconnection
🔜 Cohere / Vertex AI / Mistral / Ollama providers
🔜 Additional Flutter widgets (file picker, reasoning display, citation cards)
🔜 Dart Edge / Cloudflare Workers support
🔜 WebSocket transport for MCP

🤝 Contributing #

Contributions are welcome! Please open an issue first to discuss changes before submitting a PR.

🐛 Bug reports — use the Bug Report template
💡 Feature requests — use the Feature Request template
💬 Questions & discussions — use GitHub Discussions

Running tests #

dart pub global activate melos
melos bootstrap
melos test       # run all package tests
melos analyze    # dart analyze across all packages

Or with the Makefile:

make get      # install all workspace dependencies
make test     # run all package tests
make analyze  # run dart analyze
make format   # format all Dart source files

Runnable examples #

Set API keys before running:

export OPENAI_API_KEY=sk-...
export ANTHROPIC_API_KEY=sk-ant-...
export GOOGLE_API_KEY=AIza...

Example	Command	What it shows
Dart CLI	`make run-basic`	`generateText`, streaming, structured output, tools, embeddings, middleware
Flutter chat	`make run`	ChatController, CompletionController, ObjectStreamController
Flutter chat (web)	`make run-web`	Same as above on Chrome
Advanced app	`make run-advanced`	All providers, image gen, TTS, STT, multimodal
Advanced app (web)	`make run-advanced-web`	Same as above on Chrome

Development #

Managed with Melos as a monorepo workspace:

dart pub global activate melos
melos bootstrap
melos analyze
melos test

See docs/v6-parity-matrix.md for a feature-by-feature parity matrix against Vercel AI SDK v6.

📄 License #

MIT

ai_sdk_dart 1.0.0+1 ai_sdk_dart: ^1.0.0+1 copied to clipboard

Metadata