@fairyhunter13/ai-sdk 6.0.116-fork.1

package/docs/07-reference/01-ai-sdk-core/index.mdx

@@ -0,0 +1,160 @@
+---
+title: AI SDK Core
+description: Reference documentation for the AI SDK Core
+collapsed: true
+---
+
+# AI SDK Core
+
+[AI SDK Core](/docs/ai-sdk-core) is a set of functions that allow you to interact with language models and other AI models.
+These functions are designed to be easy-to-use and flexible, allowing you to generate text, structured data,
+and embeddings from language models and other AI models.
+
+AI SDK Core contains the following main functions:
+
+<IndexCards
+  cards={[
+    {
+      title: 'generateText()',
+      description: 'Generate text and call tools from a language model.',
+      href: '/docs/reference/ai-sdk-core/generate-text',
+    },
+    {
+      title: 'streamText()',
+      description: 'Stream text and call tools from a language model.',
+      href: '/docs/reference/ai-sdk-core/stream-text',
+    },
+    {
+      title: 'Output',
+      description: 'Structured output types for generateText and streamText.',
+      href: '/docs/reference/ai-sdk-core/output',
+    },
+    {
+      title: 'embed()',
+      description:
+        'Generate an embedding for a single value using an embedding model.',
+      href: '/docs/reference/ai-sdk-core/embed',
+    },
+    {
+      title: 'embedMany()',
+      description:
+        'Generate embeddings for several values using an embedding model (batch embedding).',
+      href: '/docs/reference/ai-sdk-core/embed-many',
+    },
+    {
+      title: 'generateImage()',
+      description:
+        'Generate images based on a given prompt using an image model.',
+      href: '/docs/reference/ai-sdk-core/generate-image',
+    },
+    {
+      title: 'experimental_generateVideo()',
+      description:
+        'Generate videos based on a given prompt using a video model.',
+      href: '/docs/reference/ai-sdk-core/generate-video',
+    },
+    {
+      title: 'experimental_transcribe()',
+      description: 'Generate a transcript from an audio file.',
+      href: '/docs/reference/ai-sdk-core/transcribe',
+    },
+    {
+      title: 'experimental_generateSpeech()',
+      description: 'Generate speech audio from text.',
+      href: '/docs/reference/ai-sdk-core/generate-speech',
+    },
+  ]}
+/>
+
+It also contains the following helper functions:
+
+<IndexCards
+  cards={[
+    {
+      title: 'tool()',
+      description: 'Type inference helper function for tools.',
+      href: '/docs/reference/ai-sdk-core/tool',
+    },
+    {
+      title: 'createMCPClient()',
+      description: 'Creates a client for connecting to MCP servers.',
+      href: '/docs/reference/ai-sdk-core/create-mcp-client',
+    },
+    {
+      title: 'jsonSchema()',
+      description: 'Creates AI SDK compatible JSON schema objects.',
+      href: '/docs/reference/ai-sdk-core/json-schema',
+    },
+    {
+      title: 'zodSchema()',
+      description: 'Creates AI SDK compatible Zod schema objects.',
+      href: '/docs/reference/ai-sdk-core/zod-schema',
+    },
+    {
+      title: 'createProviderRegistry()',
+      description:
+        'Creates a registry for using models from multiple providers.',
+      href: '/docs/reference/ai-sdk-core/provider-registry',
+    },
+    {
+      title: 'cosineSimilarity()',
+      description:
+        'Calculates the cosine similarity between two vectors, e.g. embeddings.',
+      href: '/docs/reference/ai-sdk-core/cosine-similarity',
+    },
+    {
+      title: 'simulateReadableStream()',
+      description:
+        'Creates a ReadableStream that emits values with configurable delays.',
+      href: '/docs/reference/ai-sdk-core/simulate-readable-stream',
+    },
+    {
+      title: 'wrapLanguageModel()',
+      description: 'Wraps a language model with middleware.',
+      href: '/docs/reference/ai-sdk-core/wrap-language-model',
+    },
+    {
+      title: 'wrapImageModel()',
+      description: 'Wraps an image model with middleware.',
+      href: '/docs/reference/ai-sdk-core/wrap-image-model',
+    },
+    {
+      title: 'extractReasoningMiddleware()',
+      description:
+        'Extracts reasoning from the generated text and exposes it as a `reasoning` property on the result.',
+      href: '/docs/reference/ai-sdk-core/extract-reasoning-middleware',
+    },
+    {
+      title: 'extractJsonMiddleware()',
+      description:
+        'Extracts JSON from text content by stripping markdown code fences.',
+      href: '/docs/reference/ai-sdk-core/extract-json-middleware',
+    },
+    {
+      title: 'simulateStreamingMiddleware()',
+      description:
+        'Simulates streaming behavior with responses from non-streaming language models.',
+      href: '/docs/reference/ai-sdk-core/simulate-streaming-middleware',
+    },
+    {
+      title: 'defaultSettingsMiddleware()',
+      description: 'Applies default settings to a language model.',
+      href: '/docs/reference/ai-sdk-core/default-settings-middleware',
+    },
+    {
+      title: 'smoothStream()',
+      description: 'Smooths text and reasoning streaming output.',
+      href: '/docs/reference/ai-sdk-core/smooth-stream',
+    },
+    {
+      title: 'generateId()',
+      description: 'Helper function for generating unique IDs',
+      href: '/docs/reference/ai-sdk-core/generate-id',
+    },
+    {
+      title: 'createIdGenerator()',
+      description: 'Creates an ID generator',
+      href: '/docs/reference/ai-sdk-core/create-id-generator',
+    },
+  ]}
+/>

package/docs/07-reference/02-ai-sdk-ui/01-use-chat.mdx

@@ -0,0 +1,493 @@
+---
+title: useChat
+description: API reference for the useChat hook.
+---
+
+# `useChat()`
+
+Allows you to easily create a conversational user interface for your chatbot application. It enables the streaming of chat messages from your AI provider, manages the chat state, and updates the UI automatically as new messages are received.
+
+<Note>
+  The `useChat` API has been significantly updated in AI SDK 5.0. It now uses a
+  transport-based architecture and no longer manages input state internally. See
+  the [migration
+  guide](/docs/migration-guides/migration-guide-5-0#usechat-changes) for
+  details.
+</Note>
+
+## Import
+
+<Tabs items={['React', 'Svelte', 'Vue', 'Angular']}>
+  <Tab>
+    <Snippet
+      text="import { useChat } from '@ai-sdk/react'"
+      dark
+      prompt={false}
+    />
+  </Tab>
+  <Tab>
+    <Snippet text="import { Chat } from '@ai-sdk/svelte'" dark prompt={false} />
+  </Tab>
+  <Tab>
+    <Snippet text="import { Chat } from '@ai-sdk/vue'" dark prompt={false} />
+  </Tab>
+  <Tab>
+    <Snippet
+      text="import { Chat } from '@ai-sdk/angular'"
+      dark
+      prompt={false}
+    />
+  </Tab>
+</Tabs>
+
+## API Signature
+
+### Parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: 'chat',
+      type: 'Chat<UIMessage>',
+      isOptional: true,
+      description:
+        'An existing Chat instance to use. If provided, other parameters are ignored.',
+    },
+    {
+      name: 'transport',
+      type: 'ChatTransport',
+      isOptional: true,
+      description:
+        'The transport to use for sending messages. Defaults to DefaultChatTransport with `/api/chat` endpoint.',
+      properties: [
+        {
+          type: 'DefaultChatTransport',
+          parameters: [
+            {
+              name: 'api',
+              type: "string = '/api/chat'",
+              isOptional: true,
+              description: 'The API endpoint for chat requests.',
+            },
+            {
+              name: 'credentials',
+              type: 'RequestCredentials',
+              isOptional: true,
+              description: 'The credentials mode for fetch requests.',
+            },
+            {
+              name: 'headers',
+              type: 'Record<string, string> | Headers',
+              isOptional: true,
+              description: 'HTTP headers to send with requests.',
+            },
+            {
+              name: 'body',
+              type: 'object',
+              isOptional: true,
+              description: 'Extra body object to send with requests.',
+            },
+            {
+              name: 'fetch',
+              type: 'FetchFunction',
+              isOptional: true,
+              description:
+                'Custom fetch implementation. You can use it as a middleware to intercept requests, or to provide a custom fetch implementation for e.g. testing.',
+            },
+            {
+              name: 'prepareSendMessagesRequest',
+              type: 'PrepareSendMessagesRequest',
+              isOptional: true,
+              description:
+                'A function to customize the request before chat API calls.',
+              properties: [
+                {
+                  type: 'PrepareSendMessagesRequest',
+                  parameters: [
+                    {
+                      name: 'options',
+                      type: 'PrepareSendMessageRequestOptions',
+                      description: 'Options for preparing the request',
+                      properties: [
+                        {
+                          type: 'PrepareSendMessageRequestOptions',
+                          parameters: [
+                            {
+                              name: 'id',
+                              type: 'string',
+                              description: 'The chat ID',
+                            },
+                            {
+                              name: 'messages',
+                              type: 'UIMessage[]',
+                              description: 'Current messages in the chat',
+                            },
+                            {
+                              name: 'requestMetadata',
+                              type: 'unknown',
+                              description: 'The request metadata',
+                            },
+                            {
+                              name: 'body',
+                              type: 'Record<string, any> | undefined',
+                              description: 'The request body',
+                            },
+                            {
+                              name: 'credentials',
+                              type: 'RequestCredentials | undefined',
+                              description: 'The request credentials',
+                            },
+                            {
+                              name: 'headers',
+                              type: 'HeadersInit | undefined',
+                              description: 'The request headers',
+                            },
+                            {
+                              name: 'api',
+                              type: 'string',
+                              description: `The API endpoint to use for the request. If not specified, it defaults to the transport’s API endpoint: /api/chat.`,
+                            },
+                            {
+                              name: 'trigger',
+                              type: "'submit-message' | 'regenerate-message'",
+                              description: 'The trigger for the request',
+                            },
+                            {
+                              name: 'messageId',
+                              type: 'string | undefined',
+                              description: 'The message ID if applicable',
+                            },
+                          ],
+                        },
+                      ],
+                    },
+                  ],
+                },
+              ],
+            },
+            {
+              name: 'prepareReconnectToStreamRequest',
+              type: 'PrepareReconnectToStreamRequest',
+              isOptional: true,
+              description:
+                'A function to customize the request before reconnect API call.',
+              properties: [
+                {
+                  type: 'PrepareReconnectToStreamRequest',
+                  parameters: [
+                    {
+                      name: 'options',
+                      type: 'PrepareReconnectToStreamRequestOptions',
+                      description:
+                        'Options for preparing the reconnect request',
+                      properties: [
+                        {
+                          type: 'PrepareReconnectToStreamRequestOptions',
+                          parameters: [
+                            {
+                              name: 'id',
+                              type: 'string',
+                              description: 'The chat ID',
+                            },
+                            {
+                              name: 'requestMetadata',
+                              type: 'unknown',
+                              description: 'The request metadata',
+                            },
+                            {
+                              name: 'body',
+                              type: 'Record<string, any> | undefined',
+                              description: 'The request body',
+                            },
+                            {
+                              name: 'credentials',
+                              type: 'RequestCredentials | undefined',
+                              description: 'The request credentials',
+                            },
+                            {
+                              name: 'headers',
+                              type: 'HeadersInit | undefined',
+                              description: 'The request headers',
+                            },
+                            {
+                              name: 'api',
+                              type: 'string',
+                              description: `The API endpoint to use for the request. If not specified, it defaults to the transport’s API endpoint combined with the chat ID: /api/chat/{chatId}/stream.`,
+                            },
+                          ],
+                        },
+                      ],
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    },
+    {
+      name: 'id',
+      type: 'string',
+      isOptional: true,
+      description:
+        'A unique identifier for the chat. If not provided, a random one will be generated.',
+    },
+    {
+      name: 'messages',
+      type: 'UIMessage[]',
+      isOptional: true,
+      description: 'Initial chat messages to populate the conversation with.',
+    },
+    {
+      name: 'messageMetadataSchema',
+      type: 'FlexibleSchema',
+      isOptional: true,
+      description: 'Schema for validating message metadata.',
+    },
+    {
+      name: 'dataPartSchemas',
+      type: 'UIDataTypesToSchemas',
+      isOptional: true,
+      description: 'Schemas for validating data parts in messages.',
+    },
+    {
+      name: 'generateId',
+      type: 'IdGenerator',
+      isOptional: true,
+      description:
+        'A function to generate unique IDs for messages and the chat. If not provided, the default AI SDK generateId is used.',
+    },
+    {
+      name: 'onToolCall',
+      type: '({toolCall: ToolCall}) => void | Promise<void>',
+      isOptional: true,
+      description:
+        'Optional callback function that is invoked when a tool call is received. You must call addToolOutput to provide the tool result.',
+    },
+    {
+      name: 'sendAutomaticallyWhen',
+      type: '(options: { messages: UIMessage[] }) => boolean | PromiseLike<boolean>',
+      isOptional: true,
+      description:
+        'When provided, this function will be called when the stream is finished or a tool call is added to determine if the current messages should be resubmitted. You can use the lastAssistantMessageIsCompleteWithToolCalls helper for common scenarios.',
+    },
+    {
+      name: 'onFinish',
+      type: '(options: OnFinishOptions) => void',
+      isOptional: true,
+      description: 'Called when the assistant response has finished streaming.',
+      properties: [
+        {
+          type: 'OnFinishOptions',
+          parameters: [
+            {
+              name: 'message',
+              type: 'UIMessage',
+              description: 'The response message.',
+            },
+            {
+              name: 'messages',
+              type: 'UIMessage[]',
+              description: 'All messages including the response message',
+            },
+            {
+              name: 'isAbort',
+              type: 'boolean',
+              description:
+                'True when the request has been aborted by the client.',
+            },
+            {
+              name: 'isDisconnect',
+              type: 'boolean',
+              description:
+                'True if the server has been disconnected, e.g. because of a network error.',
+            },
+            {
+              name: 'isError',
+              type: 'boolean',
+              description: `True if errors during streaming caused the response to stop early.`,
+            },
+            {
+              name: 'finishReason',
+              type: "'stop' | 'length' | 'content-filter' | 'tool-calls' | 'error' | 'other'",
+              isOptional: true,
+              description:
+                'The reason why the model finished generating the response. Undefined if the finish reason was not provided by the model.',
+            },
+          ],
+        },
+      ],
+    },
+    {
+      name: 'onError',
+      type: '(error: Error) => void',
+      isOptional: true,
+      description:
+        'Callback function to be called when an error is encountered.',
+    },
+    {
+      name: 'onData',
+      type: '(dataPart: DataUIPart) => void',
+      isOptional: true,
+      description:
+        'Optional callback function that is called when a data part is received.',
+    },
+    {
+      name: 'experimental_throttle',
+      type: 'number',
+      isOptional: true,
+      description:
+        'Custom throttle wait in ms for the chat messages and data updates. Default is undefined, which disables throttling.',
+    },
+    {
+      name: 'resume',
+      type: 'boolean',
+      isOptional: true,
+      description:
+        'Whether to resume an ongoing chat generation stream. Defaults to false.',
+    },
+  ]}
+/>
+
+### Returns
+
+<PropertiesTable
+  content={[
+    {
+      name: 'id',
+      type: 'string',
+      description: 'The id of the chat.',
+    },
+    {
+      name: 'messages',
+      type: 'UIMessage[]',
+      description: 'The current array of chat messages.',
+      properties: [
+        {
+          type: 'UIMessage',
+          parameters: [
+            {
+              name: 'id',
+              type: 'string',
+              description: 'A unique identifier for the message.',
+            },
+            {
+              name: 'role',
+              type: "'system' | 'user' | 'assistant'",
+              description: 'The role of the message.',
+            },
+            {
+              name: 'parts',
+              type: 'UIMessagePart[]',
+              description:
+                'The parts of the message. Use this for rendering the message in the UI.',
+            },
+            {
+              name: 'metadata',
+              type: 'unknown',
+              isOptional: true,
+              description: 'The metadata of the message.',
+            },
+          ],
+        },
+      ],
+    },
+    {
+      name: 'status',
+      type: "'submitted' | 'streaming' | 'ready' | 'error'",
+      description:
+        'The current status of the chat: "ready" (idle), "submitted" (request sent), "streaming" (receiving response), or "error" (request failed).',
+    },
+    {
+      name: 'error',
+      type: 'Error | undefined',
+      description: 'The error object if an error occurred.',
+    },
+    {
+      name: 'sendMessage',
+      type: '(message?: { text: string; files?: FileList | FileUIPart[]; metadata?; messageId?: string } | CreateUIMessage, options?: ChatRequestOptions) => Promise<void>',
+      description:
+        'Function to send a new message to the chat. This will trigger an API call to generate the assistant response. If a messageId is provided, the message will be replaced (useful for editing). If no message is provided, resubmits the current messages (useful after adding tool outputs).',
+      properties: [
+        {
+          type: 'ChatRequestOptions',
+          parameters: [
+            {
+              name: 'headers',
+              type: 'Record<string, string> | Headers',
+              isOptional: true,
+              description:
+                'Additional headers that should be to be passed to the API endpoint.',
+            },
+            {
+              name: 'body',
+              type: 'object',
+              isOptional: true,
+              description:
+                'Additional body JSON properties that should be sent to the API endpoint.',
+            },
+            {
+              name: 'metadata',
+              type: 'unknown',
+              isOptional: true,
+              description: 'Additional data to be sent to the API endpoint.',
+            },
+          ],
+        },
+      ],
+    },
+    {
+      name: 'regenerate',
+      type: '(options?: { messageId?: string } & ChatRequestOptions) => Promise<void>',
+      description:
+        'Function to regenerate the last assistant message or a specific message. If no messageId is provided, regenerates the last assistant message. Accepts ChatRequestOptions for headers, body, and metadata.',
+    },
+    {
+      name: 'stop',
+      type: '() => void',
+      description:
+        'Function to abort the current streaming response from the assistant.',
+    },
+    {
+      name: 'clearError',
+      type: '() => void',
+      description: 'Clears the error state.',
+    },
+    {
+      name: 'resumeStream',
+      type: '() => void',
+      description:
+        'Function to resume an interrupted streaming response. Useful when a network error occurs during streaming.',
+    },
+    {
+      name: 'addToolOutput',
+      type: '(options: { tool: string; toolCallId: string; output: unknown } | { tool: string; toolCallId: string; state: "output-error", errorText: string }) => void',
+      description:
+        'Function to add a tool result to the chat. This will update the chat messages with the tool result. If sendAutomaticallyWhen is configured, it may trigger an automatic submission.',
+    },
+    {
+      name: 'addToolApprovalResponse',
+      type: '(options: { id: string; approved: boolean; reason?: string }) => void | PromiseLike<void>',
+      description:
+        'Function to respond to a tool approval request. The id should match the approval id from the tool call. If sendAutomaticallyWhen is configured, it may trigger an automatic submission.',
+    },
+    {
+      name: 'addToolResult',
+      type: '(options: { tool: string; toolCallId: string; output: unknown } | { tool: string; toolCallId: string; state: "output-error", errorText: string }) => void',
+      description: 'Deprecated. Use addToolOutput instead.',
+    },
+    {
+      name: 'setMessages',
+      type: '(messages: UIMessage[] | ((messages: UIMessage[]) => UIMessage[])) => void',
+      description:
+        'Function to update the messages state locally without triggering an API call. Useful for optimistic updates.',
+    },
+  ]}
+/>
+
+## Learn more
+
+- [Chatbot](/docs/ai-sdk-ui/chatbot)
+- [Chatbot with Tools](/docs/ai-sdk-ui/chatbot-tool-usage)
+- [UIMessage](/docs/reference/ai-sdk-core/ui-message)