@assistant-ui/mcp-docs-server 0.2.3 → 0.3.1

package/.docs/raw/docs/guides/chain-of-thought.mdx

@@ -1,164 +0,0 @@
----
-title: Chain of Thought UI
-description: Show AI reasoning steps and tool calls in a collapsible thinking accordion. Build chain-of-thought visualizations in React chat with assistant-ui.
-platforms: ["react"]
----
-
-LLMs often produce reasoning steps and tool calls in succession. Chain of Thought lets you visually group these consecutive parts into a single collapsible accordion, giving users a clean "thinking" UI.
-
-## Overview
-
-When a reasoning model responds, it may emit a sequence of reasoning tokens and tool calls before producing its final text answer. Use `MessagePrimitive.GroupedParts` to group those adjacent reasoning and tool-call parts into a single collapsible "thinking" section.
-
-<Callout type="info">
-The older `components.ChainOfThought` prop on `MessagePrimitive.Parts` and `components` prop on `ChainOfThoughtPrimitive.Parts` are legacy APIs. They still work for existing code, but new code should use `MessagePrimitive.GroupedParts`.
-</Callout>
-
-## Quick Start
-
-<Steps>
-  <Step>
-
-### Wire GroupedParts into your assistant message
-
-Return the same top-level group for reasoning and tool calls, with nested groups for each type:
-
-```tsx
-import {
-  MessagePrimitive,
-  groupPartByType,
-} from "@assistant-ui/react";
-import { MarkdownText } from "@/components/assistant-ui/markdown-text";
-import {
-  Reasoning,
-  ReasoningContent,
-  ReasoningRoot,
-  ReasoningText,
-  ReasoningTrigger,
-} from "@/components/assistant-ui/reasoning";
-import { ToolFallback } from "@/components/assistant-ui/tool-fallback";
-import {
-  ToolGroupContent,
-  ToolGroupRoot,
-  ToolGroupTrigger,
-} from "@/components/assistant-ui/tool-group";
-import type { FC } from "react";
-
-const AssistantMessage: FC = () => {
-  return (
-    <MessagePrimitive.Root>
-      <MessagePrimitive.GroupedParts
-        groupBy={groupPartByType({
-          reasoning: ["group-chainOfThought", "group-reasoning"],
-          "tool-call": ["group-chainOfThought", "group-tool"],
-        })}
-      >
-        {({ part, children }) => {
-          switch (part.type) {
-            case "group-chainOfThought":
-              return <div className="my-2">{children}</div>;
-            case "group-reasoning": {
-              const running = part.status.type === "running";
-              return (
-                <ReasoningRoot streaming={running}>
-                  <ReasoningTrigger active={running} />
-                  <ReasoningContent aria-busy={running}>
-                    <ReasoningText>{children}</ReasoningText>
-                  </ReasoningContent>
-                </ReasoningRoot>
-              );
-            }
-            case "group-tool":
-              return (
-                <ToolGroupRoot>
-                  <ToolGroupTrigger
-                    count={part.indices.length}
-                    active={part.status.type === "running"}
-                  />
-                  <ToolGroupContent>{children}</ToolGroupContent>
-                </ToolGroupRoot>
-              );
-            case "text":
-              return <MarkdownText />;
-            case "reasoning":
-              return <Reasoning {...part} />;
-            case "tool-call":
-              return part.toolUI ?? <ToolFallback {...part} />;
-            default:
-              return null;
-          }
-        }}
-      </MessagePrimitive.GroupedParts>
-    </MessagePrimitive.Root>
-  );
-};
-```
-
-  </Step>
-  <Step>
-
-### Use a Reasoning Model
-
-Chain of Thought is most useful with models that produce reasoning tokens. Here's an example backend route using the AI SDK:
-
-```tsx title="app/api/chat/route.ts"
-import { openai } from "@ai-sdk/openai";
-import { streamText, convertToModelMessages } from "ai";
-
-export async function POST(req: Request) {
-  const { messages } = await req.json();
-
-  const result = streamText({
-    model: openai("gpt-5.6-luna"),
-    messages: await convertToModelMessages(messages),
-  });
-
-  return result.toUIMessageStreamResponse();
-}
-```
-
-  </Step>
-</Steps>
-
-## LangGraph
-
-Chain-of-thought parts are surfaced by the AI SDK's built-in reasoning stream. LangGraph does not emit reasoning tokens in that format, so reasoning grouping will not activate automatically. If you want to display reasoning text from a LangGraph agent, emit it as a custom data part from your graph and render it with `makeAssistantDataUI`. See [generative UI with LangGraph](/docs/runtimes/langgraph/generative-ui) for details.
-
-## Legacy: ChainOfThoughtPrimitive
-
-### Reading Collapsed State
-
-For existing `ChainOfThoughtPrimitive` code, use `AuiIf` to conditionally render based on the accordion state:
-
-```tsx
-import { AuiIf, ChainOfThoughtPrimitive } from "@assistant-ui/react";
-import { ChevronDownIcon, ChevronRightIcon } from "lucide-react";
-
-const ChainOfThoughtAccordionTrigger = () => {
-  return (
-    <ChainOfThoughtPrimitive.AccordionTrigger className="flex w-full cursor-pointer items-center gap-2 px-4 py-2 text-sm">
-      <AuiIf condition={(s) => s.chainOfThought.collapsed}>
-        <ChevronRightIcon className="size-4" />
-      </AuiIf>
-      <AuiIf condition={(s) => !s.chainOfThought.collapsed}>
-        <ChevronDownIcon className="size-4" />
-      </AuiIf>
-      Thinking
-    </ChainOfThoughtPrimitive.AccordionTrigger>
-  );
-};
-```
-
-### API Reference
-
-For lower-level legacy compatibility details, see the [`ChainOfThought` primitive reference](/docs/primitives/chain-of-thought).
-
-## Full Example
-
-See the complete [with-chain-of-thought example](https://github.com/assistant-ui/assistant-ui/tree/main/examples/with-chain-of-thought) for a working implementation with tool calls and reasoning.
-
-## Related Guides
-
-- [Reasoning](/docs/ui/reasoning) — reasoning UI primitives for grouped parts
-- [Generative UI](/docs/tools/tool-ui) — custom UI for tool calls
-- [Tools](/docs/tools/defining-tools) — defining and using tools

package/.docs/raw/docs/guides/chatgpt-subscription.mdx

@@ -1,108 +0,0 @@
----
-title: ChatGPT Subscription
-description: Run your assistant-ui app on your ChatGPT Plus or Pro subscription via Codex OAuth. Local development without an OpenAI API key.
-platforms: ["react"]
----
-
-If you have a ChatGPT Plus or Pro subscription, you can run your assistant-ui app against it locally instead of paying per token with an API key. OpenAI's Codex CLI authenticates via OAuth and caches tokens on your machine; requests made with those tokens hit the Responses API endpoint at `chatgpt.com` and bill to your plan. The same mechanism powers Codex itself and a growing set of local agents.
-
-This is a personal-use setup for apps running on your own machine. For anything deployed or shared, use an API key.
-
-## Log in with Codex
-
-Authenticate once with the Codex CLI. The login flow runs OAuth in your browser and writes access and refresh tokens to `~/.codex/auth.json`:
-
-```sh
-npx @openai/codex login
-```
-
-Everything below reads that file; no environment variables or API keys are involved.
-
-## AI SDK route
-
-The community AI SDK provider [`openai-oauth-provider`](https://github.com/EvanZhouDev/openai-oauth) picks up `~/.codex/auth.json` automatically, refreshes tokens as needed, and supports streaming, tool calls, and reasoning traces.
-
-```sh
-npm install openai-oauth-provider
-```
-
-In your chat route, swap `@ai-sdk/openai` for the OAuth provider. Starting from the default assistant-ui template route, only the model changes; `frontendTools` and the UI message stream response work as before:
-
-```ts title="/app/api/chat/route.ts" {10}
-import { createOpenAIOAuth } from "openai-oauth-provider";
-import { frontendTools } from "@assistant-ui/ai-sdk";
-import {
-  type JSONSchema7,
-  streamText,
-  convertToModelMessages,
-  type UIMessage,
-} from "ai";
-
-const openai = createOpenAIOAuth();
-
-export async function POST(req: Request) {
-  const {
-    messages,
-    system,
-    tools,
-  }: {
-    messages: UIMessage[];
-    system?: string;
-    tools?: Record<string, { description?: string; parameters: JSONSchema7 }>;
-  } = await req.json();
-
-  const result = streamText({
-    model: openai("gpt-5.3-codex"),
-    messages: await convertToModelMessages(messages),
-    system,
-    tools: {
-      ...frontendTools(tools ?? {}),
-    },
-  });
-
-  return result.toUIMessageStreamResponse({
-    sendReasoning: true,
-  });
-}
-```
-
-The provider discovers which models your plan includes (for example `gpt-5.4` and `gpt-5.3-codex`) from your ChatGPT account.
-
-## Eve agents
-
-Eve's `defineAgent` accepts a provider-authored AI SDK `LanguageModel`, so the same provider drops into an eve agent config:
-
-```ts title="agent/agent.ts"
-import { defineAgent } from "eve";
-import { createOpenAIOAuth } from "openai-oauth-provider";
-
-export default defineAgent({
-  model: createOpenAIOAuth()("gpt-5.3-codex"),
-});
-```
-
-## OpenAI-compatible proxy
-
-For stacks that take an OpenAI base URL rather than an AI SDK model, the same project publishes a sibling package, `openai-oauth`, whose CLI runs a local proxy:
-
-```sh
-npx openai-oauth
-# OpenAI-compatible endpoint ready at http://127.0.0.1:10531/v1
-```
-
-Point any OpenAI-compatible client at that URL. No real API key is involved, but most clients require one at construction, so pass a placeholder:
-
-```ts
-import { OpenAI } from "openai";
-
-const openai = new OpenAI({
-  baseURL: "http://127.0.0.1:10531/v1",
-  apiKey: "unused",
-});
-```
-
-The proxy binds to `127.0.0.1` by default; keep it that way, since any caller that can reach the endpoint bills your subscription.
-
-<Callout type="warn">
-  Your OAuth tokens live in `~/.codex/auth.json`, so this only works where that file exists. A deployed instance would bill every visitor to your subscription. `openai-oauth-provider` is an unofficial community package, available models depend on your ChatGPT plan, and OpenAI sanctions this auth flow for Codex tooling, so treat it as personal use.
-</Callout>