@fairyhunter13/ai-sdk 6.0.116-fork.1

package/docs/02-getting-started/09-coding-agents.mdx

@@ -0,0 +1,179 @@
+---
+title: Coding Agents
+description: Learn how to set up the AI SDK for use with coding agents, including installing skills, accessing bundled docs, and using DevTools.
+---
+
+# Getting Started with Coding Agents
+
+This page explains how to get the most out of the AI SDK when working inside a coding agent (such as Claude Code, Codex, OpenCode, Cursor, or any other AI-assisted development environment).
+
+## Install the AI SDK Skill
+
+The fastest way to give your coding agent deep knowledge of the AI SDK is to install the official AI SDK skill. Skills are lightweight markdown files that load specialized instructions into your agent's context on demand — so your agent knows exactly how to use the SDK without you needing to explain it.
+
+Install the AI SDK skill using `npx skills add`:
+
+```bash
+npx skills add vercel/ai
+```
+
+This installs the skill into your agent's specific skills directory (e.g., `.claude/skills`, `.codex/skills`). If you select more than one agent, the CLI creates symlinks so each agent can discover the skill. Use `-a` to specify agents directly — for example, `-a amp` installs into the universal `.agents/skills` directory. Use `-y` for non-interactive installation.
+
+Once installed, any agent that supports the [Agent Skills](https://agentskills.io) format will automatically discover and load the skill when working on AI SDK tasks.
+
+<Note>
+  Agent Skills use **progressive disclosure**: your agent loads only the skill's
+  name and description at startup. The full instructions are only pulled into
+  context when the task calls for it, keeping your agent fast and focused.
+</Note>
+
+## Docs and Source Code in `node_modules`
+
+Once you've installed the `ai` package, you already have the full AI SDK documentation and source code available locally inside `node_modules`. Your coding agent can read these directly — no internet access required.
+
+Install the `ai` package if you haven't already:
+
+<div className="my-4">
+  <Tabs items={['pnpm', 'npm', 'yarn', 'bun']}>
+    <Tab>
+      <Snippet text="pnpm add ai" dark />
+    </Tab>
+    <Tab>
+      <Snippet text="npm install ai" dark />
+    </Tab>
+    <Tab>
+      <Snippet text="yarn add ai" dark />
+    </Tab>
+    <Tab>
+      <Snippet text="bun add ai" dark />
+    </Tab>
+  </Tabs>
+</div>
+
+After installation, your agent can reference the bundled source code and documentation at paths like:
+
+```
+node_modules/ai/src/              # Full source code organized by module
+node_modules/ai/docs/             # Official documentation with examples
+```
+
+This means your agent can look up accurate API signatures, implementations, and usage examples directly from the installed package — ensuring it always uses the version of the SDK that's actually installed in your project.
+
+## Install DevTools
+
+AI SDK DevTools gives you full visibility into your AI SDK calls during development. It captures LLM requests, responses, tool calls, token usage, and multi-step interactions, and displays them in a local web UI.
+
+<Note type="warning">
+  AI SDK DevTools is experimental and intended for local development only. Do
+  not use in production environments.
+</Note>
+
+Install the DevTools package:
+
+<div className="my-4">
+  <Tabs items={['pnpm', 'npm', 'yarn', 'bun']}>
+    <Tab>
+      <Snippet text="pnpm add @ai-sdk/devtools" dark />
+    </Tab>
+    <Tab>
+      <Snippet text="npm install @ai-sdk/devtools" dark />
+    </Tab>
+    <Tab>
+      <Snippet text="yarn add @ai-sdk/devtools" dark />
+    </Tab>
+    <Tab>
+      <Snippet text="bun add @ai-sdk/devtools" dark />
+    </Tab>
+  </Tabs>
+</div>
+
+### Add the middleware
+
+Wrap your language model with the DevTools middleware using [`wrapLanguageModel`](/docs/ai-sdk-core/middleware):
+
+```ts
+import { wrapLanguageModel, gateway } from 'ai';
+import { devToolsMiddleware } from '@ai-sdk/devtools';
+
+const model = wrapLanguageModel({
+  model: gateway('anthropic/claude-sonnet-4.5'),
+  middleware: devToolsMiddleware(),
+});
+```
+
+Use the wrapped model with any AI SDK Core function:
+
+```ts
+import { generateText } from 'ai';
+
+const result = await generateText({
+  model, // wrapped model with DevTools middleware
+  prompt: 'What cities are in the United States?',
+});
+```
+
+### Launch the viewer
+
+Start the DevTools viewer in a separate terminal:
+
+```bash
+npx @ai-sdk/devtools
+```
+
+Open [http://localhost:4983](http://localhost:4983) to inspect your AI SDK interactions in real time.
+
+## Inspecting Tool Calls and Outputs
+
+DevTools captures and displays the following for every call:
+
+- **Input parameters and prompts** — the complete input sent to your LLM
+- **Output content and tool calls** — generated text and tool invocations
+- **Token usage and timing** — resource consumption and latency per step
+- **Raw provider data** — complete request and response payloads
+
+For multi-step agent interactions, DevTools groups everything into **runs** (a complete interaction) and **steps** (each individual LLM call within it), making it easy to trace exactly what your agent did and why.
+
+You can also log tool results directly in code during development:
+
+```ts
+import { streamText, tool, stepCountIs } from 'ai';
+import { z } from 'zod';
+
+const result = streamText({
+  model,
+  prompt: "What's the weather in New York in celsius?",
+  tools: {
+    weather: tool({
+      description: 'Get the weather in a location (fahrenheit)',
+      inputSchema: z.object({
+        location: z.string().describe('The location to get the weather for'),
+      }),
+      execute: async ({ location }) => ({
+        location,
+        temperature: Math.round(Math.random() * (90 - 32) + 32),
+      }),
+    }),
+  },
+  stopWhen: stepCountIs(5),
+  onStepFinish: async ({ toolResults }) => {
+    if (toolResults.length) {
+      console.log(JSON.stringify(toolResults, null, 2));
+    }
+  },
+});
+```
+
+The `onStepFinish` callback fires after each LLM step and prints any tool results to your terminal — useful for quick debugging without opening the DevTools UI.
+
+<Note>
+  DevTools stores all AI interactions in a local `.devtools/generations.json`
+  file. It automatically adds `.devtools` to your `.gitignore` to prevent
+  committing sensitive interaction data.
+</Note>
+
+## Where to Next?
+
+- Learn about [Agent Skills](https://agentskills.io/specification) to understand the full skill format.
+- Read the [DevTools reference](/docs/ai-sdk-core/devtools) for a complete list of captured data and configuration options.
+- Explore [Tools and Tool Calling](/docs/ai-sdk-core/tools-and-tool-calling) to build agents that can take real-world actions.
+- Check out the [Add Skills to Your Agent](/cookbook/guides/agent-skills) cookbook guide for a step-by-step integration walkthrough.

package/docs/02-getting-started/index.mdx

@@ -0,0 +1,44 @@
+---
+title: Getting Started
+description: Welcome to the AI SDK documentation!
+---
+
+# Getting Started
+
+The following guides are intended to provide you with an introduction to some of the core features provided by the AI SDK.
+
+<QuickstartFrameworkCards />
+
+## Backend Framework Examples
+
+You can also use [AI SDK Core](/docs/ai-sdk-core/overview) and [AI SDK UI](/docs/ai-sdk-ui/overview) with the following backend frameworks:
+
+<IndexCards
+  cards={[
+    {
+      title: 'Node.js HTTP Server',
+      description: 'Send AI responses from a Node.js HTTP server.',
+      href: '/examples/api-servers/node-js-http-server',
+    },
+    {
+      title: 'Express',
+      description: 'Send AI responses from an Express server.',
+      href: '/examples/api-servers/express',
+    },
+    {
+      title: 'Hono',
+      description: 'Send AI responses from a Hono server.',
+      href: '/examples/api-servers/hono',
+    },
+    {
+      title: 'Fastify',
+      description: 'Send AI responses from a Fastify server.',
+      href: '/examples/api-servers/fastify',
+    },
+    {
+      title: 'Nest.js',
+      description: 'Send AI responses from a Nest.js server.',
+      href: '/examples/api-servers/nest',
+    },
+  ]}
+/>

package/docs/03-agents/01-overview.mdx

@@ -0,0 +1,96 @@
+---
+title: Overview
+description: Learn how to build agents with the AI SDK.
+---
+
+# Agents
+
+Agents are **large language models (LLMs)** that use **tools** in a **loop** to accomplish tasks.
+
+These components work together:
+
+- **LLMs** process input and decide the next action
+- **Tools** extend capabilities beyond text generation (reading files, calling APIs, writing to databases)
+- **Loop** orchestrates execution through:
+  - **Context management** - Maintaining conversation history and deciding what the model sees (input) at each step
+  - **Stopping conditions** - Determining when the loop (task) is complete
+
+## ToolLoopAgent Class
+
+The ToolLoopAgent class handles these three components. Here's an agent that uses multiple tools in a loop to accomplish a task:
+
+```ts
+import { ToolLoopAgent, stepCountIs, tool } from 'ai';
+__PROVIDER_IMPORT__;
+import { z } from 'zod';
+
+const weatherAgent = new ToolLoopAgent({
+  model: __MODEL__,
+  tools: {
+    weather: tool({
+      description: 'Get the weather in a location (in Fahrenheit)',
+      inputSchema: z.object({
+        location: z.string().describe('The location to get the weather for'),
+      }),
+      execute: async ({ location }) => ({
+        location,
+        temperature: 72 + Math.floor(Math.random() * 21) - 10,
+      }),
+    }),
+    convertFahrenheitToCelsius: tool({
+      description: 'Convert temperature from Fahrenheit to Celsius',
+      inputSchema: z.object({
+        temperature: z.number().describe('Temperature in Fahrenheit'),
+      }),
+      execute: async ({ temperature }) => {
+        const celsius = Math.round((temperature - 32) * (5 / 9));
+        return { celsius };
+      },
+    }),
+  },
+  // Agent's default behavior is to stop after a maximum of 20 steps
+  // stopWhen: stepCountIs(20),
+});
+
+const result = await weatherAgent.generate({
+  prompt: 'What is the weather in San Francisco in celsius?',
+});
+
+console.log(result.text); // agent's final answer
+console.log(result.steps); // steps taken by the agent
+```
+
+The agent automatically:
+
+1. Calls the `weather` tool to get the temperature in Fahrenheit
+2. Calls `convertFahrenheitToCelsius` to convert it
+3. Generates a final text response with the result
+
+The ToolLoopAgent handles the loop, context management, and stopping conditions.
+
+## Why Use the ToolLoopAgent?
+
+The ToolLoopAgent is the recommended approach for building agents with the AI SDK because it:
+
+- **Reduces boilerplate** - Manages loops and message arrays
+- **Improves reusability** - Define once, use throughout your application
+- **Simplifies maintenance** - Single place to update agent configuration
+
+For most use cases, start with the ToolLoopAgent. Use core functions (`generateText`, `streamText`) when you need explicit control over each step for complex structured workflows.
+
+## Structured Workflows
+
+Agents are flexible and powerful, but non-deterministic. When you need reliable, repeatable outcomes with explicit control flow, use core functions with structured workflow patterns combining:
+
+- Conditional statements for explicit branching
+- Standard functions for reusable logic
+- Error handling for robustness
+- Explicit control flow for predictability
+
+[Explore workflow patterns](/docs/agents/workflows) to learn more about building structured, reliable systems.
+
+## Next Steps
+
+- **[Building Agents](/docs/agents/building-agents)** - Guide to creating agents with the ToolLoopAgent
+- **[Workflow Patterns](/docs/agents/workflows)** - Structured patterns using core functions for complex workflows
+- **[Loop Control](/docs/agents/loop-control)** - Execution control with stopWhen and prepareStep