import { describe, expect, it, vi } from 'vitest'
import { resolve } from 'node:path'
import type { RuntimeEvent } from './runtime'
import {
  ModelToolProvider,
  type ModelToolDefinition,
  type ModelToolProviderLike
} from './model-tool-provider'
import type {
  ResolvedMcpServer
} from '../capabilities/capability-service'
import {
  DeepSeekHarnessRuntime,
  harnessPromptError,
  type DeepSeekHarnessAcpSdk,
  type DeepSeekHarnessChild
} from './deepseek-harness-runtime'
import { RequestError } from '@agentclientprotocol/sdk'

type Permission = Parameters<
  ReturnType<
    ConstructorParameters<
      DeepSeekHarnessAcpSdk['ClientSideConnection']
    >[0]
  >['requestPermission']
>[0]

function deferred<T>() {
  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 setup(
  options: {
    toolProvider?: ModelToolProviderLike
    promptTimeoutMs?: number
    maxEventCharacters?: number
    maxRequestOutputCharacters?: number
  } = {}
) {
  const exit = deferred<{
    exitCode: number | null
    signal?: string | null
  }>()
  const stderr = new TransformStream<Uint8Array, Uint8Array>()
  const child: DeepSeekHarnessChild = {
    stdin: new WritableStream<Uint8Array>(),
    stdout: new ReadableStream<Uint8Array>(),
    stderr: stderr.readable,
    exited: exit.promise,
    terminate: vi.fn()
  }
  let permissionHandler:
    | ((params: Permission) => Promise<unknown>)
    | undefined
  let updateHandler:
    | ((context: {
        sessionId: string
        update: Record<string, unknown>
      }) => Promise<void>)
    | undefined
  let extensionHandler:
    | ((
        method: string,
        params: Record<string, unknown>
      ) => Promise<Record<string, unknown>>)
    | undefined
  const requests: Array<{
    method: string
    params: Record<string, unknown>
  }> = []
  const notifications: Array<{
    method: string
    params: Record<string, unknown>
  }> = []
  const promptGates: Array<ReturnType<typeof deferred<{ stopReason: string }>>> =
    []
  let sessionIndex = 0
  const connectionClosed = deferred<void>()
  const connectionController = new AbortController()
  const requestAgent = async (
    method: string,
    params: Record<string, unknown>
  ) => {
    requests.push({ method, params })
    if (method === 'initialize') {
      return {
        protocolVersion: 1,
        agentCapabilities: {}
      }
    }
    if (method === 'session/new') {
      sessionIndex += 1
      return { sessionId: `session-${sessionIndex}` }
    }
    if (method === 'session/prompt') {
      const gate = deferred<{ stopReason: string }>()
      promptGates.push(gate)
      return gate.promise
    }
    throw new Error(`unexpected request: ${method}`)
  }
  const notifyAgent = async (
    method: string,
    params: Record<string, unknown>
  ) => {
    notifications.push({ method, params })
  }
  const agent = {
    initialize: vi.fn((params: Record<string, unknown>) =>
      requestAgent('initialize', params)
    ),
    newSession: vi.fn((params: Record<string, unknown>) =>
      requestAgent('session/new', params)
    ),
    prompt: vi.fn((params: Record<string, unknown>) =>
      requestAgent('session/prompt', params)
    ),
    cancel: vi.fn((params: Record<string, unknown>) =>
      notifyAgent('session/cancel', params)
    ),
    extMethod: vi.fn(
      async (method: string, params: Record<string, unknown>) => {
        requests.push({ method, params })
        if (method === 'goodbuddy/handshake') {
          return {
            controlProtocolVersion: 1,
            harnessVersion: '0.1.0-rc.6',
            acpProtocolVersion: 1,
            supports: {
              cancellation: true,
              sessionRelease: true,
              oneShotApproval: true,
              reasoningEvents: true,
              toolEvents: true,
              usageEvents: true,
              credentialResolution: true
            },
            sandbox: {
              provider: 'test',
              enforcement: 'full'
            }
          }
        }
        if (method === 'goodbuddy/session/prepare') {
          return { prepared: true }
        }
        if (method === 'goodbuddy/session/release') {
          return { released: true }
        }
        if (method === 'goodbuddy/shutdown') {
          return { shutdown: true }
        }
        throw new Error(`unexpected extension: ${method}`)
      }
    ),
    extNotification: vi.fn()
  }
  const connection = {
    ...agent,
    signal: connectionController.signal,
    closed: connectionClosed.promise
  }
  const ClientSideConnection = vi.fn(function (
    this: unknown,
    toClient: (
      connectedAgent: typeof agent
    ) => {
      requestPermission: typeof permissionHandler
      sessionUpdate: typeof updateHandler
      extMethod: (
        method: string,
        params: Record<string, unknown>
      ) => Promise<Record<string, unknown>>
      extNotification: (
        method: string,
        params: Record<string, unknown>
      ) => Promise<void>
    }
  ) {
    const client = toClient(agent)
    permissionHandler = client.requestPermission
    updateHandler = client.sessionUpdate
    extensionHandler = client.extMethod
    agent.extNotification.mockImplementation(
      async (
        method: string,
        params: Record<string, unknown>
      ) => client.extNotification(method, params)
    )
    return connection
  })
  const sdk = {
    PROTOCOL_VERSION: 1,
    ClientSideConnection,
    ndJsonStream: vi.fn(() => ({ stream: true }))
  } as unknown as DeepSeekHarnessAcpSdk
  const launch = vi.fn(async () => child)
  const runtime = new DeepSeekHarnessRuntime({
    defaultWorkspace: 'C:\\workspace',
    baseUrl: 'https://api.deepseek.com',
    model: 'deepseek-test',
    launch,
    loadAcpSdk: async () => sdk,
    initializationTimeoutMs: 100,
    promptTimeoutMs: options.promptTimeoutMs ?? 100,
    shutdownTimeoutMs: 10,
    maxStderrBytes: 16,
    maxEventCharacters: options.maxEventCharacters,
    maxRequestOutputCharacters:
      options.maxRequestOutputCharacters,
    toolProvider: options.toolProvider
  })
  const emit = async (
    sessionId: string,
    update: Record<string, unknown>
  ): Promise<void> => {
    await updateHandler?.({ sessionId, update })
  }
  return {
    runtime,
    child,
    stderr,
    exit,
    sdk,
    launch,
    requests,
    notifications,
    promptGates,
    agent,
    permission: async (request: Permission) =>
      permissionHandler?.(request),
    extension: (
      method: string,
      params: Record<string, unknown>
    ) => extensionHandler?.(method, params),
    notify: (
      method: string,
      params: Record<string, unknown>
    ) => agent.extNotification(method, params),
    emit
  }
}

async function collect(
  stream: AsyncGenerator<RuntimeEvent, void, void>
): Promise<RuntimeEvent[]> {
  const events: RuntimeEvent[] = []
  for await (const event of stream) {
    events.push(event)
  }
  return events
}

function request(
  conversationId: string,
  workMode: 'ask' | 'execute' = 'execute'
) {
  return {
    requestId: `request-${conversationId}`,
    conversationId,
    prompt: 'hello',
    workMode
  } as const
}

function permission(sessionId: string): Permission {
  return {
    sessionId,
    toolCall: {
      toolCallId: 'call-1',
      title: 'Run tests',
      name: 'shell',
      kind: 'execute',
      rawInput: { command: 'npm test' }
    },
    options: [
      {
        optionId: 'allow-once',
        name: 'Allow once',
        kind: 'allow_once'
      },
      {
        optionId: 'allow-always',
        name: 'Always allow',
        kind: 'allow_always'
      },
      {
        optionId: 'reject',
        name: 'Reject',
        kind: 'reject_once'
      }
    ]
  }
}

function mcpTool(
  name = 'mcp_deadbeef_cafebabe_game_asset'
): ModelToolDefinition {
  return {
    name,
    displayName: 'Local Game Assets / game_asset',
    description: 'Returns a deterministic local game asset manifest.',
    inputSchema: {
      type: 'object',
      properties: {
        kind: { type: 'string' }
      },
      required: ['kind'],
      additionalProperties: false
    },
    source: 'mcp',
    serverName: 'Local Game Assets'
  }
}

function toolProvider(
  tools: ModelToolDefinition[] = [mcpTool()]
): ModelToolProviderLike {
  return {
    listTools: vi.fn(async () => tools),
    getApproval: vi.fn((tool, _arguments, summary) => ({
      scopeKey: `model:mcp:${tool.name}`,
      title: `允许调用 MCP 工具「${tool.displayName}」？`,
      description: '调用本地测试 MCP。',
      toolName: tool.displayName,
      argumentSummary: summary,
      allowPermanent: false
    })),
    callTool: vi.fn(async () => ({
      parts: [
        {
          type: 'text' as const,
          text: '{"asset":"cube"}'
        }
      ],
      contextBytes: 16
    })),
    releaseConversation: vi.fn(async () => undefined),
    dispose: vi.fn(async () => undefined)
  }
}

describe('DeepSeekHarnessRuntime', () => {
  it('surfaces bounded internal Harness details from ACP errors', () => {
    expect(
      harnessPromptError(
        RequestError.internalError({
          details: 'DeepSeek provider rejected the request'
        })
      )
    ).toEqual(
      new Error('DeepSeek provider rejected the request')
    )
    expect(
      harnessPromptError(
        RequestError.internalError({ unrelated: 'hidden' })
      )
    ).toBeInstanceOf(RequestError)
  })

  it('uses ACP stdio, maps conversations to sessions, and streams text', async () => {
    const harness = setup()
    const first = collect(
      harness.runtime.run(
        request('one'),
        new AbortController().signal
      )
    )
    await vi.waitFor(() =>
      expect(harness.promptGates).toHaveLength(1)
    )
    await harness.emit('session-1', {
      sessionUpdate: 'agent_message_chunk',
      content: { type: 'text', text: 'hello ' }
    })
    await harness.emit('session-1', {
      sessionUpdate: 'agent_message_chunk',
      content: { type: 'text', text: 'world' }
    })
    harness.promptGates[0]!.resolve({ stopReason: 'end_turn' })

    expect(await first).toEqual([
      expect.objectContaining({ type: 'status' }),
      expect.objectContaining({ type: 'text', delta: 'hello ' }),
      expect.objectContaining({ type: 'text', delta: 'world' }),
      expect.objectContaining({
        type: 'done',
        sessionId: 'session-1'
      })
    ])
    expect(harness.sdk.ndJsonStream).toHaveBeenCalledWith(
      harness.child.stdin,
      harness.child.stdout
    )
    expect(harness.launch).toHaveBeenCalledWith({
      cwd: 'C:\\workspace',
      signal: expect.any(AbortSignal),
      baseUrl: 'https://api.deepseek.com',
      model: 'deepseek-test',
      credentialRefs: [],
      requiredSandboxEnforcement: undefined,
      skillPackages: []
    })
    expect(harness.requests).toContainEqual({
      method: 'goodbuddy/session/prepare',
      params: {
        sessionId: 'session-1',
        requestId: 'request-one',
        mode: 'execute'
      }
    })

    const second = collect(
      harness.runtime.run(
        request('one'),
        new AbortController().signal
      )
    )
    await vi.waitFor(() =>
      expect(harness.promptGates).toHaveLength(2)
    )
    harness.promptGates[1]!.resolve({ stopReason: 'end_turn' })
    await second
    expect(
      harness.requests.filter(({ method }) => method === 'session/new')
    ).toHaveLength(1)
    await harness.runtime.dispose()
  })

  it('enforces the cumulative bridge limit against complete wire events', async () => {
    const harness = setup({
      maxEventCharacters: 1_000,
      maxRequestOutputCharacters: 180
    })
    const running = collect(
      harness.runtime.run(
        request('output-limit'),
        new AbortController().signal
      )
    )
    await vi.waitFor(() =>
      expect(harness.promptGates).toHaveLength(1)
    )

    await harness.notify('goodbuddy/session/event', {
      sessionId: 'session-1',
      requestId: 'request-output-limit',
      type: 'reasoning',
      delta: 'x'.repeat(40)
    })
    await harness.notify('goodbuddy/session/event', {
      sessionId: 'session-1',
      requestId: 'request-output-limit',
      type: 'reasoning',
      delta: 'y'.repeat(40)
    })
    harness.promptGates[0]!.resolve({ stopReason: 'end_turn' })

    await expect(running).rejects.toThrow(
      '请求累计输出超过安全限制'
    )
    await harness.runtime.dispose()
  })

  it('keeps independent conversation sessions distinct', async () => {
    const harness = setup()
    const first = collect(
      harness.runtime.run(
        request('one'),
        new AbortController().signal
      )
    )
    const second = collect(
      harness.runtime.run(
        request('two'),
        new AbortController().signal
      )
    )
    await vi.waitFor(() =>
      expect(harness.promptGates).toHaveLength(2)
    )
    harness.promptGates[0]!.resolve({ stopReason: 'end_turn' })
    harness.promptGates[1]!.resolve({ stopReason: 'end_turn' })
    await Promise.all([first, second])

    const prompts = harness.requests.filter(
      ({ method }) => method === 'session/prompt'
    )
    expect(prompts.map(({ params }) => params.sessionId).sort()).toEqual([
      'session-1',
      'session-2'
    ])
    await harness.runtime.dispose()
  })

  it('fails Ask closed and never calls the authorizer', async () => {
    const harness = setup()
    const authorize = vi.fn().mockResolvedValue('once')
    const running = collect(
      harness.runtime.run(
        request('ask', 'ask'),
        new AbortController().signal,
        authorize
      )
    )
    await vi.waitFor(() =>
      expect(harness.promptGates).toHaveLength(1)
    )

    await expect(
      harness.permission(permission('session-1'))
    ).resolves.toEqual({
      outcome: { outcome: 'selected', optionId: 'reject' }
    })
    expect(authorize).not.toHaveBeenCalled()
    expect(harness.requests).toContainEqual({
      method: 'goodbuddy/session/prepare',
      params: {
        sessionId: 'session-1',
        requestId: 'request-ask',
        mode: 'ask'
      }
    })
    harness.promptGates[0]!.resolve({ stopReason: 'end_turn' })
    await running
    await harness.runtime.dispose()
  })

  it('authorizes Execute but can select only allow-once', async () => {
    const harness = setup()
    const authorize = vi.fn().mockResolvedValue('always')
    const running = collect(
      harness.runtime.run(
        request('execute'),
        new AbortController().signal,
        authorize
      )
    )
    await vi.waitFor(() =>
      expect(harness.promptGates).toHaveLength(1)
    )

    await expect(
      harness.permission(permission('session-1'))
    ).resolves.toEqual({
      outcome: {
        outcome: 'selected',
        optionId: 'allow-once'
      }
    })
    expect(authorize).toHaveBeenCalledWith({
      scopeKey: 'deepseek-harness:shell',
      title: 'Run tests',
      description: 'DeepSeek Harness 请求一次性执行此工具',
      toolName: 'shell',
      argumentSummary: '{\n  "command": "npm test"\n}',
      allowPermanent: false
    })
    harness.promptGates[0]!.resolve({ stopReason: 'end_turn' })
    await running
    await harness.runtime.dispose()
  })

  it('lists only bounded MCP schemas without exposing server secrets', async () => {
    const provider = toolProvider([
      mcpTool(),
      {
        ...mcpTool('workspace_read_text'),
        source: 'builtin'
      }
    ])
    const harness = setup({ toolProvider: provider })
    await harness.runtime.getStatus()

    await expect(
      harness.extension('goodbuddy/tools/list', {
        sessionId: 'session-catalog'
      })
    ).resolves.toEqual({
      tools: [
        {
          name: mcpTool().name,
          description: mcpTool().description,
          inputSchema: mcpTool().inputSchema
        }
      ]
    })
    expect(
      JSON.stringify(
        await harness.extension('goodbuddy/tools/list', {
          sessionId: 'session-catalog'
        })
      )
    ).not.toContain('secret')
    await harness.runtime.dispose()
  })

  it('rejects MCP calls in Ask mode without approval or execution', async () => {
    const provider = toolProvider()
    const harness = setup({ toolProvider: provider })
    const authorize = vi.fn().mockResolvedValue('once')
    const running = collect(
      harness.runtime.run(
        request('mcp-ask', 'ask'),
        new AbortController().signal,
        authorize
      )
    )
    await vi.waitFor(() =>
      expect(harness.promptGates).toHaveLength(1)
    )

    await expect(
      harness.extension('goodbuddy/tools/call', {
        sessionId: 'session-1',
        name: mcpTool().name,
        arguments: { kind: 'cube' }
      })
    ).rejects.toThrow('需要 Execute 模式')
    expect(authorize).not.toHaveBeenCalled()
    expect(provider.callTool).not.toHaveBeenCalled()
    harness.promptGates[0]!.resolve({ stopReason: 'end_turn' })
    await running
    await harness.runtime.dispose()
  })

  it('requires one-time approval before calling an assigned MCP tool', async () => {
    const provider = toolProvider()
    const harness = setup({ toolProvider: provider })
    const authorize = vi.fn().mockResolvedValue('once')
    const running = collect(
      harness.runtime.run(
        request('mcp-execute'),
        new AbortController().signal,
        authorize
      )
    )
    await vi.waitFor(() =>
      expect(harness.promptGates).toHaveLength(1)
    )

    await expect(
      harness.extension('goodbuddy/tools/call', {
        sessionId: 'session-1',
        name: mcpTool().name,
        arguments: { kind: 'cube' }
      })
    ).resolves.toEqual({
      content: [
        { type: 'text', text: '{"asset":"cube"}' }
      ]
    })
    expect(authorize).toHaveBeenCalledTimes(1)
    expect(provider.callTool).toHaveBeenCalledWith(
      mcpTool().name,
      { kind: 'cube' },
      expect.any(AbortSignal),
      expect.objectContaining({
        conversationId: 'mcp-execute',
        workMode: 'execute'
      })
    )
    harness.promptGates[0]!.resolve({ stopReason: 'end_turn' })
    await running
    await harness.runtime.dispose()
  })

  it('lists and calls a real local stdio MCP through the Main proxy', async () => {
    const provider = new ModelToolProvider(process.cwd(), [
      {
        id: 'fbf42200-4e60-48d0-b5f2-e816db38ac54',
        name: 'Local 3D Game Blueprint',
        description: 'Deterministic integration fixture',
        enabled: true,
        allowDynamicTools: false,
        assignments: ['deepseek-harness'],
        secretConfigured: false,
        transport: 'stdio',
        command: process.execPath,
        args: [
          resolve('tests', 'fixtures', 'web-3d-game-mcp.mjs')
        ]
      } satisfies ResolvedMcpServer
    ])
    const harness = setup({
      toolProvider: provider,
      promptTimeoutMs: 10_000
    })
    const authorize = vi.fn().mockResolvedValue('once')
    const running = collect(
      harness.runtime.run(
        request('real-mcp'),
        new AbortController().signal,
        authorize
      )
    )
    await vi.waitFor(() =>
      expect(harness.promptGates).toHaveLength(1)
    )

    try {
      const catalog = await harness.extension(
        'goodbuddy/tools/list',
        { sessionId: 'session-1' }
      )
      const tool = (
        catalog as {
          tools: Array<{
            name: string
            description: string
            inputSchema: Record<string, unknown>
          }>
        }
      ).tools.find((candidate) =>
        candidate.name.endsWith('_create_game_blueprint')
      )
      expect(tool).toMatchObject({
        description: expect.stringContaining(
          'offline WebGL game design'
        ),
        inputSchema: expect.objectContaining({ type: 'object' })
      })

      const result = await harness.extension(
        'goodbuddy/tools/call',
        {
          sessionId: 'session-1',
          name: tool!.name,
          arguments: {
            theme: 'neon-ruins',
            seed: 'goodbuddy-0.9.0',
            targetCount: 5
          }
        }
      )
      expect(result).toMatchObject({
        content: [
          {
            type: 'text',
            text: expect.stringContaining('"title":"Prism Relay"')
          }
        ]
      })
      const blueprint = JSON.parse(
        (
          result as {
            content: [{ type: 'text'; text: string }]
          }
        ).content[0].text
      ) as Record<string, unknown>
      expect(blueprint).toMatchObject({
        acceptance: {
          testSurface: 'window.__GOODBUDDY_GAME__'
        }
      })
      expect(authorize).toHaveBeenCalledOnce()
    } finally {
      harness.promptGates[0]?.resolve({ stopReason: 'end_turn' })
      await running.catch(() => undefined)
      await harness.runtime.dispose()
    }
  })

  it('does not execute an MCP tool when authorization is denied', async () => {
    const provider = toolProvider()
    const harness = setup({ toolProvider: provider })
    const authorize = vi.fn().mockResolvedValue('deny')
    const running = collect(
      harness.runtime.run(
        request('mcp-denied'),
        new AbortController().signal,
        authorize
      )
    )
    await vi.waitFor(() =>
      expect(harness.promptGates).toHaveLength(1)
    )

    await expect(
      harness.extension('goodbuddy/tools/call', {
        sessionId: 'session-1',
        name: mcpTool().name,
        arguments: { kind: 'cube' }
      })
    ).rejects.toThrow('未获执行授权')
    expect(provider.callTool).not.toHaveBeenCalled()
    harness.promptGates[0]!.resolve({ stopReason: 'end_turn' })
    await running
    await harness.runtime.dispose()
  })

  it('validates MCP arguments before requesting authorization', async () => {
    const provider = toolProvider()
    const harness = setup({ toolProvider: provider })
    const authorize = vi.fn().mockResolvedValue('once')
    const running = collect(
      harness.runtime.run(
        request('mcp-invalid'),
        new AbortController().signal,
        authorize
      )
    )
    await vi.waitFor(() =>
      expect(harness.promptGates).toHaveLength(1)
    )

    await expect(
      harness.extension('goodbuddy/tools/call', {
        sessionId: 'session-1',
        name: mcpTool().name,
        arguments: {}
      })
    ).rejects.toThrow('MCP 工具参数无效')
    expect(authorize).not.toHaveBeenCalled()
    expect(provider.callTool).not.toHaveBeenCalled()
    harness.promptGates[0]!.resolve({ stopReason: 'end_turn' })
    await running
    await harness.runtime.dispose()
  })

  it('translates AbortSignal to session/cancel', async () => {
    const harness = setup()
    const controller = new AbortController()
    const running = collect(
      harness.runtime.run(request('abort'), controller.signal)
    )
    await vi.waitFor(() =>
      expect(harness.promptGates).toHaveLength(1)
    )
    controller.abort(new Error('cancelled by user'))
    harness.promptGates[0]!.resolve({ stopReason: 'cancelled' })

    await expect(running).rejects.toThrow('cancelled by user')
    expect(harness.notifications).toContainEqual({
      method: 'session/cancel',
      params: { sessionId: 'session-1' }
    })
    await harness.runtime.dispose()
  })

  it('fails on bounded stderr overflow without exposing stderr text', async () => {
    const harness = setup()
    const running = collect(
      harness.runtime.run(
        request('stderr'),
        new AbortController().signal
      )
    )
    await vi.waitFor(() =>
      expect(harness.promptGates).toHaveLength(1)
    )
    const writer = harness.stderr.writable.getWriter()
    await writer.write(
      new TextEncoder().encode('private-secret-is-too-long')
    )
    await vi.waitFor(() =>
      expect(harness.child.terminate).toHaveBeenCalled()
    )
    harness.promptGates[0]!.resolve({ stopReason: 'end_turn' })

    await expect(running).rejects.toThrow('stderr 超过 16 字节')
    await expect(running).rejects.not.toThrow('private-secret')
    await harness.runtime.dispose()
  })

  it('reports process exit and fully disposes the connection and child', async () => {
    const harness = setup()
    await expect(harness.runtime.getStatus()).resolves.toMatchObject({
      available: true
    })
    harness.exit.resolve({ exitCode: 9 })
    await vi.waitFor(async () => {
      const status = await harness.runtime.getStatus()
      expect(status).toMatchObject({
        available: false,
        detail: 'DeepSeek Harness 进程意外退出（code 9）'
      })
    })

    await harness.runtime.dispose()
    expect(harness.child.terminate).toHaveBeenCalled()
  })

  it('fails closed when the required bridge handshake is unavailable', async () => {
    const harness = setup()
    harness.agent.extMethod.mockRejectedValueOnce(
      new Error('method not found')
    )

    await expect(harness.runtime.getStatus()).resolves.toMatchObject({
      available: false,
      detail: 'method not found'
    })
    expect(harness.child.terminate).toHaveBeenCalled()
  })

  it('times out a prompt, cancels it, and bounds disposal wait', async () => {
    const harness = setup()
    const running = collect(
      harness.runtime.run(
        request('timeout'),
        new AbortController().signal
      )
    )
    await expect(running).rejects.toThrow(
      'DeepSeek Harness 请求超时'
    )
    expect(harness.notifications).toContainEqual({
      method: 'session/cancel',
      params: { sessionId: 'session-1' }
    })
    await expect(harness.runtime.dispose()).resolves.toBeUndefined()
  })
})