Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript
25.2 KB
Raw Blame
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { McpClient } from '../../mcp/client'

const sdkState = vi.hoisted(() => ({
  closeCalls: [] as unknown[][],
  closeQueue: [] as Array<() => unknown>,
  connectCalls: [] as unknown[][],
  connectQueue: [] as Array<() => unknown>,
  callToolCalls: [] as unknown[][],
  callToolQueue: [] as Array<() => unknown>,
  listToolsCalls: [] as unknown[][],
  listToolsQueue: [] as Array<() => unknown>,
  requestCalls: [] as unknown[][],
  requestQueue: [] as Array<() => unknown>,
  transportCloseCalls: [] as unknown[][],
  transportCloseQueue: [] as Array<() => unknown>,
}))

vi.mock('@modelcontextprotocol/sdk/client/index.js', () => ({
  Client: class MockClient {
    async connect(...args: unknown[]) {
      sdkState.connectCalls.push(args)
      const next = sdkState.connectQueue.shift()
      if (next) return next()
    }

    async close(...args: unknown[]) {
      sdkState.closeCalls.push(args)
      const next = sdkState.closeQueue.shift()
      if (next) return next()
    }

    async listTools(...args: unknown[]) {
      sdkState.listToolsCalls.push(args)
      const next = sdkState.listToolsQueue.shift()
      if (next) return next()
      return { tools: [] }
    }

    async request(...args: unknown[]) {
      sdkState.requestCalls.push(args)
      const next = sdkState.requestQueue.shift()
      if (next) return next()
      return { tools: [] }
    }

    async callTool(...args: unknown[]) {
      sdkState.callToolCalls.push(args)
      const next = sdkState.callToolQueue.shift()
      if (next) return next()
      return { content: [{ type: 'text', text: 'ok' }] }
    }
  },
}))

vi.mock('@modelcontextprotocol/sdk/client/streamableHttp.js', () => ({
  StreamableHTTPClientTransport: class MockStreamableHTTP {
    async close(...args: unknown[]) {
      sdkState.transportCloseCalls.push([this, ...args])
      const next = sdkState.transportCloseQueue.shift()
      if (next) return next()
    }
  },
}))

vi.mock('@modelcontextprotocol/sdk/client/sse.js', () => ({
  SSEClientTransport: class MockSSE {
    async close(...args: unknown[]) {
      sdkState.transportCloseCalls.push([this, ...args])
      const next = sdkState.transportCloseQueue.shift()
      if (next) return next()
    }
  },
}))

function client(): McpClient {
  return new McpClient({
    name: 'svc',
    contextRef: 'ctx',
    transport: { type: 'streamableHttp', url: 'http://svc/mcp' },
    enabled: true,
    status: { deployed: true, ready: true },
  })
}

function deferred<T = void>(): {
  promise: Promise<T>
  resolve: (value: T) => void
  reject: (error: unknown) => void
} {
  let resolve!: (value: T) => void
  let reject!: (error: unknown) => void
  const promise = new Promise<T>((resolvePromise, rejectPromise) => {
    resolve = resolvePromise
    reject = rejectPromise
  })
  return { promise, resolve, reject }
}

function retirePermanently(client: McpClient): Promise<void> {
  const cleanup = client.retire()
  return cleanup()
}

describe('McpClient SDK request timeouts', () => {
  beforeEach(() => {
    sdkState.closeCalls.length = 0
    sdkState.closeQueue.length = 0
    sdkState.connectCalls.length = 0
    sdkState.connectQueue.length = 0
    sdkState.callToolCalls.length = 0
    sdkState.callToolQueue.length = 0
    sdkState.listToolsCalls.length = 0
    sdkState.listToolsQueue.length = 0
    sdkState.requestCalls.length = 0
    sdkState.requestQueue.length = 0
    sdkState.transportCloseCalls.length = 0
    sdkState.transportCloseQueue.length = 0
  })

  afterEach(() => {
    vi.unstubAllEnvs()
    vi.useRealTimers()
  })

  it('passes explicit timeout options to SDK callTool', async () => {
    const c = client()
    await c.connect()

    await c.callTool('read', { id: 1 })

    expect(sdkState.callToolCalls[0]).toEqual([
      { name: 'read', arguments: { id: 1 } },
      undefined,
      expect.objectContaining({ timeout: 1_500_000 }),
    ])
  })

  it('preserves the caller budget for retry while shared recovery uses its lifecycle budget', async () => {
    vi.useFakeTimers()
    sdkState.callToolQueue.push(
      () => {
        throw Object.assign(new Error('session not found'), { code: -32003 })
      },
      () => ({ content: [{ type: 'text', text: 'ok-after-reconnect' }] })
    )
    const c = client()
    await c.connect()

    const pending = c.callTool('read', { id: 1 }, { timeoutMs: 30_000 })
    await vi.advanceTimersByTimeAsync(1000)
    const result = await pending

    expect(result).toEqual({ content: [{ type: 'text', text: 'ok-after-reconnect' }] })
    expect(sdkState.callToolCalls).toHaveLength(2)
    expect(sdkState.callToolCalls[0][2]).toEqual(expect.objectContaining({ timeout: 30_000 }))
    expect(sdkState.callToolCalls[1][2]).toEqual(expect.objectContaining({ timeout: 29_000 }))
    expect(sdkState.listToolsCalls[1][1]).toEqual(expect.objectContaining({ timeout: 1_500_000 }))
  })

  it('lets a slower peer adopt the completed recovery of their shared session', async () => {
    vi.useFakeTimers()
    sdkState.callToolQueue.push(
      () => {
        throw Object.assign(new Error('session not found'), { code: -32003 })
      },
      () => {
        throw Object.assign(new Error('session not found'), { code: -32003 })
      },
      () => ({ content: [{ type: 'text', text: 'first-after-reconnect' }] }),
      () => ({ content: [{ type: 'text', text: 'second-after-reconnect' }] })
    )
    const c = client()
    await c.connect()

    const first = c.callTool('read', { id: 1 }, { timeoutMs: 30_000 })
    await vi.advanceTimersByTimeAsync(500)
    const second = c.callTool('read', { id: 2 }, { timeoutMs: 30_000 })
    const settled = Promise.allSettled([first, second])
    await vi.advanceTimersByTimeAsync(500)

    // The first call has already completed the one shared reconnect while the
    // slower peer is still inside its independently budgeted retry delay.
    expect(sdkState.connectCalls).toHaveLength(2)
    expect(sdkState.callToolCalls).toHaveLength(3)
    await vi.advanceTimersByTimeAsync(500)

    await expect(settled).resolves.toEqual([
      {
        status: 'fulfilled',
        value: { content: [{ type: 'text', text: 'first-after-reconnect' }] },
      },
      {
        status: 'fulfilled',
        value: { content: [{ type: 'text', text: 'second-after-reconnect' }] },
      },
    ])
    expect(sdkState.connectCalls).toHaveLength(2)
    expect(sdkState.callToolCalls).toHaveLength(4)
  })

  it('retries a session error that arrives after a peer has recovered their source', async () => {
    vi.useFakeTimers()
    const lateSessionError = deferred<unknown>()
    sdkState.callToolQueue.push(
      () => {
        throw Object.assign(new Error('session not found'), { code: -32003 })
      },
      () => lateSessionError.promise,
      () => ({ content: [{ type: 'text', text: 'first-after-reconnect' }] }),
      () => ({ content: [{ type: 'text', text: 'late-after-reconnect' }] })
    )
    const c = client()
    await c.connect()

    const settled = Promise.allSettled([
      c.callTool('read', { id: 1 }, { timeoutMs: 30_000 }),
      c.callTool('read', { id: 2 }, { timeoutMs: 30_000 }),
    ])
    await vi.advanceTimersByTimeAsync(1000)
    expect(sdkState.connectCalls).toHaveLength(2)
    expect(sdkState.callToolCalls).toHaveLength(3)

    lateSessionError.reject(Object.assign(new Error('session not found'), { code: -32003 }))
    await vi.advanceTimersByTimeAsync(1000)

    await expect(settled).resolves.toEqual([
      {
        status: 'fulfilled',
        value: { content: [{ type: 'text', text: 'first-after-reconnect' }] },
      },
      {
        status: 'fulfilled',
        value: { content: [{ type: 'text', text: 'late-after-reconnect' }] },
      },
    ])
    expect(sdkState.connectCalls).toHaveLength(2)
    expect(sdkState.callToolCalls).toHaveLength(4)
  })

  it('fails all shared recovery waiters closed when the client is retired', async () => {
    vi.useFakeTimers()
    const reconnectHandshake = deferred()
    sdkState.callToolQueue.push(
      () => {
        throw Object.assign(new Error('session not found'), { code: -32003 })
      },
      () => {
        throw Object.assign(new Error('session not found'), { code: -32003 })
      },
      () => ({ content: [{ type: 'text', text: 'must-not-run' }] }),
      () => ({ content: [{ type: 'text', text: 'must-not-run' }] })
    )
    const c = client()
    await c.connect()
    sdkState.connectQueue.push(() => reconnectHandshake.promise)

    const settled = Promise.allSettled([
      c.callTool('write', { id: 1 }, { timeoutMs: 30_000 }),
      c.callTool('write', { id: 2 }, { timeoutMs: 30_000 }),
    ])
    await vi.advanceTimersByTimeAsync(1000)
    expect(sdkState.connectCalls).toHaveLength(2)

    const closing = retirePermanently(c)
    reconnectHandshake.resolve()
    await closing
    await vi.advanceTimersByTimeAsync(0)

    await expect(settled).resolves.toEqual([
      {
        status: 'rejected',
        reason: expect.objectContaining({ message: expect.stringMatching(/closed|superseded/) }),
      },
      {
        status: 'rejected',
        reason: expect.objectContaining({ message: expect.stringMatching(/closed|superseded/) }),
      },
    ])
    expect(sdkState.callToolCalls).toHaveLength(2)
    expect(c.isConnected).toBe(false)
  })

  it('keeps shared recovery alive when its first caller exhausts a shorter budget', async () => {
    vi.useFakeTimers()
    const reconnectHandshake = deferred()
    sdkState.callToolQueue.push(
      () => {
        throw Object.assign(new Error('session not found'), { code: -32003 })
      },
      () => {
        throw Object.assign(new Error('session not found'), { code: -32003 })
      },
      () => ({ content: [{ type: 'text', text: 'long-budget-peer-recovered' }] })
    )
    const c = client()
    await c.connect()
    sdkState.connectQueue.push(() => reconnectHandshake.promise)

    const shortBudget = c.callTool('read', { id: 1 }, { timeoutMs: 1_500 })
    const shortAssertion = expect(shortBudget).rejects.toThrow('step-timeout')
    const longBudget = c.callTool('read', { id: 2 }, { timeoutMs: 30_000 })
    await vi.advanceTimersByTimeAsync(1000)
    expect(sdkState.connectCalls).toHaveLength(2)

    await vi.advanceTimersByTimeAsync(500)
    await shortAssertion
    expect(sdkState.callToolCalls).toHaveLength(2)

    reconnectHandshake.resolve()
    await vi.advanceTimersByTimeAsync(0)
    await expect(longBudget).resolves.toEqual({
      content: [{ type: 'text', text: 'long-budget-peer-recovered' }],
    })
    expect(sdkState.connectCalls).toHaveLength(2)
    expect(sdkState.callToolCalls).toHaveLength(3)
  })

  it('lets an aborted peer leave shared recovery without cancelling it for another caller', async () => {
    vi.useFakeTimers()
    const reconnectHandshake = deferred()
    const peerController = new AbortController()
    sdkState.callToolQueue.push(
      () => {
        throw Object.assign(new Error('session not found'), { code: -32003 })
      },
      () => {
        throw Object.assign(new Error('session not found'), { code: -32003 })
      },
      () => ({ content: [{ type: 'text', text: 'leader-recovered' }] })
    )
    const c = client()
    await c.connect()
    sdkState.connectQueue.push(() => reconnectHandshake.promise)

    const leader = c.callTool('read', { id: 1 }, { timeoutMs: 30_000 })
    const peer = c.callTool('read', { id: 2 }, { timeoutMs: 30_000, signal: peerController.signal })
    const peerAssertion = expect(peer).rejects.toThrow('peer-aborted')
    await vi.advanceTimersByTimeAsync(1000)
    expect(sdkState.connectCalls).toHaveLength(2)

    peerController.abort('peer-aborted')
    await peerAssertion
    expect(sdkState.connectCalls).toHaveLength(2)
    expect(sdkState.callToolCalls).toHaveLength(2)

    reconnectHandshake.resolve()
    await vi.advanceTimersByTimeAsync(0)
    await expect(leader).resolves.toEqual({
      content: [{ type: 'text', text: 'leader-recovered' }],
    })
    expect(sdkState.connectCalls).toHaveLength(2)
    expect(sdkState.callToolCalls).toHaveLength(3)
  })

  it('does not start reconnect retry after the caller budget is exhausted', async () => {
    vi.useFakeTimers()
    sdkState.callToolQueue.push(() => {
      throw Object.assign(new Error('session not found'), { code: -32003 })
    })
    const c = client()
    await c.connect()

    const pending = c.callTool('read', { id: 1 }, { timeoutMs: 500 })
    const assertion = expect(pending).rejects.toThrow('step-timeout')
    await vi.advanceTimersByTimeAsync(500)

    await assertion
    expect(sdkState.callToolCalls).toHaveLength(1)
    expect(sdkState.listToolsCalls).toHaveLength(1)
  })

  it('does not start reconnect after the caller aborts during the retry delay', async () => {
    vi.useFakeTimers()
    sdkState.callToolQueue.push(() => {
      throw Object.assign(new Error('session not found'), { code: -32003 })
    })
    const controller = new AbortController()
    const c = client()
    await c.connect()

    const pending = c.callTool(
      'write',
      { value: 'side-effect' },
      { timeoutMs: 30_000, signal: controller.signal }
    )
    const assertion = expect(pending).rejects.toThrow('caller-aborted')
    await vi.advanceTimersByTimeAsync(500)
    controller.abort('caller-aborted')
    await vi.advanceTimersByTimeAsync(500)

    await assertion
    expect(sdkState.connectCalls).toHaveLength(1)
    expect(sdkState.transportCloseCalls).toHaveLength(0)
    expect(sdkState.callToolCalls).toHaveLength(1)
    expect(c.isConnected).toBe(true)
  })

  it.each(['', ' ', '0', '-1', '2147483648'])(
    'fails closed for invalid timeout env %j before SDK tool discovery',
    async value => {
      vi.stubEnv('CLERUM_MCP_TOOL_TIMEOUT_MS', value)
      const c = client()

      await expect(c.connect()).rejects.toThrow(
        'CLERUM_MCP_TOOL_TIMEOUT_MS must be a positive safe integer'
      )
      expect(sdkState.listToolsCalls).toHaveLength(0)
      expect(sdkState.callToolCalls).toHaveLength(0)
    }
  )

  it('allows a lower caller budget to override env max/per-call contradiction', async () => {
    vi.stubEnv('CLERUM_MCP_TOOL_TIMEOUT_MS', '3600000')
    vi.stubEnv('CLERUM_MCP_TOOL_MAX_TOTAL_TIMEOUT_MS', '60000')
    const c = client()
    await c.connect({ timeoutMs: 30_000 })

    await c.callTool('read', {}, { timeoutMs: 30_000 })

    const requestOptions = sdkState.callToolCalls[0][2] as {
      timeout: number
      maxTotalTimeout: number
    }
    expect(requestOptions.timeout).toBeLessThanOrEqual(30_000)
    expect(requestOptions.timeout).toBeGreaterThan(29_000)
    expect(requestOptions.maxTotalTimeout).toBe(requestOptions.timeout)
  })

  it('uses a raw validated SDK request for status probes without calling listTools', async () => {
    const controller = new AbortController()
    const c = client()

    await c.connect({ timeoutMs: 5_000, signal: controller.signal })
    await c.probeTools({ timeoutMs: 3_000, signal: controller.signal })

    expect(sdkState.listToolsCalls[0]).toEqual([
      undefined,
      expect.objectContaining({
        timeout: 5_000,
        maxTotalTimeout: 5_000,
        signal: controller.signal,
      }),
    ])
    expect(sdkState.requestCalls[0]).toEqual([
      { method: 'tools/list', params: undefined },
      expect.anything(),
      expect.objectContaining({
        timeout: 3_000,
        maxTotalTimeout: 3_000,
        signal: controller.signal,
      }),
    ])
    expect(sdkState.listToolsCalls).toHaveLength(1)
  })

  it('fails connect when SDK tool discovery fails', async () => {
    sdkState.listToolsQueue.push(() => {
      throw new Error('tools/list timeout')
    })
    const c = client()

    await expect(c.connect({ timeoutMs: 5_000 })).rejects.toThrow('tools/list timeout')

    expect(c.isConnected).toBe(false)
    expect(sdkState.listToolsCalls[0][1]).toEqual(
      expect.objectContaining({ timeout: 5_000, maxTotalTimeout: 5_000 })
    )
    expect(sdkState.transportCloseCalls).toHaveLength(1)
  })

  it('abandons SDK connect when the caller budget expires during handshake', async () => {
    vi.useFakeTimers()
    sdkState.connectQueue.push(() => new Promise(() => undefined))
    const c = client()

    const pending = c.connect({ timeoutMs: 500 })
    const assertion = expect(pending).rejects.toThrow('step-timeout')
    await vi.advanceTimersByTimeAsync(500)

    await assertion
    expect(c.isConnected).toBe(false)
    expect(sdkState.connectCalls).toHaveLength(1)
    expect(sdkState.listToolsCalls).toHaveLength(0)
    expect(sdkState.transportCloseCalls).toHaveLength(1)
  })

  it('abandons SDK connect when the caller signal aborts during handshake', async () => {
    sdkState.connectQueue.push(() => new Promise(() => undefined))
    const controller = new AbortController()
    const c = client()

    const pending = c.connect({ timeoutMs: 30_000, signal: controller.signal })
    controller.abort('step-timeout')

    await expect(pending).rejects.toThrow('step-timeout')
    expect(c.isConnected).toBe(false)
    expect(sdkState.connectCalls).toHaveLength(1)
    expect(sdkState.listToolsCalls).toHaveLength(0)
    expect(sdkState.transportCloseCalls).toHaveLength(1)
  })

  it('detaches immediately and closes the owned transport when SDK protocol close hangs', async () => {
    const releaseClose = deferred()
    sdkState.transportCloseQueue.push(() => releaseClose.promise)
    const c = client()
    await c.connect()

    const disconnecting = c.disconnect()
    await Promise.resolve()

    expect(c.isConnected).toBe(false)
    expect(c.availableTools).toEqual([])
    expect(sdkState.closeCalls).toHaveLength(0)
    expect(sdkState.transportCloseCalls).toHaveLength(1)

    releaseClose.resolve()
    await expect(disconnecting).resolves.toBeUndefined()
  })

  it('does not reconnect or replay a tool after permanent close during the retry delay', async () => {
    vi.useFakeTimers()
    sdkState.callToolQueue.push(
      () => {
        throw Object.assign(new Error('session not found'), { code: -32003 })
      },
      () => ({ content: [{ type: 'text', text: 'must-not-run' }] })
    )
    const c = client()
    await c.connect()

    const pending = c.callTool('write', { value: 'side-effect' }, { timeoutMs: 30_000 })
    const assertion = expect(pending).rejects.toThrow(/closed/)
    await vi.advanceTimersByTimeAsync(0)
    await retirePermanently(c)
    await vi.advanceTimersByTimeAsync(1000)

    await assertion
    expect(sdkState.connectCalls).toHaveLength(1)
    expect(sdkState.callToolCalls).toHaveLength(1)
    expect(c.isConnected).toBe(false)
  })

  it('discards a successful tool result that arrives after permanent close', async () => {
    let resolveCall!: (value: unknown) => void
    const callResult = new Promise<unknown>(resolve => {
      resolveCall = resolve
    })
    sdkState.callToolQueue.push(() => callResult)
    const c = client()
    await c.connect()

    const pending = c.callTool('write', { value: 'side-effect' })
    const assertion = expect(pending).rejects.toThrow(/closed/)
    await vi.waitFor(() => expect(sdkState.callToolCalls).toHaveLength(1))
    await retirePermanently(c)
    resolveCall({ content: [{ type: 'text', text: 'late-success' }] })

    await assertion
    expect(sdkState.connectCalls).toHaveLength(1)
    expect(sdkState.callToolCalls).toHaveLength(1)
    expect(c.isConnected).toBe(false)
  })

  it('starts transport close synchronously when permanently retired', async () => {
    const c = client()
    await c.connect()

    const cleanup = c.retire()

    expect(c.isConnected).toBe(false)
    expect(sdkState.transportCloseCalls).toHaveLength(1)
    await cleanup()
    expect(sdkState.transportCloseCalls).toHaveLength(1)
  })

  it('discards a retry result that arrives after permanent close', async () => {
    vi.useFakeTimers()
    const retryResult = deferred<unknown>()
    sdkState.callToolQueue.push(
      () => {
        throw Object.assign(new Error('session not found'), { code: -32003 })
      },
      () => retryResult.promise
    )
    const c = client()
    await c.connect()

    const pending = c.callTool('write', { value: 'side-effect' }, { timeoutMs: 30_000 })
    const assertion = expect(pending).rejects.toThrow(/closed/)
    await vi.advanceTimersByTimeAsync(1000)
    await vi.waitFor(() => expect(sdkState.callToolCalls).toHaveLength(2))

    await retirePermanently(c)
    retryResult.resolve({ content: [{ type: 'text', text: 'late-retry-success' }] })

    await assertion
    expect(sdkState.callToolCalls).toHaveLength(2)
    expect(c.isConnected).toBe(false)
  })

  it('invalidates a reconnect handshake when permanent close arrives in flight', async () => {
    vi.useFakeTimers()
    const reconnectHandshake = deferred()
    sdkState.callToolQueue.push(
      () => {
        throw Object.assign(new Error('session not found'), { code: -32003 })
      },
      () => ({ content: [{ type: 'text', text: 'must-not-run' }] })
    )
    const c = client()
    await c.connect()
    sdkState.connectQueue.push(() => reconnectHandshake.promise)

    const pending = c.callTool('write', { value: 'side-effect' }, { timeoutMs: 30_000 })
    const assertion = expect(pending).rejects.toThrow(/closed|superseded/)
    await vi.advanceTimersByTimeAsync(1000)
    expect(sdkState.connectCalls).toHaveLength(2)

    const closing = retirePermanently(c)
    reconnectHandshake.resolve()
    await closing
    await vi.advanceTimersByTimeAsync(0)

    await assertion
    expect(sdkState.callToolCalls).toHaveLength(1)
    expect(c.isConnected).toBe(false)
    expect(sdkState.transportCloseCalls).toHaveLength(2)
    expect(new Set(sdkState.transportCloseCalls.map(([transport]) => transport)).size).toBe(2)
  })

  it('rejects all recovery waiters promptly when retired while reconnect never settles', async () => {
    vi.useFakeTimers()
    const reconnectHandshake = deferred()
    sdkState.callToolQueue.push(
      () => {
        throw Object.assign(new Error('session not found'), { code: -32003 })
      },
      () => {
        throw Object.assign(new Error('session not found'), { code: -32003 })
      }
    )
    const c = client()
    await c.connect()
    sdkState.connectQueue.push(() => reconnectHandshake.promise)

    const settled = Promise.allSettled([
      c.callTool('write', { id: 1 }, { timeoutMs: 30_000 }),
      c.callTool('write', { id: 2 }, { timeoutMs: 30_000 }),
    ])
    await vi.advanceTimersByTimeAsync(1000)
    expect(sdkState.connectCalls).toHaveLength(2)

    await retirePermanently(c)
    await vi.advanceTimersByTimeAsync(0)

    await expect(settled).resolves.toEqual([
      {
        status: 'rejected',
        reason: expect.objectContaining({ message: expect.stringMatching(/closed/) }),
      },
      {
        status: 'rejected',
        reason: expect.objectContaining({ message: expect.stringMatching(/closed/) }),
      },
    ])
    expect(sdkState.callToolCalls).toHaveLength(2)
    expect(c.isConnected).toBe(false)
  })

  it('does not publish tools discovered after permanent close', async () => {
    const discovery = deferred<{
      tools: Array<{ name: string; description: string; inputSchema: Record<string, unknown> }>
    }>()
    sdkState.listToolsQueue.push(() => discovery.promise)
    const c = client()

    const pending = c.connect()
    await vi.waitFor(() => expect(sdkState.listToolsCalls).toHaveLength(1))
    const closing = retirePermanently(c)
    discovery.resolve({
      tools: [{ name: 'stale-tool', description: 'stale', inputSchema: {} }],
    })

    await closing
    await expect(pending).rejects.toThrow(/closed/)
    expect(c.availableTools).toEqual([])
    expect(c.isConnected).toBe(false)
    expect(sdkState.transportCloseCalls).toHaveLength(1)
  })

  it('does not let an old tools/list failure erase a reconnected tool cache', async () => {
    const c = client()
    await c.connect()

    const staleDiscovery = deferred<{
      tools: Array<{ name: string; description: string; inputSchema: Record<string, unknown> }>
    }>()
    sdkState.listToolsQueue.push(
      () => staleDiscovery.promise,
      () => ({
        tools: [{ name: 'fresh-tool', description: 'fresh', inputSchema: {} }],
      })
    )
    const staleRefresh = c.listTools()
    await vi.waitFor(() => expect(sdkState.listToolsCalls).toHaveLength(2))

    await c.reconnect()
    expect(c.availableTools.map(tool => tool.name)).toEqual(['fresh-tool'])

    staleDiscovery.reject(new Error('old tools/list failed'))
    await expect(staleRefresh).rejects.toThrow(/superseded/)
    expect(c.availableTools.map(tool => tool.name)).toEqual(['fresh-tool'])
    expect(c.isConnected).toBe(true)
  })

  it('does not report a successful probe from a permanently closed connection', async () => {
    const c = client()
    await c.connect()
    const staleProbe = deferred<{
      tools: Array<{ name: string; description: string; inputSchema: Record<string, unknown> }>
    }>()
    // probeTools() issues a validated raw `request(tools/list)` (not listTools),
    // so drive the in-flight probe through the request queue.
    sdkState.requestQueue.push(() => staleProbe.promise)

    const probing = c.probeTools()
    await vi.waitFor(() => expect(sdkState.requestCalls).toHaveLength(1))
    const closing = retirePermanently(c)
    staleProbe.resolve({
      tools: [{ name: 'stale-tool', description: 'stale', inputSchema: {} }],
    })

    await closing
    await expect(probing).resolves.toEqual({
      ok: false,
      error: expect.objectContaining({ message: expect.stringMatching(/closed/) }),
      stale: true,
    })
  })
})