Migrating from 0.x

import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js'

throw new McpError(ErrorCode.InvalidParams, 'Bad argument')

import { ProtocolError, ProtocolErrorCode } from '@modelcontextprotocol/server'

throw new ProtocolError(ProtocolErrorCode.InvalidParams, 'Bad argument')

import { ProtocolError, ProtocolErrorCode } from '@modelcontextprotocol/server'

try {
  await client.readResource('config://missing')
} catch (err) {
  if (err instanceof ProtocolError && err.code === ProtocolErrorCode.InvalidParams) {
    // -32602 — an unknown resource reports here now, not -32002
  }
}

import { Client } from '@prefecthq/fastmcp-ts/client'

// 0.x auto-detected SSE from the URL.
const client = await Client.connect('http://localhost:3000/sse')

import { Client } from '@prefecthq/fastmcp-ts/client'

// 1.0 needs the explicit opt-in for an SSE endpoint.
const client = await Client.connect('http://localhost:3000/sse', { legacySSE: true })

import { FastMCP } from '@prefecthq/fastmcp-ts/server'

const server = new FastMCP({
  name: 'my-server',
  dnsRebinding: {
    allowedHosts: ['mcp.example.com'],
    allowedOrigins: ['https://app.example.com'],
  },
})

await server.run({ transport: 'http', port: 3000 })

// 0.x exposed the server on every interface by default.
await server.run({ transport: 'http', port: 3000 })

// 1.0 binds loopback by default; set the host to expose the server.
await server.run({ transport: 'http', host: '0.0.0.0', port: 3000 })

import { Client } from '@prefecthq/fastmcp-ts/client'

const client = await Client.connect('http://localhost:3000')

import { Client } from '@prefecthq/fastmcp-ts/client'

// Default: modern when the server offers it, legacy fallback when it is 0.x-only.
const client = await Client.connect('http://localhost:3000')

client.getProtocolEra()   // 'modern' or 'legacy'

// Opt out: byte-identical to the 0.x connect sequence, no probe.
const legacyClient = await Client.connect('http://localhost:3000', {
  versionNegotiation: { mode: 'legacy' },
})

server.tool({ name: 'stash', description: 'Remember a value for later calls' }, (args: Record<string, unknown>) => {
  const ctx = server.getContext()
  ctx.setState('blob', args.data)   // 1.0: throws on a modern HTTP request
  return 'stored'
})

import { randomUUID } from 'node:crypto'

const store = new Map<string, unknown>()

server.tool({ name: 'stash', description: 'Store a value and return a handle to it' }, (args: Record<string, unknown>) => {
  const handle = randomUUID()
  store.set(handle, args.data)
  return { handle }
})

server.tool({ name: 'fetch', description: 'Read a stashed value back by its handle' }, (args: Record<string, unknown>) => {
  return store.get(args.handle as string)
})

server.tool({ name: 'deleteFiles', description: 'Delete files after confirmation' }, async (args: Record<string, unknown>) => {
  const ctx = server.getContext()
  const { action } = await ctx.elicit(`Delete ${args.count} files?`, {
    type: 'object',
    properties: { confirm: { type: 'boolean' } },
    required: ['confirm'],
  })
  if (action !== 'accept') return 'Cancelled'
  return `Deleted ${args.count} files`
})

import { inputRequired, acceptedContent } from '@prefecthq/fastmcp-ts/server'

server.tool({ name: 'deleteFiles', description: 'Delete files after confirmation' }, async (args: Record<string, unknown>) => {
  const ctx = server.getContext()
  const accepted = acceptedContent<{ confirm: boolean }>(ctx.inputResponses, 'confirm')
  if (!accepted?.confirm) {
    return inputRequired({
      inputRequests: {
        confirm: inputRequired.elicit({
          message: `Delete ${args.count} files?`,
          requestedSchema: {
            type: 'object',
            properties: { confirm: { type: 'boolean' } },
            required: ['confirm'],
          },
        }),
      },
    })
  }
  return `Deleted ${args.count} files`
})