tapimo 0.15.0 → 0.15.1

package/src/apps/data/App.test.ts

@@ -153,6 +153,32 @@ describe('MPP session management', () => {
     )
   })
 
+  test('keeps GET quota controls off generated management routes', async () => {
+    const rateLimitStore = Store.memory()
+    const limit = { limit: 1, period: 'minute' } satisfies RateLimit.Limit
+    const app = TestApp.create({
+      auth: {
+        mpp,
+        overrides: {
+          'GET /v1/scopes': { mpp: { bucket: 'scopes', rateLimit: limit } },
+        },
+      },
+      rateLimit: { store: rateLimitStore },
+    })
+    await RateLimit.memory({ store: rateLimitStore }).consume({
+      key: 'mpp:public:anonymous:bucket:scopes',
+      limit,
+    })
+
+    const response = await app.request('/v1/scopes', {
+      headers: { authorization: 'Payment not-a-credential' },
+      method: 'POST',
+    })
+
+    expect(response.status).toBe(402)
+    expect(response.headers.get('RateLimit-Limit')).toBe('100')
+  })
+
   test('applies POST auth overrides to QUERY aliases', async () => {
     const app = TestApp.create({
       auth: {

package/src/apps/data/routes/fee-amm.test.ts

@@ -428,6 +428,25 @@ describe.skip('GET /fee-amm/pools', () => {
 })
 
 describe('GET /fee-amm/pools query', () => {
+  test('applies the protective limit to public and API-key access', async () => {
+    const app = TestApp.create()
+    const publicResponse = await app.request('/v1/fee-amm/pools?include=token')
+    const publicOverflow = await app.request('/v1/fee-amm/pools?include=token')
+    const apiKeyResponse = await app.request('/v1/fee-amm/pools?include=token', TestApp.auth)
+    const apiKeyOverflow = await app.request('/v1/fee-amm/pools?include=token', TestApp.auth)
+
+    expect([
+      publicResponse.status,
+      publicOverflow.status,
+      apiKeyResponse.status,
+      apiKeyOverflow.status,
+    ]).toEqual([400, 402, 400, 402])
+    expect([
+      publicResponse.headers.get('RateLimit-Limit'),
+      apiKeyResponse.headers.get('RateLimit-Limit'),
+    ]).toEqual(['1', '1'])
+  })
+
   test('rejects the legacy token include', async () => {
     const response = await TestApp.create().request('/v1/fee-amm/pools?include=token', {
       headers: TestApp.auth.headers,

package/src/apps/data/routes/fee-amm.ts

@@ -319,7 +319,15 @@ export function feeAmm() {
   return new Hono<App.Environment>()
     .get(
       '/v1/fee-amm/pools',
-      Auth.policy({ apiKey: { scopes: ['data:read'] }, mpp: true, public: true }),
+      Auth.policy({
+        apiKey: {
+          bucket: 'fee-amm-pools',
+          rateLimit: { limit: 1, period: 'minute' },
+          scopes: ['data:read'],
+        },
+        mpp: { bucket: 'fee-amm-pools', rateLimit: { limit: 1, period: 'minute' } },
+        public: { bucket: 'fee-amm-pools', rateLimit: { limit: 1, period: 'minute' } },
+      }),
       OpenApi.validate('query', schema.getFeeAmmPools.Query, {
         code: 'query_invalid',
         message: 'Invalid query parameters',
@@ -344,7 +352,7 @@ export function feeAmm() {
         tags: ['Fee AMM'],
       }),
       Cache.response<App.Environment>({
-        cacheControl: Cache.policies.state,
+        cacheControl: Cache.policies.noStore,
         name: 'tempo-api:fee-amm-pools:v2',
         key: (c) => Cache.urlKey(c, schema.getFeeAmmPools.Query),
       }),

package/src/apps/data/routes/rpc.test.ts

@@ -144,6 +144,38 @@ describe('POST /rpc', () => {
     }
   })
 
+  test('rejects oversized anonymous requests before proxying upstream', async () => {
+    const requests: Request[] = []
+    const server = await Relay.createServer(
+      RequestListener.fromFetchHandler((request) => {
+        requests.push(request)
+        return Response.json({ id: 1, jsonrpc: '2.0', result: '0x1' })
+      }),
+    )
+
+    try {
+      const app = TestApp.create({ rpc: { url: server.url } })
+      const request = new Request('http://tempo-api.test/rpc', {
+        body: JSON.stringify({
+          id: 1,
+          jsonrpc: '2.0',
+          method: 'eth_call',
+          params: [`0x${'ab'.repeat(32_768)}`, 'latest'],
+        }),
+        method: 'POST',
+      })
+      expect(request.headers.get('content-length')).toBeNull()
+
+      const response = await app.fetch(request)
+
+      expect(response.status).toBe(413)
+      expect(await response.json()).toMatchObject({ error: { code: 'payload_too_large' } })
+      expect(requests).toHaveLength(0)
+    } finally {
+      await server.closeAsync()
+    }
+  })
+
   test('routes by principal: a resolver sees the request principal and routes accordingly', async () => {
     const fetch = mockRpc()
     // A resolver that routes API-key principals to the private upstream and

package/src/apps/data/routes/rpc.ts

@@ -278,9 +278,8 @@ async function handleRpc(c: Context<App.Environment>) {
   const zoneToken = getZoneToken(c)
   const apiKeyRequired = requiresApiKey(c)
   const inspectBody = apiKeyRequired || Boolean(zone)
-  const inspection = inspectBody ? await inspectRpcBody(c.req.raw) : undefined
+  const inspection = inspectBody ? await inspectRpcRequest(c.req.raw) : undefined
   if (inspection && inspection.result === undefined) {
-    await inspection.body?.cancel()
     return Response.error(c, {
       code: 'payload_too_large',
       message: 'RPC requests requiring method inspection must not exceed 64 KiB.',
@@ -469,6 +468,38 @@ async function inspectNotificationOnly(request: Request): Promise<boolean> {
   }
 }
 
+async function inspectRpcRequest(request: Request): Promise<RpcInspection> {
+  const contentLength = Number(request.headers.get('content-length'))
+  if (Number.isFinite(contentLength) && contentLength > maxRpcInspectionBytes) {
+    await request.body?.cancel()
+    return { body: null, result: undefined }
+  }
+  if (!request.body) return { body: null, result: { empty: true, ok: false } }
+
+  const reader = request.body.getReader()
+  const chunks: Uint8Array<ArrayBuffer>[] = []
+  let size = 0
+  while (size <= maxRpcInspectionBytes) {
+    const read = await reader.read()
+    if (read.done) break
+    size += read.value.byteLength
+    if (size > maxRpcInspectionBytes) {
+      await reader.cancel()
+      return { body: null, result: undefined }
+    }
+    chunks.push(read.value)
+  }
+
+  const bytes = joinChunks(chunks, size)
+  const body = new ReadableStream<Uint8Array<ArrayBuffer>>({
+    start(controller) {
+      controller.enqueue(bytes)
+      controller.close()
+    },
+  })
+  return { body, result: parseRpcBody(bytes) }
+}
+
 function hasZoneWriteScope(c: Context<App.Environment>, chainId: number): boolean {
   const principal = Auth.getPrincipal(c)
   if (principal?.type !== 'api_key') return false
@@ -712,20 +743,26 @@ async function inspectRpcBody(response: Request | globalThis.Response): Promise<
   })
   if (!complete || size > maxRpcInspectionBytes) return { body, result: undefined }
 
+  const bytes = joinChunks(chunks, size)
+  return { body, result: parseRpcBody(bytes) }
+}
+
+function joinChunks(chunks: readonly Uint8Array<ArrayBuffer>[], size: number) {
   const bytes = new Uint8Array(size)
   let offset = 0
   for (const chunk of chunks) {
     bytes.set(chunk, offset)
     offset += chunk.byteLength
   }
-  const result = (() => {
-    try {
-      return { ok: true as const, value: JSON.parse(new TextDecoder().decode(bytes)) as unknown }
-    } catch {
-      return { empty: size === 0, ok: false as const }
-    }
-  })()
-  return { body, result }
+  return bytes
+}
+
+function parseRpcBody(bytes: Uint8Array<ArrayBuffer>): RpcInspection['result'] {
+  try {
+    return { ok: true, value: JSON.parse(new TextDecoder().decode(bytes)) as unknown }
+  } catch {
+    return { empty: bytes.byteLength === 0, ok: false }
+  }
 }
 
 function rpcProviderFailure(cause: unknown, chainId: number): Log.ProviderFailure {

package/src/apps/data/routes/webhooks.scan.test.ts

@@ -239,6 +239,35 @@ describe('scanBlock', () => {
     expect(invalid.invalid).toHaveLength(1)
   })
 
+  test('delivers an anonymous LOG0 event matched by address', () => {
+    const result = AppWebhooks.scanBlock({
+      block: block(),
+      logs: [customLog({ topics: [] })],
+      subscriptions: [subscription('log:emitted', { address: callTarget })],
+    })
+
+    expect(result.invalid).toEqual([])
+    expect(result.matches).toHaveLength(1)
+    expect(result.matches[0]?.data).toMatchObject({
+      address: callTarget,
+      data: `0x${'0'.repeat(63)}1`,
+      logIndex: 7,
+      topics: [],
+      transactionHash,
+    })
+  })
+
+  test('rejects raw logs with malformed topics', () => {
+    const result = AppWebhooks.scanBlock({
+      block: block(),
+      logs: [customLog({ topics: ['invalid'] })],
+      subscriptions: [subscription('log:emitted', { address: callTarget })],
+    })
+
+    expect(result.matches).toEqual([])
+    expect(result.invalid).toEqual([])
+  })
+
   test('rolls back partial matches when a matcher throws mid-block', () => {
     const signature = 'event Named(string value)'
     const namedTopic = encodeEventTopics({ abi: [parseAbiItem(signature)] })[0]

package/src/apps/data/routes/webhooks.test.ts

@@ -2144,6 +2144,12 @@ describe('matchesOperator', () => {
     expect(Webhooks.matchesOperator('0x200', op, 'number')).toBe(false)
   })
 
+  test('compare accepts decoded integer values', () => {
+    const op = { gte: '100', lte: '200' }
+    expect(Webhooks.matchesOperator(150n, op, 'number')).toBe(true)
+    expect(Webhooks.matchesOperator(201, op, 'number')).toBe(false)
+  })
+
   test('bytes selector matches the first four bytes', () => {
     expect(Webhooks.matchesOperator('0xa9059cbbdeadbeef', { selector: '0xa9059cbb' })).toBe(true)
     expect(Webhooks.matchesOperator('0x12345678deadbeef', { selector: '0xa9059cbb' })).toBe(false)

package/src/apps/data/routes/webhooks.ts

@@ -908,9 +908,12 @@ export namespace schema {
             z.meta({ examples: ['2026-01-14T18:38:03.685Z'] }),
           ),
         topics: z.array(Schema.Hash).check(
-          z.describe('Log topics, starting with the event signature hash (topic 0).'),
+          z.describe(
+            'Zero to four log topics; non-anonymous events start with the event signature hash.',
+          ),
           z.meta({
             examples: [
+              [],
               [
                 '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
                 '0x000000000000000000000000e7687128b0a808c2831ff94d4f7b2fb35c65af38',
@@ -2421,10 +2424,14 @@ function serializeArgs(value: unknown): unknown {
 const toBig = (value: unknown) => BigInt(String(value))
 
 /** Case-insensitive equality for string fields; bigint equality for numeric. */
-function operandEquals(value: string, target: unknown, kind: 'number' | 'string'): boolean {
+function operandEquals(
+  value: bigint | number | string,
+  target: unknown,
+  kind: 'number' | 'string',
+): boolean {
   return kind === 'number'
     ? toBig(value) === toBig(target)
-    : value.toLowerCase() === String(target).toLowerCase()
+    : String(value).toLowerCase() === String(target).toLowerCase()
 }
 
 /**
@@ -2442,17 +2449,18 @@ function operandEquals(value: string, target: unknown, kind: 'number' | 'string'
  * - `{ startsWith }` → hex prefix
  */
 export function matchesOperator(
-  value: string | undefined,
+  value: bigint | number | string | undefined,
   op: unknown,
   kind: 'number' | 'string' = 'string',
 ): boolean {
   if (value === undefined) return false
   if (typeof op !== 'object' || op === null) return operandEquals(value, op, kind)
   const o = op as Record<string, unknown>
+  const value_string = String(value)
   if ('selector' in o)
-    return value.slice(0, 10).toLowerCase() === String(o['selector']).toLowerCase()
+    return value_string.slice(0, 10).toLowerCase() === String(o['selector']).toLowerCase()
   if ('startsWith' in o)
-    return value.toLowerCase().startsWith(String(o['startsWith']).toLowerCase())
+    return value_string.toLowerCase().startsWith(String(o['startsWith']).toLowerCase())
   if ('in' in o) return (o['in'] as readonly unknown[]).some((v) => operandEquals(value, v, kind))
   if ('not' in o) return !operandEquals(value, o['not'], kind)
   if ('eq' in o && kind === 'string') return operandEquals(value, o['eq'], kind)
@@ -2535,13 +2543,12 @@ function toLogEvent(
   const blockNumber = log.blockNumber === null ? undefined : Number(log.blockNumber)
   const logIndex = log.logIndex ?? undefined
   const transactionIndex = log.transactionIndex ?? undefined
-  const topics = log.topics.filter((t): t is string => typeof t === 'string')
-  const topic0 = Schema.Hash.safeParse(topics[0])
+  const topics = z.array(Schema.Hash).safeParse(log.topics)
   const data = typeof log.data === 'string' ? log.data : '0x'
   if (
     !address.success ||
     !transactionHash.success ||
-    !topic0.success ||
+    !topics.success ||
     blockNumber === undefined ||
     logIndex === undefined ||
     transactionIndex === undefined ||
@@ -2555,15 +2562,17 @@ function toLogEvent(
     data,
     logIndex,
     timestamp,
-    topics,
+    topics: topics.data,
     transactionHash: transactionHash.data,
     transactionIndex,
   }
   if (!signature || !event || log.args === undefined) return base
+  const topic0 = topics.data[0]
+  if (!topic0) return undefined
   return {
     ...base,
     args: serializeArgs(log.args) as Record<string, unknown>,
-    event: { name: event.name, signature, topic0: topic0.data },
+    event: { name: event.name, signature, topic0 },
   }
 }
 
@@ -2736,7 +2745,11 @@ function matchesLog(
       const numeric = /^u?int/.test(input.type)
       const value = args[name]
       const normalized = input.type === 'address' ? lowercaseLeaves(op) : op
-      if (!matchesOperator(asString(value), normalized, numeric ? 'number' : 'string')) return false
+      const operand =
+        typeof value === 'bigint' || typeof value === 'number' || typeof value === 'string'
+          ? value
+          : undefined
+      if (!matchesOperator(operand, normalized, numeric ? 'number' : 'string')) return false
     }
   }
   return true

package/src/apps/management/routes/verified-token-requests.test.ts

@@ -247,10 +247,18 @@ describe('POST /v1/orgs/:orgId/verified-token-requests', () => {
     expect(body.error?.code).toBe('request_pending_exists')
   })
 
-  test('caps pending requests per organization', async () => {
+  test('caps pending requests per requester after an organization is deleted', async () => {
     const context = createApp()
     const requests = context.client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}']['verified-token-requests']
     const { org, owner } = await setup(context)
+    const nextResponse = await context.client.v1.orgs.$post(
+      { json: { name: 'Next' } },
+      as(owner.cookie),
+    )
+    expect(nextResponse.status).toBe(200)
+    if (nextResponse.status !== 200)
+      throw new Error(`Failed to create organization: ${nextResponse.status}`)
+    const next = await nextResponse.json()
 
     for (let index = 0; index < 10; index++) {
       const created = await requests.$post(
@@ -267,10 +275,16 @@ describe('POST /v1/orgs/:orgId/verified-token-requests', () => {
       expect(created.status).toBe(200)
     }
 
+    const deleted = await context.client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].$delete(
+      { param: { orgId: org.id } },
+      as(owner.cookie),
+    )
+    expect(deleted.status).toBe(200)
+
     const overflow = await requests.$post(
       {
         json: { ...token, address: `0x20c${'f'.padStart(37, '0')}` as `0x${string}`, symbol: 'tOVER' }, // prettier-ignore
-        param: { orgId: org.id },
+        param: { orgId: next.id },
       },
       as(owner.cookie),
     )

package/src/apps/management/routes/verified-token-requests.ts

@@ -239,9 +239,6 @@ const paramValidation = {
   message: 'Check the path parameters and try again.',
 } as const
 
-/** Maximum open (pending) requests per organization. */
-const maxPending = 10
-
 /** Mounts organization verified-token request operations. */
 export function verifiedTokenRequests() {
   return new Hono<Environment>()
@@ -265,7 +262,7 @@ export function verifiedTokenRequests() {
             },
             409: {
               codes: ['request_limit_reached', 'request_pending_exists', 'verified_symbol_exists', 'verified_token_exists'], // prettier-ignore
-              description: 'The token is already verified or requested, or the organization is at its pending-request limit.', // prettier-ignore
+              description: 'The token is already verified or requested, or the requester is at the pending-request limit.', // prettier-ignore
             },
           },
           success: { description: 'Created request.', schema: schema.VerifiedTokenRequest },
@@ -297,12 +294,6 @@ export function verifiedTokenRequests() {
               message: 'A verified token already uses this symbol',
               status: 409,
             })
-          if ((await VerifiedTokenRequests.countPending(db, orgId)) >= maxPending)
-            return Response.error(c, {
-              code: 'request_limit_reached',
-              message: `Organizations may have at most ${maxPending} pending requests`,
-              status: 409,
-            })
           const record = await VerifiedTokenRequests.create(db, {
             address: body.address,
             chainId: body.chainId,
@@ -330,6 +321,12 @@ export function verifiedTokenRequests() {
             200,
           )
         } catch (cause) {
+          if (cause instanceof VerifiedTokenRequests.PendingLimitError)
+            return Response.error(c, {
+              code: 'request_limit_reached',
+              message: `Requesters may have at most ${VerifiedTokenRequests.maxPendingPerRequester} pending requests`,
+              status: 409,
+            })
           return Response.upstream(c, cause)
         }
       },

package/src/apps/mcp.test.ts

@@ -1,6 +1,6 @@
 import { Cli as incur_Cli, z } from 'incur'
 import { data } from 'tapimo/apps'
-import { App } from 'tapimo/server'
+import { App, Store } from 'tapimo/server'
 
 import * as TestApp from '../../test/App.js'
 import * as Runtime from '../../test/runtime.js'
@@ -42,32 +42,36 @@ function docsStub() {
 type Host = { fetch: (request: Request) => Response | Promise<Response> }
 
 async function request(host: Host, body: unknown, headers: Record<string, string> = {}) {
-  const response = await host.fetch(
-    new Request(new URL('/mcp', origin), {
-      body: JSON.stringify(body),
-      headers: {
-        accept: 'application/json, text/event-stream',
-        'content-type': 'application/json',
-        ...headers,
-      },
-      method: 'POST',
-    }),
-  )
+  const request = new Request(new URL('/mcp', origin), {
+    body: JSON.stringify(body),
+    headers: {
+      accept: 'application/json, text/event-stream',
+      'content-type': 'application/json',
+      ...headers,
+    },
+    method: 'POST',
+  })
+  if (request.headers.has('cf-connecting-ip')) Object.assign(request, { cf: {} })
+  const response = await host.fetch(request)
   expect(response.status).toBe(200)
   return (await response.json()) as { result: any }
 }
 
-function initialize(host: Host) {
-  return request(host, {
-    id: 1,
-    jsonrpc: '2.0',
-    method: 'initialize',
-    params: {
-      capabilities: {},
-      clientInfo: { name: 'test-client', version: '1.0.0' },
-      protocolVersion: '2025-03-26',
+function initialize(host: Host, headers: Record<string, string> = {}) {
+  return request(
+    host,
+    {
+      id: 1,
+      jsonrpc: '2.0',
+      method: 'initialize',
+      params: {
+        capabilities: {},
+        clientInfo: { name: 'test-client', version: '1.0.0' },
+        protocolVersion: '2025-03-26',
+      },
     },
-  })
+    headers,
+  )
 }
 
 async function toolsList(host: Host) {
@@ -109,8 +113,8 @@ async function toolsSearch(host: Host) {
 }
 
 /** Loads the complete schema and metadata for one catalog tool. */
-async function toolDetails(host: Host, name: string) {
-  return resultJson(await toolsCall(host, 'get_tool_details', { name })) as {
+async function toolDetails(host: Host, name: string, headers: Record<string, string> = {}) {
+  return resultJson(await toolsCall(host, 'get_tool_details', { name }, headers)) as {
     annotations?: { readOnlyHint?: boolean }
     inputSchema: { properties?: Record<string, { description?: string }> }
     name: string
@@ -124,7 +128,7 @@ async function generatedToolCall(
   args: Record<string, unknown>,
   headers: Record<string, string> = {},
 ) {
-  const details = await toolDetails(host, name)
+  const details = await toolDetails(host, name, headers)
   return toolsCall(
     host,
     details.annotations?.readOnlyHint === true ? 'call_read_tool' : 'call_write_tool',
@@ -246,6 +250,85 @@ test('forwards the caller Authorization header to authenticated tools', async ()
   expect(resultJson(allowed)).toMatchObject({ data: [] })
 })
 
+test('preserves Cloudflare client identity across concurrent generated tools', async () => {
+  const store = Store.memory()
+  const db = TestApp.database()
+  await TestApp.verifiedSeed(db, Runtime.get().chainId)
+  const app = App.create({
+    auth: { rateLimit: { store } },
+    cache: { edge: false },
+    db,
+  }).route('/', data())
+  app.route('/', mcp({ docs: false, fetch: (request) => app.fetch(request) }))
+  const headers_a = { 'cf-connecting-ip': '203.0.113.7' }
+  const headers_b = { 'cf-connecting-ip': '198.51.100.9' }
+  await initialize(app, headers_a)
+
+  const [result_a, result_b] = await Promise.all([
+    generatedToolCall(app, 'v1_tokens_get', { verified: true }, headers_a),
+    generatedToolCall(app, 'v1_tokens_get', { verified: true }, headers_b),
+  ])
+
+  expect(result_a.isError, JSON.stringify(result_a.content)).toBeFalsy()
+  expect(result_b.isError, JSON.stringify(result_b.content)).toBeFalsy()
+  const keys = (await store.list({ prefix: 'ratelimit:' })).keys.map((key) => key.name)
+  expect(keys.some((key) => key.endsWith('public:203.0.113.7'))).toBe(true)
+  expect(keys.some((key) => key.endsWith('public:198.51.100.9'))).toBe(true)
+  expect(keys.some((key) => key.endsWith('public:anonymous'))).toBe(false)
+})
+
+test('allows an IP-restricted API key through generated tools', async () => {
+  const db = TestApp.database()
+  await TestApp.verifiedSeed(db, Runtime.get().chainId)
+  const key = {
+    ...TestApp.key,
+    allowedIps: ['203.0.113.0/24'],
+  }
+  const app = App.create({
+    auth: {},
+    cache: { edge: false },
+    db,
+    kv: { store: TestApp.kvStore({ keys: [key] }) },
+  }).route('/', data())
+  app.route('/', mcp({ docs: false, fetch: (request) => app.fetch(request) }))
+  const headers = {
+    authorization: `Bearer ${key.token}`,
+    'cf-connecting-ip': '203.0.113.7',
+  }
+  await initialize(app, headers)
+
+  const result = await generatedToolCall(app, 'v1_tokens_get', { verified: true }, headers)
+
+  expect(result.isError, JSON.stringify(result.content)).toBeFalsy()
+})
+
+test('preserves a configured trusted client identity through generated tools', async () => {
+  const db = TestApp.database()
+  await TestApp.verifiedSeed(db, Runtime.get().chainId)
+  const key = {
+    ...TestApp.key,
+    allowedIps: ['198.51.100.0/24'],
+  }
+  const app = App.create({
+    auth: { public: { clientIp: (request) => request.headers.get('x-real-ip') ?? undefined } },
+    cache: { edge: false },
+    db,
+    kv: { store: TestApp.kvStore({ keys: [key] }) },
+  }).route('/', data())
+  app.route('/', mcp({ docs: false, fetch: (request) => app.fetch(request) }))
+  const headers = {
+    authorization: `Bearer ${key.token}`,
+    'cf-connecting-ip': '203.0.113.7',
+    'tempo-mcp-client-ip': '192.0.2.1',
+    'x-real-ip': '198.51.100.9',
+  }
+  await initialize(app, headers)
+
+  const result = await generatedToolCall(app, 'v1_tokens_get', { verified: true }, headers)
+
+  expect(result.isError, JSON.stringify(result.content)).toBeFalsy()
+})
+
 test('proxies docs tool calls to the remote MCP source', async () => {
   const { host } = createHost({ docs: docsStub() })
   await initialize(host)

package/src/apps/mcp.ts

@@ -16,6 +16,9 @@ const routesTagGroup = 'Routes API'
 /** Tags inside the group hidden from MCP: partner-shaped CoinGecko mirrors and the MCP endpoint itself. */
 const excludedTags = ['CoinGecko', 'MCP']
 
+/** Internal header carrying the trusted caller identity through incur's generated request. */
+const clientIpHeader = 'tempo-mcp-client-ip'
+
 /** Usage guidance surfaced to MCP clients on initialize. */
 const instructions =
   "Tempo MCP provides access to the Tempo API's data and Routes domains, plus documentation. Authenticated tools accept a Tempo API key sent as an `Authorization: Bearer` header on the HTTP request. List endpoints paginate via `cursor`/`nextCursor`. `docs_*` tools search the Tempo documentation."
@@ -106,7 +109,11 @@ export function mcp(options: mcp.Options) {
       // them onto the caller origin and dispatch in-process.
       fetch: (request) => {
         const url = new URL(request.url)
-        return fetch(new Request(new URL(url.pathname + url.search, origin), request))
+        const address = request.headers.get(clientIpHeader)
+        const forwarded = new Request(new URL(url.pathname + url.search, origin), request)
+        forwarded.headers.delete(clientIpHeader)
+        if (address) Auth.trustClientIp(forwarded, address)
+        return fetch(forwarded)
       },
       mcp: { instructions, title },
       openapi: scope(document),
@@ -115,7 +122,7 @@ export function mcp(options: mcp.Options) {
       // forwarded `Authorization` header).
       openapiConfig: {
         compact: true,
-        forwardHeaders: ['authorization'],
+        forwardHeaders: ['authorization', clientIpHeader],
         mode: 'namespace',
         security: false,
       },
@@ -130,7 +137,12 @@ export function mcp(options: mcp.Options) {
     const cli = await resolve(new URL(c.req.url).origin)
     // incur routes on the first path segment; pin the path to `/mcp` so a
     // mount prefix never leaks into its router.
-    return cli.fetch(new Request(new URL('/mcp', c.req.url), c.req.raw))
+    const request = new Request(new URL('/mcp', c.req.url), c.req.raw)
+    // Replace caller input with the identity resolved by the outer auth boundary.
+    request.headers.delete(clientIpHeader)
+    const address = Auth.getTrustedClientIp(c)
+    if (address) request.headers.set(clientIpHeader, address)
+    return cli.fetch(request)
   }
 
   // The documented POST carries the auth policy (described routes are