mppx 0.0.1 → 0.1.0

package/src/internal/types.ts

@@ -0,0 +1,403 @@
+/** Combines members of an intersection into a readable type. */
+// https://twitter.com/mattpocockuk/status/1622730173446557697?s=20&t=NdpAcmEFXY01xkqU3KO0Mg
+export type Compute<type> = { [key in keyof type]: type[key] } & unknown
+
+declare const symbol: unique symbol
+
+/**
+ * Creates a branded type of `T` with the brand `U`.
+ *
+ * @example
+ * ```ts
+ * type Result = Branded<string, 'foo'>
+ * //   ^? type Result = string & { [symbol]: 'foo' }
+ * ```
+ */
+export type Branded<T, U> = T & { [symbol]: U }
+
+/**
+ * Filters out all members of `T` that are not `P`
+ *
+ * @example
+ * ```ts
+ * type Result = Filter<['a', 'b', 'c'], 'b'>
+ * //   ^? type Result = ['a', 'c']
+ * ```
+ *
+ * @internal
+ */
+export type Filter<
+  T extends readonly unknown[],
+  P,
+  Acc extends readonly unknown[] = [],
+> = T extends readonly [infer F, ...infer Rest extends readonly unknown[]]
+  ? [F] extends [P]
+    ? Filter<Rest, P, [...Acc, F]>
+    : Filter<Rest, P, Acc>
+  : readonly [...Acc]
+
+/**
+ * Checks if `T` can be narrowed further than `U`
+ *
+ * @example
+ * ```ts
+ * type Result = IsNarrowable<'foo', string>
+ * //   ^? true
+ * ```
+ */
+export type IsNarrowable<T, U> =
+  IsNever<(T extends U ? true : false) & (U extends T ? false : true)> extends true ? false : true
+
+/**
+ * Checks if `T` is `never`
+ *
+ * @example
+ * ```ts
+ * type Result = IsNever<never>
+ * //   ^? type Result = true
+ * ```
+ */
+export type IsNever<T> = [T] extends [never] ? true : false
+
+/**
+ * Removes `readonly` from all properties of an object.
+ *
+ * @internal
+ */
+export type Mutable<type extends object> = {
+  -readonly [key in keyof type]: type[key]
+}
+
+/**
+ * Evaluates boolean "or" condition for `T` properties.
+ *
+ * * @example
+ * ```ts
+ * type Result = Or<[false, true, false]>
+ * //   ^? type Result = true
+ * ```
+ *
+ * @example
+ * ```ts
+ * type Result = Or<[false, false, false]>
+ * //   ^? type Result = false
+ * ```
+ *
+ * @internal
+ */
+export type Or<T extends readonly unknown[]> = T extends readonly [infer Head, ...infer Tail]
+  ? Head extends true
+    ? true
+    : Or<Tail>
+  : false
+
+/**
+ * Checks if `T` is `undefined`
+ *
+ * @example
+ * ```ts
+ * type Result = IsUndefined<undefined>
+ * //   ^? type Result = true
+ * ```
+ *
+ * @internal
+ */
+export type IsUndefined<T> = [undefined] extends [T] ? true : false
+
+/**
+ * Checks if type `T` is the `unknown` type.
+ *
+ * @internal
+ */
+export type IsUnknown<T> = unknown extends T ? ([T] extends [null] ? false : true) : false
+
+/** @internal */
+export type MaybePromise<T> = T | Promise<T>
+
+/**
+ * Makes attributes on the type T required if required is true.
+ *
+ * @example
+ * ```ts
+ * MaybeRequired<{ a: string, b?: number }, true>
+ * // { a: string, b: number }
+ *
+ * MaybeRequired<{ a: string, b?: number }, false>
+ * // { a: string, b?: number }
+ * ```
+ *
+ * @internal
+ */
+export type MaybeRequired<T, required extends boolean> = required extends true
+  ? ExactRequired<T>
+  : T
+
+/**
+ * Assigns the properties of U onto T.
+ *
+ * @example
+ * ```ts
+ * Assign<{ a: string, b: number }, { a: undefined, c: boolean }>
+ * // { a: undefined, b: number, c: boolean }
+ * ```
+ *
+ * @internal
+ */
+export type Assign<T, U> = Assign_inner<T, U> & U
+
+/** @internal */
+export type Assign_inner<T, U> = {
+  [K in keyof T as K extends keyof U ? (U[K] extends void ? never : K) : K]: K extends keyof U
+    ? U[K]
+    : T[K]
+}
+
+/**
+ * Constructs a type by excluding `undefined` from `T`.
+ *
+ * @example
+ * ```ts
+ * NoUndefined<string | undefined>
+ * // string
+ * ```
+ *
+ * @internal
+ */
+export type NoUndefined<T> = T extends undefined ? never : T
+
+/**
+ * Strict version of built-in Omit type
+ *
+ * @internal
+ */
+export type Omit<type, keys extends keyof type> = Pick<type, Exclude<keyof type, keys>>
+
+/**
+ * Creates a type that is a partial of T, but with the required keys K.
+ *
+ * @example
+ * ```ts
+ * PartialBy<{ a: string, b: number }, 'a'>
+ * // { a?: string, b: number }
+ * ```
+ *
+ * @internal
+ */
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & ExactPartial<Pick<T, K>>
+
+export type RecursiveArray<T> = T | readonly RecursiveArray<T>[]
+
+/**
+ * Creates a type that is T with the required keys K.
+ *
+ * @example
+ * ```ts
+ * RequiredBy<{ a?: string, b: number }, 'a'>
+ * // { a: string, b: number }
+ * ```
+ *
+ * @internal
+ */
+export type RequiredBy<T, K extends keyof T> = Omit<T, K> & ExactRequired<Pick<T, K>>
+
+/**
+ * Returns truthy if `array` contains `value`.
+ *
+ * @example
+ * ```ts
+ * Some<[1, 2, 3], 2>
+ * // true
+ * ```
+ *
+ * @internal
+ */
+export type Some<array extends readonly unknown[], value> = array extends readonly [
+  value,
+  ...unknown[],
+]
+  ? true
+  : array extends readonly [unknown, ...infer rest]
+    ? Some<rest, value>
+    : false
+
+/**
+ * Prints custom error message
+ *
+ * @param messages - Error message
+ * @returns Custom error message
+ *
+ * @example
+ * ```ts
+ * type Result = TypeErrorMessage<'Custom error message'>
+ * //   ^? type Result = ['Error: Custom error message']
+ * ```
+ */
+export type TypeErrorMessage<messages extends string | string[]> = messages extends string
+  ? [
+      // Surrounding with array to prevent `messages` from being widened to `string`
+      `Error: ${messages}`,
+    ]
+  : {
+      [key in keyof messages]: messages[key] extends infer message extends string
+        ? `Error: ${message}`
+        : never
+    }
+
+/** @internal */
+export type UnionToTuple<
+  union,
+  ///
+  last = LastInUnion<union>,
+> = [union] extends [never] ? [] : [...UnionToTuple<Exclude<union, last>>, last]
+
+/** @internal */
+export type LastInUnion<U> =
+  UnionToIntersection<U extends unknown ? (x: U) => 0 : never> extends (x: infer l) => 0 ? l : never
+
+/** @internal */
+export type UnionToIntersection<union> = (
+  union extends unknown
+    ? (arg: union) => 0
+    : never
+) extends (arg: infer i) => 0
+  ? i
+  : never
+
+/** @internal */
+export type IsUnion<
+  union,
+  ///
+  union2 = union,
+> = union extends union2 ? ([union2] extends [union] ? false : true) : never
+
+/** @internal */
+export type MaybePartial<type, enabled extends boolean | undefined> = enabled extends true
+  ? Compute<ExactPartial<type>>
+  : type
+
+export type ExactPartial<type> = {
+  [key in keyof type]?: type[key] | undefined
+}
+
+/** @internal */
+export type ExactRequired<type> = {
+  [key in keyof type]-?: Exclude<type[key], undefined>
+}
+
+export type OneOf<
+  union extends object,
+  fallback extends object | undefined = undefined,
+  ///
+  keys extends KeyofUnion<union> = KeyofUnion<union>,
+> = union extends infer item
+  ? Compute<
+      item & {
+        [key in Exclude<keys, keyof item>]?: fallback extends object
+          ? key extends keyof fallback
+            ? fallback[key]
+            : undefined
+          : undefined
+      }
+    >
+  : never
+
+/** @internal */
+export type KeyofUnion<type> = type extends type ? keyof type : never
+
+/** @internal */
+export type Undefined<type> = {
+  [key in keyof type]?: undefined
+}
+
+///////////////////////////////////////////////////////////////////////////
+// Loose types
+
+/**
+ * Loose version of {@link Omit}
+ * @internal
+ */
+export type LooseOmit<type, keys extends string> = Pick<type, Exclude<keyof type, keys>>
+
+///////////////////////////////////////////////////////////////////////////
+// Union types
+
+/** @internal */
+export type UnionCompute<type> = type extends object ? Compute<type> : type
+
+/** @internal */
+export type UnionLooseOmit<type, keys extends string> = type extends any
+  ? LooseOmit<type, keys>
+  : never
+
+/**
+ * Construct a type with the properties of union type T except for those in type K.
+ * @example
+ * ```ts
+ * type Result = UnionOmit<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * // { b: number } | { b: undefined, c: number }
+ * ```
+ *
+ * @internal
+ */
+export type UnionOmit<type, keys extends keyof type> = type extends any ? Omit<type, keys> : never
+
+/**
+ * Construct a type with the properties of union type T except for those in type K.
+ * @example
+ * ```ts
+ * type Result = UnionOmit<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * // { b: number } | { b: undefined, c: number }
+ * ```
+ *
+ * @internal
+ */
+export type UnionPick<type, keys extends keyof type> = type extends any ? Pick<type, keys> : never
+
+/**
+ * Creates a type that is a partial of T, but with the required keys K.
+ *
+ * @example
+ * ```ts
+ * PartialBy<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * // { a?: string, b: number } | { a?: string, b: undefined, c: number }
+ * ```
+ *
+ * @internal
+ */
+export type UnionPartialBy<T, K extends keyof T> = T extends any ? PartialBy<T, K> : never
+
+/**
+ * Creates a type that is T with the required keys K.
+ *
+ * @example
+ * ```ts
+ * RequiredBy<{ a?: string, b: number } | { a?: string, c?: number }, 'a'>
+ * // { a: string, b: number } | { a: string, c?: number }
+ * ```
+ *
+ * @internal
+ */
+export type UnionRequiredBy<T, K extends keyof T> = T extends any ? RequiredBy<T, K> : never
+
+/**
+ * Merges two object types, creating a union for overlapping properties.
+ *
+ * @example
+ * ```ts
+ * type Result = UnionMerge<{ a: string, b: number }, { b: boolean, c: string }>
+ * // { a: string, b: number | boolean, c: string }
+ * ```
+ *
+ * @internal
+ */
+export type UnionMerge<A, B> = [keyof B] extends [never]
+  ? A
+  : LooseOmit<A, keyof B & string> & {
+      [K in keyof B]: K extends keyof A ? A[K] | B[K] : B[K]
+    }
+
+/** @internal Distributes union `U` into per-member function overloads returning `R`. */
+export type Distribute<U, R> = U extends infer member ? (response: member) => R : never
+
+/** @internal */
+export type Flatten<element> = element extends readonly (infer item)[] ? item : element

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

@@ -0,0 +1,109 @@
+import type { Client } from '@modelcontextprotocol/sdk/client/index.js'
+import { tempo } from 'mppx/client'
+import type { Account } from 'viem'
+import { describe, expectTypeOf, test } from 'vitest'
+import * as McpClient from './McpClient.js'
+
+describe('McpClient.wrap', () => {
+  test('returns wrapped client with callTool', () => {
+    const client = {} as Client
+    const wrapped = McpClient.wrap(client, {
+      methods: [
+        tempo({
+          account: {} as Account,
+        }),
+      ],
+    })
+
+    expectTypeOf(wrapped.callTool).toBeFunction()
+    expectTypeOf(wrapped.callTool).returns.toExtend<Promise<McpClient.CallToolResult>>()
+  })
+
+  test('preserves original client methods', () => {
+    const client = {} as Client
+    const wrapped = McpClient.wrap(client, {
+      methods: [
+        tempo({
+          account: {} as Account,
+        }),
+      ],
+    })
+
+    expectTypeOf(wrapped).toHaveProperty('connect')
+    expectTypeOf(wrapped).toHaveProperty('close')
+    expectTypeOf(wrapped).toHaveProperty('listTools')
+    expectTypeOf(wrapped).toHaveProperty('listResources')
+    expectTypeOf(wrapped).toHaveProperty('listPrompts')
+  })
+
+  test('preserves custom properties on client', () => {
+    const client = { callTool: {} as Client['callTool'], customProp: 'hello' }
+    const wrapped = McpClient.wrap(client, {
+      methods: [
+        tempo({
+          account: {} as Account,
+        }),
+      ],
+    })
+
+    expectTypeOf(wrapped.customProp).toEqualTypeOf<string>()
+  })
+
+  test('callTool accepts context when method has context', () => {
+    const client = {} as Client
+    const wrapped = McpClient.wrap(client, {
+      methods: [tempo({})],
+    })
+
+    expectTypeOf(wrapped.callTool).toBeCallableWith(
+      { name: 'tool' },
+      { context: { account: {} as Account } },
+    )
+  })
+
+  test('callTool context is optional when account provided at creation', () => {
+    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' }, {})
+    expectTypeOf(wrapped.callTool).toBeCallableWith({ name: 'tool' }, { timeout: 5000 })
+  })
+
+  test('callTool result includes receipt', () => {
+    const client = {} as Client
+    const wrapped = McpClient.wrap(client, {
+      methods: [
+        tempo({
+          account: {} as Account,
+        }),
+      ],
+    })
+
+    expectTypeOf(wrapped.callTool({} as never)).resolves.toHaveProperty('receipt')
+    expectTypeOf(wrapped.callTool({} as never)).resolves.toHaveProperty('content')
+  })
+})
+
+describe('McpClient.wrap.McpClient', () => {
+  test('has callTool with correct signature', () => {
+    type WrappedClient = McpClient.wrap.McpClient
+
+    expectTypeOf<WrappedClient>().toHaveProperty('callTool')
+  })
+})
+
+describe('McpClient.wrap.CallToolOptions', () => {
+  test('has context and timeout properties', () => {
+    type Options = McpClient.wrap.CallToolOptions
+
+    expectTypeOf<Options>().toHaveProperty('context')
+    expectTypeOf<Options>().toHaveProperty('timeout')
+  })
+})