@gemus/mcp-proxy 0.1.9 → 0.1.10

package/src/__tests__/failFast.test.ts

@@ -1,356 +0,0 @@
-/**
- * @gemus/mcp-proxy fail-fast (#2068) — single-pass upstream-disconnect correlation.
- *
- * Pure logic; the socket is an injected `realFetch` returning controllable `Response`s. Cases that
- * involve the final-safety timer use fake timers with advanceTimersByTimeAsync (lesson: fake timers
- * + real reader.read() promises need the async advance to flush continuations).
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { parseRequestIds, isCodexOriginated, createSseIdScanner, createFailFast, isJsonRpcResponse } from '../failFast.mjs'
-
-const enc = new TextEncoder()
-
-/** A response body that emits the given SSE frames then closes. */
-function bodyOf(...frames: string[]): ReadableStream<Uint8Array> {
-  return new ReadableStream<Uint8Array>({
-    start(c) {
-      for (const f of frames) c.enqueue(enc.encode(f))
-      c.close()
-    },
-  })
-}
-/** A response body that never emits and never closes (zombie stream). */
-function neverBody(): ReadableStream<Uint8Array> {
-  return new ReadableStream<Uint8Array>({ start() {} })
-}
-function sseRes(body: ReadableStream<Uint8Array> | null, init?: { status?: number; contentType?: string }) {
-  const status = init?.status ?? 200
-  return new Response(body, { status, headers: { 'content-type': init?.contentType ?? 'text/event-stream' } })
-}
-function resultFrame(id: number | string): string {
-  return `event: message\ndata: ${JSON.stringify({ jsonrpc: '2.0', id, result: { ok: true } })}\n\n`
-}
-function post(id: number | string, method = 'tools/call') {
-  return { method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', id, method, params: {} }) }
-}
-async function drain(res: Response): Promise<void> {
-  const r = res.body!.getReader()
-  for (;;) { const { done } = await r.read(); if (done) break }
-}
-
-describe('parseRequestIds', () => {
-  it('extracts the id from a POST JSON-RPC request', () => {
-    expect(parseRequestIds(post(42))).toEqual([42])
-  })
-  it('extracts all ids from a batch', () => {
-    const body = JSON.stringify([
-      { jsonrpc: '2.0', id: 1, method: 'a' },
-      { jsonrpc: '2.0', id: 2, method: 'b' },
-    ])
-    expect(parseRequestIds({ method: 'POST', body })).toEqual([1, 2])
-  })
-  it('returns [] for GET / DELETE / bodyless requests', () => {
-    expect(parseRequestIds({ method: 'GET' })).toEqual([])
-    expect(parseRequestIds({ method: 'DELETE' })).toEqual([])
-    expect(parseRequestIds({ method: 'POST' })).toEqual([])
-  })
-  it('returns [] for non-JSON body and for notifications (no id)', () => {
-    expect(parseRequestIds({ method: 'POST', body: 'not json' })).toEqual([])
-    expect(parseRequestIds({ method: 'POST', body: JSON.stringify({ jsonrpc: '2.0', method: 'x' }) })).toEqual([])
-  })
-})
-
-describe('isCodexOriginated', () => {
-  it.each([
-    [42, true],
-    ['abc', true],
-    ['gemus-bf-3', false],
-    ['gemus-ping-9', false],
-    [null, false],
-    [undefined, false],
-  ])('id=%s → %s', (id, expected) => {
-    expect(isCodexOriginated(id as never)).toBe(expected)
-  })
-})
-
-describe('isJsonRpcResponse', () => {
-  it('is true for a result/error response, false for a request or notification', () => {
-    expect(isJsonRpcResponse({ id: 1, result: {} })).toBe(true)
-    expect(isJsonRpcResponse({ id: 1, error: {} })).toBe(true)
-    expect(isJsonRpcResponse({ id: 1, method: 'elicitation/create', params: {} })).toBe(false) // server→client request
-    expect(isJsonRpcResponse({ method: 'notifications/x' })).toBe(false)
-    expect(isJsonRpcResponse(null)).toBe(false)
-  })
-})
-
-describe('createSseIdScanner', () => {
-  it('yields the id of a complete RESPONSE frame; ignores comment lines', () => {
-    const s = createSseIdScanner()
-    expect(s.push(enc.encode(': keepalive\n\n'))).toEqual([])
-    expect(s.push(enc.encode(resultFrame(7)))).toEqual([7])
-  })
-  it('does NOT yield a server→client REQUEST id (has a method) — avoids id-collision premature settle', () => {
-    const s = createSseIdScanner()
-    const reqFrame = `event: message\ndata: ${JSON.stringify({ jsonrpc: '2.0', id: 3, method: 'elicitation/create', params: {} })}\n\n`
-    expect(s.push(enc.encode(reqFrame))).toEqual([])
-  })
-  it('buffers a half-frame split across chunks until its boundary arrives', () => {
-    const s = createSseIdScanner()
-    const frame = resultFrame(5)
-    const mid = Math.floor(frame.length / 2)
-    expect(s.push(enc.encode(frame.slice(0, mid)))).toEqual([])
-    expect(s.push(enc.encode(frame.slice(mid)))).toEqual([5])
-  })
-  it('handles CRLF line endings (normalizes to LF)', () => {
-    const s = createSseIdScanner()
-    const crlf = `event: message\r\ndata: ${JSON.stringify({ jsonrpc: '2.0', id: 8, result: {} })}\r\n\r\n`
-    expect(s.push(enc.encode(crlf))).toEqual([8])
-  })
-  it('ignores non-JSON data payloads', () => {
-    const s = createSseIdScanner()
-    expect(s.push(enc.encode('data: not-json\n\n'))).toEqual([])
-  })
-})
-
-describe('createFailFast.fetch', () => {
-  it('injects a JSON-RPC error when the stream closes before the result', async () => {
-    const onLost = vi.fn()
-    const realFetch = vi.fn(async () => sseRes(bodyOf(': keepalive\n\n'))) // no result frame → lost
-    const ff = createFailFast({ onLost, realFetch })
-
-    const res = await ff.fetch('u', post(42))
-    await drain(res)
-
-    expect(onLost).toHaveBeenCalledTimes(1)
-    expect(onLost).toHaveBeenCalledWith(42, { kind: 'stream' })
-    expect(ff.failedIds.has('42')).toBe(true)
-  })
-
-  it('does NOT inject an error when the result crosses the wire before close', async () => {
-    const onLost = vi.fn()
-    const realFetch = vi.fn(async () => sseRes(bodyOf(resultFrame(42))))
-    const ff = createFailFast({ onLost, realFetch })
-
-    const res = await ff.fetch('u', post(42))
-    await drain(res)
-
-    expect(onLost).not.toHaveBeenCalled()
-    expect(ff.failedIds.has('42')).toBe(false)
-  })
-
-  it('fails fast immediately when realFetch throws before any response', async () => {
-    const onLost = vi.fn()
-    const realFetch = vi.fn(async () => {
-      throw new Error('socket reset', { cause: Object.assign(new Error('inner socket failure'), { code: 'ECONNRESET' }) })
-    })
-    const ff = createFailFast({ onLost, realFetch })
-
-    await expect(ff.fetch('u', post(7))).rejects.toThrow('socket reset')
-    expect(onLost).toHaveBeenCalledWith(7, { kind: 'connection', code: 'ECONNRESET' })
-    expect(realFetch).toHaveBeenCalledTimes(1) // must NOT retry — a 2nd fetch could execute the tool
-  })
-
-  it('allowlists a nested connection code without exposing hostile raw diagnostics or retrying', async () => {
-    const hostile =
-      'Authorization: Bearer arbitrary-secret at '
-      + 'https://alice:password@example.test/api/mcp?token=query-secret '
-      + 'via 203.0.113.1,2001:db8::1'
-    const onLost = vi.fn()
-    const log = vi.fn()
-    const rejection = new Error(`outer ${hostile}`, {
-      cause: new Error(`middle ${hostile}`, {
-        cause: Object.assign(new Error(`inner ${hostile}`), {
-          code: 'UND_ERR_CONNECT_TIMEOUT',
-        }),
-      }),
-    })
-    const realFetch = vi.fn(async () => { throw rejection })
-    const ff = createFailFast({ onLost, log, realFetch })
-
-    await expect(ff.fetch('u', post(71))).rejects.toBe(rejection)
-
-    expect(realFetch).toHaveBeenCalledTimes(1)
-    expect(onLost).toHaveBeenCalledTimes(1)
-    expect(onLost).toHaveBeenCalledWith(71, {
-      kind: 'connection',
-      code: 'UND_ERR_CONNECT_TIMEOUT',
-    })
-    const diagnostics = JSON.stringify(log.mock.calls)
-    expect(diagnostics).not.toMatch(
-      /arbitrary-secret|alice|password|query-secret|203\.0\.113\.1|2001:db8/,
-    )
-  })
-
-  it('classifies an established SSE reader error before its result as a stream failure', async () => {
-    const readerError = new Error('established stream failed')
-    let pulls = 0
-    const body = new ReadableStream<Uint8Array>({
-      pull(controller) {
-        if (pulls++ === 0) {
-          controller.enqueue(enc.encode(': established\n\n'))
-        } else {
-          controller.error(readerError)
-        }
-      },
-    })
-    const onLost = vi.fn()
-    const realFetch = vi.fn(async () => sseRes(body))
-    const ff = createFailFast({ onLost, realFetch })
-
-    const res = await ff.fetch('u', post(72))
-    await expect(drain(res)).rejects.toBe(readerError)
-
-    expect(onLost).toHaveBeenCalledTimes(1)
-    expect(onLost).toHaveBeenCalledWith(72, { kind: 'stream' })
-  })
-
-  it('classifies downstream cancellation before its result as a stream failure', async () => {
-    const onLost = vi.fn()
-    const realFetch = vi.fn(async () => sseRes(neverBody()))
-    const ff = createFailFast({ onLost, realFetch })
-    const res = await ff.fetch('u', post(73))
-    const reader = res.body!.getReader()
-
-    await reader.cancel('downstream closed')
-
-    expect(onLost).toHaveBeenCalledTimes(1)
-    expect(onLost).toHaveBeenCalledWith(73, { kind: 'stream' })
-  })
-
-  it('fails fast on a non-ok HTTP response', async () => {
-    const onLost = vi.fn()
-    const realFetch = vi.fn(async () => sseRes(null, { status: 404, contentType: 'application/json' }))
-    const ff = createFailFast({ onLost, realFetch })
-
-    await ff.fetch('u', post(7))
-    expect(onLost).toHaveBeenCalledWith(7, { kind: 'http', status: 404 })
-  })
-
-  it('passes GET and DELETE through untouched (no body → no monitoring, no onLost)', async () => {
-    const onLost = vi.fn()
-    const getRes = sseRes(bodyOf())
-    const realFetch = vi.fn(async () => getRes)
-    const ff = createFailFast({ onLost, realFetch })
-
-    const g = await ff.fetch('u', { method: 'GET' })
-    const d = await ff.fetch('u', { method: 'DELETE' })
-    expect(g).toBe(getRes)
-    expect(d).toBe(getRes)
-    expect(onLost).not.toHaveBeenCalled()
-  })
-
-  it('does not track internal gemus-bf-* / gemus-ping-* ids', async () => {
-    const onLost = vi.fn()
-    const realFetch = vi.fn(async () => sseRes(bodyOf(': keepalive\n\n'))) // closes with no result
-    const ff = createFailFast({ onLost, realFetch })
-
-    await drain(await ff.fetch('u', post('gemus-bf-1')))
-    await drain(await ff.fetch('u', post('gemus-ping-2')))
-    expect(onLost).not.toHaveBeenCalled()
-  })
-
-  it('degrades to plain passthrough if internal logic throws', async () => {
-    const onLost = vi.fn()
-    const badRes = { ok: true, status: 200, headers: { get() { throw new Error('boom') } }, body: null } as unknown as Response
-    const realFetch = vi.fn(async () => badRes)
-    const ff = createFailFast({ onLost, realFetch })
-
-    const res = await ff.fetch('u', post(1))
-    expect(res).toBe(badRes)              // returns the response we ALREADY have — no re-fetch
-    expect(realFetch).toHaveBeenCalledTimes(1)
-    expect(onLost).not.toHaveBeenCalled()
-    ff.dispose()
-  })
-
-  it('isolates concurrent requests — disconnecting one does not affect the other', async () => {
-    const onLost = vi.fn()
-    const realFetch = vi
-      .fn()
-      .mockResolvedValueOnce(sseRes(bodyOf(': keepalive\n\n')))   // id 1 → dies with no result
-      .mockResolvedValueOnce(sseRes(bodyOf(resultFrame(2))))      // id 2 → delivers
-    const ff = createFailFast({ onLost, realFetch })
-
-    await drain(await ff.fetch('u', post(1)))
-    await drain(await ff.fetch('u', post(2)))
-
-    expect(onLost).toHaveBeenCalledTimes(1)
-    expect(onLost.mock.calls[0][0]).toBe(1)
-  })
-
-  it('does not settle a healthy concurrent request when another connection rejects before response', async () => {
-    let healthyController!: ReadableStreamDefaultController<Uint8Array>
-    const healthyBody = new ReadableStream<Uint8Array>({
-      start(controller) { healthyController = controller },
-    })
-    const connectionError = Object.assign(new Error('connection rejected'), {
-      code: 'ECONNREFUSED',
-    })
-    const onLost = vi.fn()
-    const realFetch = vi.fn(async (_url: unknown, init: { body?: unknown }) => {
-      const [{ id }] = [JSON.parse(String(init.body))]
-      if (id === 74) throw connectionError
-      return sseRes(healthyBody)
-    })
-    const ff = createFailFast({ onLost, realFetch })
-
-    const rejecting = ff.fetch('u', post(74))
-    const healthy = ff.fetch('u', post(75))
-    await expect(rejecting).rejects.toBe(connectionError)
-    const healthyResponse = await healthy
-
-    expect(onLost).toHaveBeenCalledTimes(1)
-    expect(onLost).toHaveBeenCalledWith(74, {
-      kind: 'connection',
-      code: 'ECONNREFUSED',
-    })
-    healthyController.enqueue(enc.encode(resultFrame(75)))
-    healthyController.close()
-    await drain(healthyResponse)
-    expect(onLost).toHaveBeenCalledTimes(1)
-    expect(ff.failedIds.has('75')).toBe(false)
-  })
-
-  describe('idle safety timeout', () => {
-    beforeEach(() => vi.useFakeTimers())
-    afterEach(() => vi.useRealTimers())
-
-    it('injects an error for a zombie connection that never emits a byte', async () => {
-      const onLost = vi.fn()
-      const realFetch = vi.fn(async () => sseRes(neverBody()))
-      const ff = createFailFast({ onLost, realFetch, idleTimeoutMs: 120_000 })
-
-      await ff.fetch('u', post(99)) // never emits → idle timer is never reset
-      expect(onLost).not.toHaveBeenCalled()
-      await vi.advanceTimersByTimeAsync(120_000)
-      expect(onLost).toHaveBeenCalledWith(99, { kind: 'idle' })
-      ff.dispose()
-    })
-
-    it('does NOT kill a healthy-but-slow stream — heartbeat bytes reset the idle timer', async () => {
-      const onLost = vi.fn()
-      let ctl!: ReadableStreamDefaultController<Uint8Array>
-      const body = new ReadableStream<Uint8Array>({ start(c) { ctl = c } })
-      const realFetch = vi.fn(async () => sseRes(body))
-      const ff = createFailFast({ onLost, realFetch, idleTimeoutMs: 100 })
-
-      const res = await ff.fetch('u', post(1))
-      const reader = res.body!.getReader()
-
-      // Keepalive every 60ms (< 100ms idle) for 300ms total — each read touches → never fires.
-      for (let i = 0; i < 5; i++) {
-        ctl.enqueue(enc.encode(': keepalive\n\n'))
-        await reader.read()
-        await vi.advanceTimersByTimeAsync(60)
-      }
-      expect(onLost).not.toHaveBeenCalled() // survived 300ms > idleTimeout because bytes kept flowing
-
-      // Now the result arrives and the stream closes → still no fail-fast.
-      ctl.enqueue(enc.encode(resultFrame(1)))
-      await reader.read()
-      ctl.close()
-      await reader.read()
-      expect(onLost).not.toHaveBeenCalled()
-      ff.dispose()
-    })
-  })
-})

package/src/__tests__/fixtures/proxy-runtime-loader.mjs

@@ -1,216 +0,0 @@
-function moduleUrl(source) {
-  return `data:text/javascript,${encodeURIComponent(source)}`
-}
-
-const markerPrelude = `
-  import fs from 'node:fs'
-  function mark(name) {
-    const file = process.env.PROXY_TEST_CONSTRUCTION_LOG
-    if (file) fs.appendFileSync(file, name + '\\n')
-  }
-`
-
-const modules = new Map([
-  ['@gemus/codex-backfill-core', `
-    export const CLIENT_CAPABILITIES = []
-    export const CLIENT_CAPABILITIES_HEADER = 'X-Gemus-Client-Capabilities'
-    export function serializeClientCapabilities(value) { return JSON.stringify(value) }
-    export function unwrapMcpContent(value) { return value }
-  `],
-  ['@modelcontextprotocol/sdk/server/stdio.js', `
-    ${markerPrelude}
-    export class StdioServerTransport {
-      constructor() { mark('stdio-transport') }
-      async start() {
-        if (process.env.PROXY_TEST_STDIO_START_FAILURE === '1') {
-          this.onclose?.()
-          throw new Error(
-            'stdio failed Authorization: Bearer '
-            + process.env.GEMUS_KEY
-            + ' at '
-            + process.env.GEMUS_URL
-          )
-        }
-        if (process.env.PROXY_TEST_FORWARD_STDIN === '1') {
-          let input = ''
-          process.stdin.setEncoding('utf8')
-          process.stdin.on('data', (chunk) => {
-            input += chunk
-            for (;;) {
-              const newline = input.indexOf('\\n')
-              if (newline < 0) break
-              const line = input.slice(0, newline).trim()
-              input = input.slice(newline + 1)
-              if (line) this.onmessage?.(JSON.parse(line))
-            }
-          })
-        }
-        process.stdin.resume()
-        process.stdin.once('end', () => this.onclose?.())
-        if (process.env.PROXY_TEST_SIGNAL_AFTER_START === 'SIGTERM') {
-          setTimeout(() => {
-            if (process.platform === 'win32') {
-              process.emit('SIGTERM')
-            } else {
-              process.kill(process.pid, 'SIGTERM')
-            }
-          }, 0)
-        }
-      }
-      async send(message) {
-        if (process.env.PROXY_TEST_STDIO_CAPTURE_SEND === '1') {
-          process.stdout.write(JSON.stringify(message) + '\\n')
-        }
-      }
-    }
-  `],
-  ['@modelcontextprotocol/sdk/client/streamableHttp.js', `
-    ${markerPrelude}
-    export class StreamableHTTPClientTransport {
-      constructor(url, options) {
-        mark('upstream-transport')
-        this.url = url
-        this.fetch = options.fetch
-      }
-      async start() {}
-      async send(message) {
-        if (
-          process.env.PROXY_TEST_UPSTREAM_INITIALIZE_FAILURE === '1'
-          && message?.method === 'initialize'
-        ) {
-          throw new Error(
-            'initialize fetch failed Authorization: Bearer '
-            + process.env.GEMUS_KEY
-            + ' at '
-            + process.env.GEMUS_URL
-          )
-        }
-        if (
-          process.env.PROXY_TEST_UPSTREAM_INITIALIZE_FETCH_FAILURE === '1'
-          && message?.method === 'initialize'
-        ) {
-          await this.fetch(this.url, {
-            method: 'POST',
-            headers: { Authorization: 'Bearer ' + process.env.GEMUS_KEY },
-            body: JSON.stringify(message),
-          })
-        }
-        if (
-          process.env.PROXY_TEST_LATE_RESULT === '1'
-          && message?.method === 'tools/call'
-        ) {
-          await this.fetch(this.url, {
-            method: 'POST',
-            body: JSON.stringify(message),
-          })
-          setTimeout(() => {
-            this.onmessage?.({
-              jsonrpc: '2.0',
-              id: message.id,
-              result: { content: [{ type: 'text', text: 'late-real-result' }] },
-            })
-          }, 80)
-        }
-      }
-      async terminateSession() {
-        mark('upstream-terminate-session')
-        if (process.env.PROXY_TEST_TERMINATE_SESSION_HANG === '1') {
-          return await new Promise(() => {})
-        }
-        if (process.env.PROXY_TEST_TERMINATE_SESSION_REJECT === '1') {
-          throw new Error('terminate session rejected')
-        }
-      }
-      async close() { mark('upstream-transport-close') }
-    }
-  `],
-  ['undici', `
-    ${markerPrelude}
-    export class Agent {
-      constructor() { mark('upstream-http-agent') }
-      async close() { mark('upstream-http-shutdown') }
-      destroy() { mark('upstream-http-destroy') }
-    }
-    export class Pool {
-      destroy() { mark('upstream-origin-destroy') }
-    }
-    export async function fetch() {
-      mark('undici-fetch')
-      if (process.env.PROXY_TEST_LATE_RESULT === '1') {
-        return new Response(
-          new ReadableStream({ start() {} }),
-          { headers: { 'content-type': 'text/event-stream' } },
-        )
-      }
-      const error = new Error(
-        'connect failed Authorization: Bearer '
-        + process.env.GEMUS_KEY
-        + ' at '
-        + process.env.GEMUS_URL
-        + ' via 203.0.113.1,2001:db8::1'
-      )
-      error.cause = { code: 'UND_ERR_CONNECT_TIMEOUT' }
-      throw error
-    }
-  `],
-  ['node:http', `
-    ${markerPrelude}
-    function hookError() {
-      return new Error(
-        'hook listen failed Authorization: Bearer '
-        + process.env.GEMUS_KEY
-        + ' at '
-        + process.env.GEMUS_URL
-      )
-    }
-    const http = {
-      createServer() {
-        mark('hook-server')
-        const listeners = new Map()
-        return {
-          on(event, handler) { listeners.set(event, handler); return this },
-          listen(_port, _host, callback) {
-            if (process.env.PROXY_TEST_HOOK_LISTEN_FAILURE === '1') {
-              queueMicrotask(() => listeners.get('error')?.(hookError()))
-            } else {
-              queueMicrotask(callback)
-            }
-            return this
-          },
-          address() { return { port: 43114 } },
-          unref() {},
-          close() {
-            mark('hook-server-close')
-            if (process.env.PROXY_TEST_HOOK_ERROR_AFTER_CLOSE === '1') {
-              queueMicrotask(() => listeners.get('error')?.(hookError()))
-            }
-          },
-        }
-      },
-    }
-    export default http
-  `],
-  ['./backfill.mjs', `
-    ${markerPrelude}
-    export function createBackfiller() {
-      mark('backfiller')
-      return {
-        observeCall() { mark('backfiller-observe-call') },
-        observeResult() { mark('backfiller-observe-result') },
-        async backfillTurn() {},
-      }
-    }
-    export function injectSteering() { return false }
-  `],
-])
-
-export async function resolve(specifier, context, nextResolve) {
-  const source = modules.get(specifier)
-  if (
-    source !== undefined
-    && (specifier !== './backfill.mjs' || context.parentURL?.endsWith('/proxy.mjs'))
-  ) {
-    return { url: moduleUrl(source), shortCircuit: true }
-  }
-  return nextResolve(specifier, context)
-}

package/src/__tests__/mcpHeaders.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { CLIENT_CAPABILITIES } from '@gemus/codex-backfill-core'
-import { buildProxyUpstreamHeaders } from '../mcpHeaders.mjs'
-
-describe('buildProxyUpstreamHeaders', () => {
-  it('advertises only the capabilities the proxy can actually fulfil', () => {
-    expect(buildProxyUpstreamHeaders('mak_test123')).toEqual({
-      Authorization: 'Bearer mak_test123',
-      'X-Gemus-Client-Capabilities': 'agent-authored-prompts,codex-imagen',
-    })
-  })
-
-  it('never advertises codex-instant-delivery — the proxy has no ImageScheduler to renew the lease (#2049)', () => {
-    // 该能力门控服务端的 AWAITING_CLIENT execute 分支，要求客户端有 scheduler 每 60s renewLease。
-    // 只有 bridge 有（且 probe 门控，见 bridge/src/cli.ts）。proxy 没有 —— 发了它就等于承诺一个
-    // 永不到来的续租 → 5min 后 CLIENT_LEASE_EXPIRED → 图 orphan 成孤立 image-upload 节点。
-    // absent → 服务端回退经典两阶段 client-delivered 协议，proxy 完全支持（backfill.mjs）。
-    const header = buildProxyUpstreamHeaders('mak_test123')['X-Gemus-Client-Capabilities']
-    expect(header).not.toContain('codex-instant-delivery')
-  })
-
-  it('stays a strict subset of the shared allowlist — a new capability must not auto-inherit (#2049)', () => {
-    // 回归门：本 bug 的成因正是 proxy 发「整个 CLIENT_CAPABILITIES 数组」—— #1969 往数组里加了
-    // codex-instant-delivery，proxy 就自动继承了一个它做不到的承诺，而 #1990 把红掉的断言改成
-    // 迎合它。此断言让「加能力」与「proxy 声称支持它」变成两个独立决策，不再自动传染。
-    const advertised = buildProxyUpstreamHeaders('mak_test123')['X-Gemus-Client-Capabilities'].split(',')
-    for (const capability of advertised) {
-      expect(CLIENT_CAPABILITIES).toContain(capability)
-    }
-    expect(advertised.length).toBeLessThan(CLIENT_CAPABILITIES.length)
-  })
-})

package/src/__tests__/proxyMessages.test.ts

@@ -1,81 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { createProxyFailure, publicMessageForFailure } from '../proxyMessages.mjs'
-
-describe('publicMessageForFailure', () => {
-  it.each([
-    [
-      { kind: 'connection', code: 'UND_ERR_CONNECT_TIMEOUT' },
-      'Gemus upstream connection failed before a response was received',
-    ],
-    [
-      { kind: 'http', status: 503 },
-      'Gemus upstream returned an HTTP error before the tool result was delivered',
-    ],
-    [
-      { kind: 'stream' },
-      'Gemus upstream stream disconnected before the tool result was delivered',
-    ],
-    [
-      { kind: 'idle' },
-      'Gemus upstream stream became unresponsive before the tool result was delivered',
-    ],
-  ])('maps $kind to its delivery-stage message', (failure, expected) => {
-    expect(publicMessageForFailure(failure)).toBe(expected)
-  })
-
-  it('fails closed for an unknown failure kind', () => {
-    expect(publicMessageForFailure({ kind: 'hostile-secret-kind' })).toBe(
-      'Gemus upstream failed before the tool result was delivered',
-    )
-  })
-
-  it.each(['toString', 'constructor', '__proto__'])(
-    'fails closed for the Object.prototype property name %s',
-    (kind) => {
-      expect(publicMessageForFailure({ kind })).toBe(
-        'Gemus upstream failed before the tool result was delivered',
-      )
-    },
-  )
-})
-
-describe('createProxyFailure', () => {
-  it('preserves the original JSON-RPC id in the public error envelope', () => {
-    expect(createProxyFailure('request-17', { kind: 'stream' }).response).toEqual({
-      jsonrpc: '2.0',
-      id: 'request-17',
-      error: {
-        code: -32000,
-        message: 'Gemus upstream stream disconnected before the tool result was delivered',
-      },
-    })
-  })
-
-  it.each([
-    [
-      {
-        kind: 'connection',
-        code: 'UND_ERR_CONNECT_TIMEOUT',
-        reason: 'Authorization: Bearer secret at https://alice:password@example.test/api/mcp?token=secret',
-        addresses: ['203.0.113.1', '2001:db8::1'],
-      },
-      { id: 41, kind: 'connection', code: 'UND_ERR_CONNECT_TIMEOUT' },
-    ],
-    [
-      {
-        kind: 'http',
-        status: 503,
-        reason: 'https://alice:password@example.test/api/mcp?token=secret',
-      },
-      { id: 41, kind: 'http', status: 503 },
-    ],
-  ])('keeps only safe diagnostic fields for $kind failures', (failure, expected) => {
-    const result = createProxyFailure(41, failure)
-    const serialized = JSON.stringify(result)
-
-    expect(result.diagnostic).toEqual(expected)
-    expect(serialized).not.toMatch(
-      /Authorization|Bearer|secret|alice|password|example\.test|203\.0\.113\.1|2001:db8/,
-    )
-  })
-})