MCP

npm i @modelcontextprotocol/sdk

import { createMcpClient } from '@deuz-sdk/core/mcp';

const client = await createMcpClient(options);

interface McpClientOptions {
  transport: McpHttpTransport;
  name?: string;
  version?: string;
  onElicitationRequest?: McpElicitationHandler;
}

interface McpHttpTransport {
  type: 'http' | 'sse';
  url: string;
  headers?: Record<string, string>;
}

import { createStdioMcpClient } from '@deuz-sdk/core/mcp/stdio';

const client = await createStdioMcpClient(options);

interface McpStdioOptions {
  command: string;
  args?: string[];
  env?: Record<string, string>;
  name?: string;
  version?: string;
  onElicitationRequest?: McpElicitationHandler; // same semantics as the HTTP client
}

interface McpClient {
  /** MCP tools mapped to a ToolSet ready for generateText({ tools }). */
  listTools(namespace?: string): Promise<ToolSet>;
  /** Call a tool directly (rarely needed; the loop uses execute). */
  callTool(name: string, args: unknown): Promise<unknown>;
  /** All resources / prompts, auto-paginated (cursor handled for you). */
  listResources(): Promise<McpResource[]>;
  readResource(uri: string): Promise<McpResourceContent[]>;
  listPrompts(): Promise<McpPrompt[]>;
  getPrompt(name: string, args?: Record<string, string>): Promise<McpGetPromptResult>;
  close(): Promise<void>;
}

const mcp = await createMcpClient({
  transport: { type: 'http', url: 'https://mcp.example.com/mcp' },
  onElicitationRequest: async (req) => {
    if (req.mode === 'form') {
      // req.requestedSchema: flat object, primitive props — render a form.
      const content = await showForm(req.message, req.requestedSchema);
      return content ? { action: 'accept', content } : { action: 'decline' };
    }
    // req.mode === 'url': show req.url to the user and ask for consent.
    // NEVER auto-open or prefetch it (spec requirement). accept = consent
    // only — the interaction completes out-of-band on the server's side.
    const consented = await confirmOpenUrl(req.message, req.url);
    return { action: consented ? 'accept' : 'decline' };
  },
});

import { generateText } from '@deuz-sdk/core';
import { createAnthropic } from '@deuz-sdk/core/anthropic';
import { createMcpClient } from '@deuz-sdk/core/mcp';

const anthropic = createAnthropic({ apiKey: process.env.ANTHROPIC_API_KEY! });

const mcp = await createMcpClient({
  transport: {
    type: 'http',
    url: 'https://mcp.example.com/mcp',
    headers: { Authorization: `Bearer ${process.env.MCP_TOKEN!}` },
  },
});

try {
  const tools = await mcp.listTools();

  const { text, steps } = await generateText({
    model: anthropic('claude-opus-4-8'),
    messages: [{ role: 'user', content: 'Scrape example.com and summarize it.' }],
    maxSteps: 5,
    tools,
  });

  console.log(text);
  console.log(steps?.length);
} finally {
  await mcp.close();
}

import { generateText } from '@deuz-sdk/core';
import { createAnthropic } from '@deuz-sdk/core/anthropic';
import { createStdioMcpClient } from '@deuz-sdk/core/mcp/stdio';

const anthropic = createAnthropic({ apiKey: process.env.ANTHROPIC_API_KEY! });

const mcp = await createStdioMcpClient({
  command: 'npx',
  args: ['-y', 'firecrawl-mcp'],
  env: { FIRECRAWL_API_KEY: process.env.FIRECRAWL_API_KEY! },
});

try {
  const tools = await mcp.listTools();

  const { text } = await generateText({
    model: anthropic('claude-opus-4-8'),
    messages: [{ role: 'user', content: 'Find the pricing page on example.com.' }],
    maxSteps: 5,
    tools,
  });

  console.log(text);
} finally {
  await mcp.close();
}

import { generateText } from '@deuz-sdk/core';
import { createAnthropic } from '@deuz-sdk/core/anthropic';
import { createMcpClient } from '@deuz-sdk/core/mcp';
import { z } from 'zod';

const anthropic = createAnthropic({ apiKey: process.env.ANTHROPIC_API_KEY! });

const search = await createMcpClient({
  transport: { type: 'http', url: 'https://search.example.com/mcp' },
});
const docs = await createMcpClient({
  transport: { type: 'sse', url: 'https://docs.example.com/v2/sse' },
});

try {
  const tools = {
    // Namespaced MCP tools: e.g. `search_query`, `docs_fetch`.
    ...(await search.listTools('search')),
    ...(await docs.listTools('docs')),
    // A local tool, defined inline with a Zod schema.
    now: {
      description: 'Return the current ISO timestamp.',
      parameters: z.object({}),
      execute: async () => ({ now: new Date().toISOString() }),
    },
  };

  const { text } = await generateText({
    model: anthropic('claude-opus-4-8'),
    messages: [{ role: 'user', content: 'What time is it, and what does example.com sell?' }],
    maxSteps: 6,
    tools,
  });

  console.log(text);
} finally {
  await Promise.all([search.close(), docs.close()]);
}

const result = await mcp.callTool('scrape', { url: 'https://example.com' });
console.log(result); // joined text content, or the raw blocks if there is no text