mppx 0.6.31 → 0.8.0

package/src/{mcp-sdk → mcp}/client/McpClient.integration.test.ts

@@ -6,29 +6,30 @@ import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/
 import { createMcpExpressApp } from '@modelcontextprotocol/sdk/server/express.js'
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js'
-import { session as tempo_session_client, tempo as tempo_client } from 'mppx/client'
+import { sessionLegacy as tempo_session_client, tempo as tempo_client } from 'mppx/client'
 import { Mppx as Mppx_server, tempo as tempo_server } from 'mppx/server'
 import type { Address } from 'viem'
 import { readContract } from 'viem/actions'
 import { Actions, Addresses } from 'viem/tempo'
 import { beforeAll, describe, expect, test } from 'vp/test'
-import { nodeEnv } from '~test/config.js'
-import { deployEscrow, signTopUpChannel } from '~test/tempo/session.js'
+import { tempoNetwork } from '~test/config.js'
+import { deployEscrow, signTopUpChannel } from '~test/tempo/legacy/session.js'
 import { accounts, asset, client as testClient, fundAccount } from '~test/tempo/viem.js'
 
 import * as Credential from '../../Credential.js'
 import * as core_Mcp from '../../Mcp.js'
 import * as Store from '../../Store.js'
-import * as ChannelStore from '../../tempo/session/ChannelStore.js'
-import type { SessionReceipt } from '../../tempo/session/Types.js'
+import type { SessionReceipt } from '../../tempo/session/precompile/Protocol.js'
+import * as ChannelStore from '../../tempo/session/server/ChannelStore.js'
 import * as McpServer_transport from '../server/Transport.js'
 import * as McpClient from './McpClient.js'
 
 const realm = 'api.example.com'
-const secretKey = 'test-secret-key'
+const secretKey = 'test-secret-key-test-secret-key-32'
 const chargeAmountRaw = 1_000_000n
 const doubleSessionAmountRaw = chargeAmountRaw * 2n
 const topUpAmountRaw = chargeAmountRaw * 3n
+const isLocalnet = tempoNetwork === 'localnet'
 
 let escrowContract: Address
 
@@ -40,7 +41,7 @@ beforeAll(async () => {
   await fundAccount({ address: accounts[2].address, token: asset })
 }, 60_000)
 
-describe.runIf(nodeEnv === 'localnet')('McpClient.wrap integration', () => {
+describe.runIf(isLocalnet)('McpClient.wrap integration', () => {
   const scenarios: readonly Scenario[] = [
     {
       name: 'charge intent settles a paid MCP tool against the live chain',
@@ -409,6 +410,7 @@ describe.runIf(nodeEnv === 'localnet')('McpClient.wrap integration', () => {
 type WrappedClient = {
   callTool: (
     params: { name: string; arguments?: Record<string, unknown>; _meta?: Record<string, unknown> },
+    resultSchema?: undefined,
     options?: { context?: unknown; timeout?: number },
   ) => Promise<McpClient.CallToolResult>
 }
@@ -464,7 +466,7 @@ async function createHarness(options?: {
         currency: asset,
         getClient: () => testClient,
       }),
-      tempo_server.session({
+      tempo_server.sessionLegacy({
         account: accounts[0],
         currency: asset,
         escrowContract,
@@ -544,9 +546,14 @@ async function createHarness(options?: {
   const clientTransport = new StreamableHTTPClientTransport(new URL(`${httpServer.url}/mcp`))
   await sdkClient.connect(clientTransport as never)
 
-  const mcp = McpClient.wrap(sdkClient, {
-    methods: [chargeMethod, sessionMethod],
-  })
+  // Wrap a facade over the same session so `sdkClient` keeps raw (challenge-
+  // throwing) behavior for the credential-level scenarios below.
+  const mcp = McpClient.wrap(
+    { callTool: sdkClient.callTool.bind(sdkClient) as Client['callTool'] },
+    {
+      methods: [chargeMethod, sessionMethod],
+    },
+  )
 
   return {
     async close() {

package/src/{mcp-sdk → mcp}/client/McpClient.test-d.ts

@@ -6,7 +6,7 @@ import { describe, expectTypeOf, test } from 'vp/test'
 import * as McpClient from './McpClient.js'
 
 describe('McpClient.wrap', () => {
-  test('returns wrapped client with callTool', () => {
+  test('returns the original client with payment-aware callTool', () => {
     const client = {} as Client
     const wrapped = McpClient.wrap(client, {
       methods: [
@@ -16,6 +16,9 @@ describe('McpClient.wrap', () => {
       ],
     })
 
+    expectTypeOf(wrapped).toEqualTypeOf<
+      McpClient.wrap.McpClient<Client, readonly [ReturnType<typeof tempo>]>
+    >()
     expectTypeOf(wrapped.callTool).toBeFunction()
     expectTypeOf(wrapped.callTool).returns.toExtend<Promise<McpClient.CallToolResult>>()
   })
@@ -50,19 +53,36 @@ describe('McpClient.wrap', () => {
     expectTypeOf(wrapped.customProp).toEqualTypeOf<string>()
   })
 
-  test('callTool accepts context when method has context', () => {
+  test('callTool keeps the MCP SDK result schema and options positions', () => {
+    const client = {} as Client
+    const wrapped = McpClient.wrap(client, {
+      methods: [
+        tempo({
+          account: {} as Account,
+        }),
+      ],
+    })
+
+    expectTypeOf(wrapped.callTool).toBeCallableWith({ name: 'tool' })
+    expectTypeOf(wrapped.callTool).toBeCallableWith({ name: 'tool' }, undefined, {})
+    expectTypeOf(wrapped.callTool).toBeCallableWith({ name: 'tool' }, undefined, {
+      timeout: 5000,
+    })
+  })
+
+  test('callTool accepts context in the options position', () => {
     const client = {} as Client
     const wrapped = McpClient.wrap(client, {
       methods: [tempo({})],
     })
 
-    expectTypeOf(wrapped.callTool).toBeCallableWith(
-      { name: 'tool' },
-      { context: { account: {} as Account } },
-    )
+    expectTypeOf(wrapped.callTool).toBeCallableWith({ name: 'tool' }, undefined, {
+      context: { account: {} as Account },
+      timeout: 5000,
+    })
   })
 
-  test('callTool context is optional when account provided at creation', () => {
+  test('callTool accepts a per-call approval hook in the options position', () => {
     const client = {} as Client
     const wrapped = McpClient.wrap(client, {
       methods: [
@@ -72,9 +92,12 @@ describe('McpClient.wrap', () => {
       ],
     })
 
-    expectTypeOf(wrapped.callTool).toBeCallableWith({ name: 'tool' })
-    expectTypeOf(wrapped.callTool).toBeCallableWith({ name: 'tool' }, {})
-    expectTypeOf(wrapped.callTool).toBeCallableWith({ name: 'tool' }, { timeout: 5000 })
+    expectTypeOf(wrapped.callTool).toBeCallableWith({ name: 'tool' }, undefined, {
+      onPaymentRequired: async (challenge) => challenge.intent === 'charge',
+    })
+    expectTypeOf(wrapped.callTool).toBeCallableWith({ name: 'tool' }, undefined, {
+      onPaymentRequired: null,
+    })
   })
 
   test('callTool result includes receipt', () => {
@@ -90,6 +113,16 @@ describe('McpClient.wrap', () => {
     expectTypeOf(wrapped.callTool({} as never)).resolves.toHaveProperty('receipt')
     expectTypeOf(wrapped.callTool({} as never)).resolves.toHaveProperty('content')
   })
+
+  test('can store an inferred client as the exported client type', () => {
+    const client = {} as Client
+
+    const wrapped = McpClient.wrap(client, {
+      methods: [tempo({ account: {} as Account })],
+    })
+
+    expectTypeOf(wrapped).toMatchTypeOf<McpClient.wrap.McpClient>()
+  })
 })
 
 describe('McpClient.wrap.McpClient', () => {
@@ -101,10 +134,11 @@ describe('McpClient.wrap.McpClient', () => {
 })
 
 describe('McpClient.wrap.CallToolOptions', () => {
-  test('has context and timeout properties', () => {
+  test('has context, approval hook, and timeout properties', () => {
     type Options = McpClient.wrap.CallToolOptions
 
     expectTypeOf<Options>().toHaveProperty('context')
+    expectTypeOf<Options>().toHaveProperty('onPaymentRequired')
     expectTypeOf<Options>().toHaveProperty('timeout')
   })
 })

package/src/{mcp-sdk → mcp}/client/McpClient.test.ts

@@ -14,7 +14,31 @@ import * as McpServer_transport from '../server/Transport.js'
 import * as McpClient from './McpClient.js'
 
 const realm = 'api.example.com'
-const secretKey = 'test-secret-key'
+const secretKey = 'test-secret-key-test-secret-key-32'
+
+function createChallenge() {
+  return Challenge.fromMethod(Methods.charge, {
+    realm,
+    secretKey,
+    expires: new Date(Date.now() + 60_000).toISOString(),
+    request: {
+      amount: '1',
+      currency: asset,
+      decimals: 6,
+      recipient: accounts[0].address,
+    },
+  })
+}
+
+function createReceipt(challenge: Challenge.Challenge): core_Mcp.Receipt {
+  return {
+    challengeId: challenge.id,
+    method: 'tempo',
+    reference: 'test',
+    status: 'success',
+    timestamp: new Date().toISOString(),
+  }
+}
 
 describe('McpClient.wrap', () => {
   let client: Client
@@ -97,10 +121,9 @@ describe('McpClient.wrap', () => {
       ],
     })
 
-    const result = await mcp.callTool(
-      { name: 'premium_tool', arguments: {} },
-      { context: { account: accounts[1] } },
-    )
+    const result = await mcp.callTool({ name: 'premium_tool', arguments: {} }, undefined, {
+      context: { account: accounts[1] },
+    })
 
     expect(result.content).toEqual([{ type: 'text', text: 'Premium tool executed' }])
     expect(result.receipt?.status).toBe('success')
@@ -122,6 +145,25 @@ describe('McpClient.wrap', () => {
     expect(result.receipt).toBeUndefined()
   })
 
+  test('behavior: does not forward empty options', async () => {
+    const rawCallTool = vi.fn(async () => ({
+      content: [{ type: 'text' as const, text: 'Free tool executed' }],
+    }))
+    const mcp = McpClient.wrap(
+      { callTool: rawCallTool as Client['callTool'] },
+      { methods: [Method.toClient(Methods.charge, { createCredential: vi.fn() })] },
+    )
+
+    const result = await mcp.callTool({ name: 'free_tool', arguments: {} }, undefined, {})
+
+    expect(result.content).toEqual([{ type: 'text', text: 'Free tool executed' }])
+    expect(rawCallTool).toHaveBeenCalledWith(
+      { name: 'free_tool', arguments: {} },
+      undefined,
+      undefined,
+    )
+  })
+
   test('behavior: throws when no account provided', async () => {
     const mcp = McpClient.wrap(client, {
       methods: [
@@ -226,6 +268,170 @@ describe('McpClient.wrap', () => {
   })
 })
 
+describe('McpClient.wrap (in-place)', () => {
+  test('default: mutates the existing client and handles payment', async () => {
+    const challenge = createChallenge()
+    const createCredential = vi.fn(async ({ challenge }) =>
+      Credential.serialize({
+        challenge,
+        payload: { signature: '0xsignature', type: 'transaction' },
+      }),
+    )
+    const rawCallTool = vi
+      .fn()
+      .mockRejectedValueOnce(
+        new McpError(core_Mcp.paymentRequiredCode, 'Payment Required', {
+          httpStatus: 402,
+          challenges: [challenge],
+        }),
+      )
+      .mockResolvedValueOnce({
+        _meta: { [core_Mcp.receiptMetaKey]: createReceipt(challenge) },
+        content: [{ type: 'text', text: 'Premium tool executed' }],
+      })
+    const fakeClient = { callTool: rawCallTool as Client['callTool'] }
+
+    const wrapped = McpClient.wrap(fakeClient, {
+      methods: [Method.toClient(Methods.charge, { createCredential })],
+    })
+
+    expect(wrapped).toBe(fakeClient)
+
+    const result = await wrapped.callTool({ name: 'premium_tool', arguments: {} })
+
+    expect(result.content).toEqual([{ type: 'text', text: 'Premium tool executed' }])
+    expect(result.isError).toBeUndefined()
+    expect(result.receipt).toBeDefined()
+    expect(result.receipt?.status).toBe('success')
+    expect(rawCallTool).toHaveBeenCalledTimes(2)
+    expect(createCredential).toHaveBeenCalledOnce()
+  })
+
+  test('behavior: preserves the MCP SDK callTool argument shape', async () => {
+    const rawCallTool = vi.fn(async () => ({
+      content: [{ type: 'text' as const, text: 'Free tool executed' }],
+    }))
+    const createCredential = vi.fn()
+    const fakeClient = { callTool: rawCallTool as Client['callTool'] }
+
+    const wrapped = McpClient.wrap(fakeClient, {
+      methods: [Method.toClient(Methods.charge, { createCredential })],
+    })
+
+    const result = await wrapped.callTool({ name: 'free_tool', arguments: {} }, undefined, {
+      timeout: 30_000,
+    })
+
+    expect(result.content).toEqual([{ type: 'text', text: 'Free tool executed' }])
+    expect(result.receipt).toBeUndefined()
+    expect(rawCallTool).toHaveBeenCalledWith({ name: 'free_tool', arguments: {} }, undefined, {
+      timeout: 30_000,
+    })
+    expect(createCredential).not.toHaveBeenCalled()
+  })
+
+  test('behavior: strips payment context from MCP SDK request options', async () => {
+    const rawCallTool = vi.fn(async () => ({
+      content: [{ type: 'text' as const, text: 'Free tool executed' }],
+    }))
+    const fakeClient = { callTool: rawCallTool as Client['callTool'] }
+
+    const wrapped = McpClient.wrap(fakeClient, {
+      methods: [tempo_client({})],
+    })
+
+    await wrapped.callTool({ name: 'free_tool', arguments: {} }, undefined, {
+      context: { account: accounts[1] },
+      timeout: 30_000,
+    })
+
+    expect(rawCallTool).toHaveBeenCalledWith({ name: 'free_tool', arguments: {} }, undefined, {
+      timeout: 30_000,
+    })
+  })
+
+  test('behavior: re-wrapping replaces config without stacking wrappers', async () => {
+    const challenge = createChallenge()
+
+    const rawCallTool = vi
+      .fn()
+      .mockRejectedValueOnce(
+        new McpError(core_Mcp.paymentRequiredCode, 'Payment Required', {
+          httpStatus: 402,
+          challenges: [challenge],
+        }),
+      )
+      .mockResolvedValueOnce({
+        _meta: { [core_Mcp.receiptMetaKey]: createReceipt(challenge) },
+        content: [{ type: 'text', text: 'paid' }],
+      })
+
+    const fakeClient = { callTool: rawCallTool as Client['callTool'] }
+    const staleCreateCredential = vi.fn(async () => {
+      throw new Error('stale config used')
+    })
+    const freshCreateCredential = vi.fn(async ({ challenge }) =>
+      Credential.serialize({
+        challenge,
+        payload: { signature: '0xsignature', type: 'transaction' },
+      }),
+    )
+
+    McpClient.wrap(fakeClient, {
+      methods: [Method.toClient(Methods.charge, { createCredential: staleCreateCredential })],
+    })
+    const wrapped = McpClient.wrap(fakeClient, {
+      methods: [Method.toClient(Methods.charge, { createCredential: freshCreateCredential })],
+    })
+
+    const result = await wrapped.callTool({ name: 'premium_tool', arguments: {} })
+
+    expect(result.content).toEqual([{ type: 'text', text: 'paid' }])
+    expect(result.receipt?.status).toBe('success')
+    expect(staleCreateCredential).not.toHaveBeenCalled()
+    expect(freshCreateCredential).toHaveBeenCalledOnce()
+    expect(rawCallTool).toHaveBeenCalledTimes(2)
+  })
+
+  test('behavior: handles payment challenge metadata returned as a tool result', async () => {
+    const challenge = createChallenge()
+    const createCredential = vi.fn(async ({ challenge }) =>
+      Credential.serialize({
+        challenge,
+        payload: { signature: '0xsignature', type: 'transaction' },
+      }),
+    )
+    const rawCallTool = vi
+      .fn()
+      .mockResolvedValueOnce({
+        _meta: {
+          [core_Mcp.paymentRequiredMetaKey]: {
+            challenges: [challenge],
+            httpStatus: 402,
+          },
+        },
+        content: [{ type: 'text', text: 'Payment Required' }],
+        isError: true,
+      })
+      .mockResolvedValueOnce({
+        _meta: { [core_Mcp.receiptMetaKey]: createReceipt(challenge) },
+        content: [{ type: 'text', text: 'Premium tool executed' }],
+      })
+
+    const wrapped = McpClient.wrap(
+      { callTool: rawCallTool as Client['callTool'] },
+      { methods: [Method.toClient(Methods.charge, { createCredential })] },
+    )
+
+    const result = await wrapped.callTool({ name: 'premium_tool', arguments: {} })
+
+    expect(result.content).toEqual([{ type: 'text', text: 'Premium tool executed' }])
+    expect(result.receipt?.status).toBe('success')
+    expect(createCredential).toHaveBeenCalledOnce()
+    expect(rawCallTool).toHaveBeenCalledTimes(2)
+  })
+})
+
 describe('isPaymentRequiredError', () => {
   test('returns true for McpError with payment code and challenges', () => {
     const error = new McpError(core_Mcp.paymentRequiredCode, 'Payment Required', {