@assistant-ui/mcp-docs-server 0.1.31 → 0.1.33

package/.docs/raw/docs/(docs)/copilots/make-assistant-tool-ui.mdx

@@ -1,151 +0,0 @@
----
-title: makeAssistantToolUI
-description: Register custom UI components to render tool executions and their status.
-platforms: ["react"]
----
-
-<Callout type="info">
-  Prefer pre-registering tool UIs via the [`Tools()` API](/docs/guides/tools)
-  (set `render` on the tool definition) or by mounting `makeAssistantToolUI`
-  near the root of your tree. A tool UI that is only registered while a
-  specific component is mounted will not appear when chat history is replayed
-  or during server-side rendering, since the registering component may not be
-  mounted at that point. Tool execution can still be registered dynamically
-  via [`makeAssistantTool`](/docs/copilots/make-assistant-tool); this caveat
-  applies specifically to the UI render function.
-</Callout>
-
-The `makeAssistantToolUI` utility is used to register a tool UI component with the Assistant.
-
-## Usage
-
-```tsx
-import { makeAssistantToolUI } from "@assistant-ui/react";
-
-const MyToolUI = makeAssistantToolUI({
-  toolName: "myTool",
-  render: ({ args, result, status }) => {
-    // render your tool UI here
-  },
-});
-```
-
-## API
-
-### Parameters
-
-<ParametersTable
-  type="AssistantToolUIProps<TArgs, TResult>"
-  parameters={[
-    {
-      name: "toolName",
-      type: "string",
-      description:
-        "The name of the tool. This must match the name of the tool defined in the assistant.",
-    },
-    {
-      name: "render",
-      type: "ComponentType<ToolCallMessagePartProps<TArgs, TResult>>",
-      description:
-        "A React component that renders the tool UI. Receives the following props:",
-      required: true,
-      children: [
-        {
-          type: "ToolCallMessagePartProps<TArgs, TResult>",
-          parameters: [
-            {
-              name: "type",
-              type: '"tool-call"',
-              description: "The message part type",
-            },
-            {
-              name: "toolCallId",
-              type: "string",
-              description: "Unique identifier for this tool call",
-            },
-            {
-              name: "toolName",
-              type: "string",
-              description: "The name of the tool being called",
-            },
-            {
-              name: "args",
-              type: "TArgs",
-              description: "The arguments passed to the tool",
-            },
-            {
-              name: "argsText",
-              type: "string",
-              description: "String representation of the arguments",
-            },
-            {
-              name: "result",
-              type: "TResult | undefined",
-              description: "The result of the tool execution (if complete)",
-            },
-            {
-              name: "isError",
-              type: "boolean | undefined",
-              description: "Whether the result is an error",
-            },
-            {
-              name: "status",
-              type: "ToolCallMessagePartStatus",
-              description:
-                'The execution status object with a type property: "running", "complete", "incomplete", or "requires-action"',
-            },
-            {
-              name: "addResult",
-              type: "(result: TResult | ToolResponse<TResult>) => void",
-              description:
-                "Function to add a result (useful for human-in-the-loop tools)",
-            },
-            {
-              name: "artifact",
-              type: "unknown",
-              description:
-                "Optional artifact data associated with the tool call",
-            },
-          ],
-        },
-      ],
-    },
-  ]}
-/>
-
-### Returns
-
-A React functional component that should be included in your component tree. This component doesn't render anything itself, but it registers the tool UI with the Assistant.
-
-## Example
-
-```tsx
-import { makeAssistantToolUI } from "@assistant-ui/react";
-import { AssistantRuntimeProvider } from "@assistant-ui/react";
-
-const GetWeatherUI = makeAssistantToolUI({
-  toolName: "get_weather",
-  render: ({ args, result, status }) => {
-    if (status.type === "requires-action")
-      return <p>Getting weather for {args.location}...</p>;
-    if (status.type === "running") return <p>Loading...</p>;
-    if (status.type === "incomplete" && status.reason === "error")
-      return <p>Error getting weather.</p>;
-    if (status.type === "complete")
-      return <p>The weather is {result.weather}.</p>;
-    return null;
-  },
-});
-
-function App() {
-  const runtime = /* your runtime setup */;
-  return (
-    <AssistantRuntimeProvider runtime={runtime}>
-      {/* ...your other components */}
-      <GetWeatherUI />
-    </AssistantRuntimeProvider>
-  );
-}
-```
-
-This example shows how to create a simple UI for a `get_weather` tool. The UI will display different messages depending on the status of the tool execution.

package/.docs/raw/docs/(docs)/copilots/make-assistant-tool.mdx

@@ -1,230 +0,0 @@
----
-title: makeAssistantTool
-description: Create React components that provide reusable tools to the assistant.
-platforms: ["react"]
----
-
-<Callout type="info">
-  For most apps, the [`Tools()` API](/docs/guides/tools) is an easier starting
-  point: tool definitions live in a toolkit object rather than the component
-  tree. `makeAssistantTool` is fully supported and remains a good fit when a
-  tool's availability is tied to a component being mounted, for example a
-  product-specific tool that should only be exposed while that product's UI is
-  on screen (the [intelligent components](/docs/copilots/motivation) pattern).
-</Callout>
-
-`makeAssistantTool` creates a React component that provides a tool to the assistant. This is useful for defining reusable tools that can be composed into your application.
-
-## Usage
-
-```tsx
-import { makeAssistantTool, tool } from "@assistant-ui/react";
-import { z } from "zod";
-
-// Define the tool using the tool() helper
-const submitForm = tool({
-  parameters: z.object({
-    email: z.string().email(),
-    name: z.string(),
-  }),
-  execute: async ({ email, name }) => {
-    // Implementation
-    return { success: true };
-  },
-});
-
-// Create a tool component
-const SubmitFormTool = makeAssistantTool({
-  ...submitForm,
-  toolName: "submitForm",
-});
-
-// Use in your component
-function Form() {
-  return (
-    <div>
-      <form>{/* form fields */}</form>
-      <SubmitFormTool />
-    </div>
-  );
-}
-```
-
-## API Reference
-
-### Parameters
-
-<ParametersTable
-  type="AssistantToolProps<TArgs, TResult>"
-  parameters={[
-    {
-      name: "toolName",
-      type: "string",
-      description: "The unique identifier for the tool",
-      required: true,
-    },
-    {
-      name: "parameters",
-      type: "StandardSchemaV1<TArgs> | JSONSchema7",
-      description:
-        "Schema defining the tool's parameters (typically a Zod schema)",
-      required: true,
-    },
-    {
-      name: "execute",
-      type: "(args: TArgs, context: ToolExecutionContext) => TResult | Promise<TResult>",
-      description:
-        "Function that implements the tool's behavior (required for frontend tools)",
-      required: true,
-    },
-    {
-      name: "description",
-      type: "string",
-      description: "Optional description of the tool's purpose",
-    },
-    {
-      name: "render",
-      type: "ComponentType<ToolCallMessagePartProps<TArgs, TResult>>",
-      description:
-        "Optional custom UI component for rendering the tool execution. Receives the following props:",
-      children: [
-        {
-          type: "ToolCallMessagePartProps<TArgs, TResult>",
-          parameters: [
-            {
-              name: "type",
-              type: '"tool-call"',
-              description: "The message part type",
-            },
-            {
-              name: "toolCallId",
-              type: "string",
-              description: "Unique identifier for this tool call",
-            },
-            {
-              name: "toolName",
-              type: "string",
-              description: "The name of the tool being called",
-            },
-            {
-              name: "args",
-              type: "TArgs",
-              description: "The arguments passed to the tool",
-            },
-            {
-              name: "argsText",
-              type: "string",
-              description: "String representation of the arguments",
-            },
-            {
-              name: "result",
-              type: "TResult | undefined",
-              description: "The result of the tool execution (if complete)",
-            },
-            {
-              name: "isError",
-              type: "boolean | undefined",
-              description: "Whether the result is an error",
-            },
-            {
-              name: "status",
-              type: "ToolCallMessagePartStatus",
-              description:
-                'The execution status object with a type property: "running", "complete", "incomplete", or "requires-action"',
-            },
-            {
-              name: "addResult",
-              type: "(result: TResult | ToolResponse<TResult>) => void",
-              description:
-                "Function to add a result (useful for human-in-the-loop tools)",
-            },
-            {
-              name: "artifact",
-              type: "unknown",
-              description:
-                "Optional artifact data associated with the tool call",
-            },
-          ],
-        },
-      ],
-    },
-  ]}
-/>
-
-### Returns
-
-Returns a React component that:
-
-- Provides the tool to the assistant when mounted
-- Automatically removes the tool when unmounted
-- Renders nothing in the DOM (returns null)
-
-## Example with Multiple Tools
-
-```tsx
-import { makeAssistantTool, tool } from "@assistant-ui/react";
-import { z } from "zod";
-
-// Define tools
-const validateEmail = tool({
-  parameters: z.object({
-    email: z.string(),
-  }),
-  execute: ({ email }) => {
-    const isValid = email.includes("@");
-    return { isValid, reason: isValid ? "Valid email" : "Missing @" };
-  },
-});
-
-const sendEmail = tool({
-  parameters: z.object({
-    to: z.string().email(),
-    subject: z.string(),
-    body: z.string(),
-  }),
-  execute: async (params) => {
-    // Tool logic
-    return { sent: true };
-  },
-});
-
-// Create tool components
-const EmailValidator = makeAssistantTool({
-  ...validateEmail,
-  toolName: "validateEmail",
-});
-const EmailSender = makeAssistantTool({
-  ...sendEmail,
-  toolName: "sendEmail",
-});
-
-// Use together
-function EmailForm() {
-  return (
-    <div>
-      <form>{/* form fields */}</form>
-      <EmailValidator />
-      <EmailSender />
-    </div>
-  );
-}
-```
-
-## Best Practices
-
-1. **Parameter Validation**
-
-   - Always use Zod schemas to define parameters
-   - Be specific about parameter types and constraints
-   - Add helpful error messages to schema validations
-
-2. **Error Handling**
-
-   - Return meaningful error messages
-   - Consider returning partial results when possible
-   - Handle async errors appropriately
-
-3. **Composition**
-   - Break complex tools into smaller, focused ones
-   - Consider tool dependencies and interactions
-   - Use multiple tools together for complex functionality

package/.docs/raw/docs/(reference)/api-reference/adapters/feedback-speech.mdx

@@ -1,41 +0,0 @@
----
-title: Feedback and Speech Adapters
-description: Capture message feedback and connect speech or dictation.
----
-
-## Feedback
-
-`FeedbackAdapter` receives message feedback submitted through action primitives or runtime actions.
-
-```tsx
-const runtime = useLocalRuntime(chatModelAdapter, {
-  adapters: {
-    feedback: {
-      submit: async ({ message, type }) => {
-        await fetch("/api/feedback", {
-          method: "POST",
-          body: JSON.stringify({ messageId: message.id, type }),
-        });
-      },
-    },
-  },
-});
-```
-
-## Speech
-
-`SpeechSynthesisAdapter` controls text-to-speech playback. `WebSpeechSynthesisAdapter` provides a browser implementation.
-
-```tsx
-import { WebSpeechSynthesisAdapter } from "@assistant-ui/react";
-
-const runtime = useLocalRuntime(chatModelAdapter, {
-  adapters: {
-    speech: new WebSpeechSynthesisAdapter(),
-  },
-});
-```
-
-## Dictation and Suggestions
-
-Runtime adapters can also provide dictation and suggestion behavior. Dictation powers composer voice input; suggestions power prompt suggestions rendered by thread and suggestion primitives.

package/.docs/raw/docs/(reference)/api-reference/context-providers/text-message-part-provider.mdx

@@ -1,40 +0,0 @@
----
-title: <TextMessagePartProvider />
-description: Context provider for reusing text components outside of message content.
----
-
-The `TextMessagePartProvider` provides data and APIs for `TextMessagePart` components.
-
-This is useful if you want to reuse the same `Text` component outside of a message text, e.g. with the `@assistant-ui/react-markdown` package.
-
-```tsx
-import { TextMessagePartProvider } from "@assistant-ui/react";
-
-const MyApp = () => {
-  return (
-    <TextMessagePartProvider text={"Hello!"}>
-      <MyMarkdownText />
-    </TextMessagePartProvider>
-  );
-};
-```
-
-#### Properties
-
-<ParametersTable
-  type="TextMessagePartProviderProps"
-  parameters={[
-    {
-      name: "text",
-      type: "string",
-      required: true,
-      description: "The text content to provide to child components.",
-    },
-    {
-      name: "isRunning",
-      type: "boolean",
-      required: false,
-      description: "Whether the text is still being streamed. Defaults to false.",
-    },
-  ]}
-/>