ebay-mcp 1.13.2 → 1.14.0

package/build/tools/categories/{token-management.js → tokenManagement.js}

@@ -1,13 +1,86 @@
-import { z } from 'zod';
-import { buildCredentialDisplay, maskToken } from '../../auth/credential-session.js';
+import { z } from '../../utils/effectSchema.js';
+import { buildCredentialDisplay, maskToken } from '../../auth/credentialSession.js';
 import { getOAuthAuthorizationUrl, validateScopes } from '../../config/environment.js';
-import { defineTool } from '../../tools/define-tool.js';
-import { convertToTimestamp, validateTokenExpiry } from '../../utils/date-converter.js';
+import { defineTool } from '../../tools/defineTool.js';
+import { convertToTimestamp, validateTokenExpiry } from '../../utils/dateConverter.js';
 import { getErrorMessage } from '../../utils/errors.js';
+import { Data, Effect, Either } from 'effect';
+/** Tagged failure raised inside token-management tool handlers. */
+class TokenManagementToolError extends Data.TaggedError('TokenManagementToolError') {
+}
+const tokenToolError = (operation, message, error) => new TokenManagementToolError({
+    operation,
+    message: error === undefined ? message : `${message}: ${getErrorMessage(error, String(error))}`,
+    ...(error === undefined ? {} : { cause: error }),
+});
+/** Convert an optional token expiry value into a timestamp inside the token tool Effect. */
+const optionalTokenExpiryTimestamp = (value, operation, message) => {
+    if (value === undefined) {
+        return Effect.succeed(undefined);
+    }
+    return convertToTimestamp(value).pipe(Effect.mapError((error) => tokenToolError(operation, message, error)));
+};
+const missingClientIdError = tokenToolError('getOAuthUrl', 'EBAY_CLIENT_ID environment variable is required to generate OAuth URL');
+const missingRedirectUriError = tokenToolError('getOAuthUrl', 'Redirect URI is required. Either provide it as a parameter or set EBAY_REDIRECT_URI in your .env file.');
+const missingUserTokensError = tokenToolError('refreshAccessToken', 'No user tokens available. Please set user tokens first using ebay_set_user_tokens_with_expiry or add EBAY_USER_REFRESH_TOKEN to your .env file.');
+const oauthUrlInputSchema = z.object({
+    redirectUri: z
+        .string()
+        .optional()
+        .describe('Optional redirect URI registered with your eBay application (RuName). If not provided, will use EBAY_REDIRECT_URI from .env file.'),
+    scopes: z
+        .array(z.string())
+        .optional()
+        .describe('Optional array of OAuth scopes. If not provided, uses environment-specific default scopes (production or sandbox based on EBAY_ENVIRONMENT). Custom scopes will be validated against the environment.'),
+    state: z.string().optional().describe('Optional state parameter for CSRF protection'),
+});
+const setUserTokensInputSchema = z.object({
+    accessToken: z.string().min(1).describe('The user access token obtained from OAuth flow'),
+    refreshToken: z.string().min(1).describe('The refresh token obtained from OAuth flow'),
+});
+const setUserTokensWithExpiryInputSchema = z.object({
+    accessToken: z.string().min(1).describe('eBay user access token'),
+    refreshToken: z.string().min(1).describe('eBay user refresh token'),
+    accessTokenExpiry: z
+        .union([z.string(), z.number()])
+        .optional()
+        .describe('Optional access-token expiry. Supports ISO date strings, Unix timestamps, and relative time.'),
+    refreshTokenExpiry: z
+        .union([z.string(), z.number()])
+        .optional()
+        .describe('Optional refresh-token expiry. Supports ISO date strings, Unix timestamps, and relative time.'),
+    autoRefresh: z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe('Whether to validate and refresh the access token immediately'),
+});
+const getTokenStatusInputSchema = z.object({});
+const clearTokensInputSchema = z.object({});
+const validateTokenExpiryInputSchema = z.object({
+    accessTokenExpiry: z
+        .union([z.string(), z.number()])
+        .describe('Access token expiry as an ISO date string, Unix timestamp, or relative time'),
+    refreshTokenExpiry: z
+        .union([z.string(), z.number()])
+        .describe('Refresh token expiry as an ISO date string, Unix timestamp, or relative time'),
+});
+const convertDateToTimestampInputSchema = z.object({
+    dateInput: z
+        .union([z.string(), z.number()])
+        .describe('Date to convert as an ISO date string, Unix timestamp, or relative time'),
+});
+const displayCredentialsInputSchema = z.object({});
+const refreshAccessTokenInputSchema = z.object({});
+const exchangeAuthorizationCodeInputSchema = z.object({
+    code: z
+        .string()
+        .min(1)
+        .describe('The authorization code received from eBay after user authorization'),
+});
 /**
  * OAuth token management tools for consent URLs, token storage, refresh, status,
- * and date/expiry helpers. Several handlers read configuration from `process.env`
- * (e.g. `EBAY_CLIENT_ID`, `EBAY_REDIRECT_URI`) rather than the eBay API client.
+ * and date/expiry helpers. Handlers receive validated runtime config from the API facade.
  */
 export const tokenManagementEntries = [
     defineTool({
@@ -33,111 +106,59 @@ export const tokenManagementEntries = [
             '- "Insufficient permissions" errors mean you need to re-authorize with additional scopes\n' +
             '- OAuth URL format: Use + to separate scopes (e.g., scope=scope1+scope2), not %2B\n' +
             '- Refresh tokens last 18 months and are saved to .env file for persistence',
-        inputSchema: {
-            redirectUri: z
-                .string()
-                .optional()
-                .describe('Optional redirect URI registered with your eBay application (RuName). If not provided, will use EBAY_REDIRECT_URI from .env file.'),
-            scopes: z
-                .array(z.string())
-                .optional()
-                .describe('Optional array of OAuth scopes. If not provided, uses environment-specific default scopes (production or sandbox based on EBAY_ENVIRONMENT). Custom scopes will be validated against the environment.'),
-            state: z.string().optional().describe('Optional state parameter for CSRF protection'),
-        },
-        handler: (_api, args) => {
-            const clientId = process.env.EBAY_CLIENT_ID ?? '';
-            const environment = (process.env.EBAY_ENVIRONMENT ?? 'sandbox');
-            const envRedirectUri = process.env.EBAY_REDIRECT_URI;
-            const redirectUri = args.redirectUri ?? envRedirectUri;
-            const scopes = args.scopes;
-            const state = args.state;
-            if (!clientId) {
-                throw new Error('EBAY_CLIENT_ID environment variable is required to generate OAuth URL');
+        inputSchema: oauthUrlInputSchema.shape,
+        handler: (api, args) => Effect.runPromise(Effect.gen(function* () {
+            const config = api.getConfig();
+            const redirectUri = args.redirectUri ?? config.redirectUri;
+            if (!config.clientId) {
+                return yield* Effect.fail(missingClientIdError);
             }
             if (!redirectUri) {
-                throw new Error('Redirect URI is required. Either provide it as a parameter or set EBAY_REDIRECT_URI in your .env file.');
-            }
-            let scopeWarnings = [];
-            let validatedScopes = scopes;
-            if (scopes && scopes.length > 0) {
-                const validation = validateScopes(scopes, environment);
-                scopeWarnings = validation.warnings;
-                validatedScopes = validation.validScopes;
+                return yield* Effect.fail(missingRedirectUriError);
             }
-            const authUrl = getOAuthAuthorizationUrl(clientId, redirectUri, environment, validatedScopes, state);
+            const scopes = args.scopes;
+            const scopeValidation = scopes && scopes.length > 0
+                ? validateScopes(scopes, config.environment)
+                : { warnings: [], validScopes: scopes };
+            const authUrl = getOAuthAuthorizationUrl(config.clientId, redirectUri, config.environment, scopeValidation.validScopes, args.state);
             const result = {
                 authorizationUrl: authUrl,
                 redirectUri,
                 instructions: 'Open this URL in a browser to authorize the application. After authorization, you will be redirected to your redirect URI with an authorization code that can be exchanged for an access token.',
-                environment,
+                environment: config.environment,
                 scopes: scopes ?? 'default (all Sell API scopes)',
             };
-            if (scopeWarnings.length > 0) {
-                result.warnings = scopeWarnings;
+            if (scopeValidation.warnings.length > 0) {
+                result.warnings = scopeValidation.warnings;
             }
             return result;
-        },
+        })),
     }),
     defineTool({
         name: 'ebay_set_user_tokens',
         description: 'Set the user access token and refresh token for authenticated API requests. These tokens should be obtained through the OAuth authorization code flow. Tokens will be persisted to disk and automatically refreshed when needed. User tokens provide higher rate limits (10,000-50,000 requests/day) compared to client credentials (1,000 requests/day).',
-        inputSchema: {
-            accessToken: z.string().describe('The user access token obtained from OAuth flow'),
-            refreshToken: z.string().describe('The refresh token obtained from OAuth flow'),
-        },
-        handler: async (api, args) => {
-            const { accessToken, refreshToken } = args;
-            if (!accessToken || !refreshToken) {
-                throw new Error('Both accessToken and refreshToken are required');
-            }
-            await api.setUserTokens(accessToken, refreshToken);
-            return {
-                success: true,
-                message: 'User tokens successfully stored. These tokens will be used for all subsequent API requests and will be automatically refreshed when needed.',
-                tokenInfo: api.getTokenInfo(),
-            };
-        },
+        inputSchema: setUserTokensInputSchema.shape,
+        handler: (api, args) => Effect.runPromise(api.setUserTokens(args.accessToken, args.refreshToken).pipe(Effect.mapError((error) => tokenToolError('setUserTokens', 'Failed to set user tokens', error)), Effect.map(() => ({
+            success: true,
+            message: 'User tokens successfully stored. These tokens will be used for all subsequent API requests and will be automatically refreshed when needed.',
+            tokenInfo: api.getTokenInfo(),
+        })))),
     }),
     defineTool({
         name: 'ebay_set_user_tokens_with_expiry',
         description: "Set user access and refresh tokens with custom expiry times. This is an enhanced version of ebay_set_user_tokens that accepts expiry times and can automatically refresh the access token if it's expired but the refresh token is valid. Useful when user provides tokens that may already be partially expired.",
-        inputSchema: {
-            accessToken: z.string().min(1).describe('eBay user access token'),
-            refreshToken: z.string().min(1).describe('eBay user refresh token'),
-            accessTokenExpiry: z
-                .union([z.string(), z.number()])
-                .optional()
-                .describe('Optional: Access token expiry time. If not provided, defaults to 2 hours from now. Can be ISO date string, Unix timestamp, or relative time (e.g., "in 7200 seconds")'),
-            refreshTokenExpiry: z
-                .union([z.string(), z.number()])
-                .optional()
-                .describe('Optional: Refresh token expiry time. If not provided, defaults to 18 months from now. Can be ISO date string, Unix timestamp, or relative time'),
-            autoRefresh: z
-                .boolean()
-                .optional()
-                .default(true)
-                .describe('If true and access token is expired but refresh token is valid, automatically refresh the access token. Default: true'),
-        },
-        handler: async (api, args) => {
+        inputSchema: setUserTokensWithExpiryInputSchema.shape,
+        handler: (api, args) => {
             const { accessToken, refreshToken, accessTokenExpiry, refreshTokenExpiry, autoRefresh } = args;
-            if (!accessToken || !refreshToken) {
-                throw new Error('Both accessToken and refreshToken are required');
-            }
-            try {
-                let accessExpiry;
-                let refreshExpiry;
-                if (accessTokenExpiry !== undefined) {
-                    accessExpiry = convertToTimestamp(accessTokenExpiry);
-                }
-                if (refreshTokenExpiry !== undefined) {
-                    refreshExpiry = convertToTimestamp(refreshTokenExpiry);
-                }
-                await api.setUserTokens(accessToken, refreshToken, accessExpiry, refreshExpiry);
-                // The OAuth client refreshes internally if the access token is expired.
+            return Effect.runPromise(Effect.gen(function* () {
+                const accessExpiry = yield* optionalTokenExpiryTimestamp(accessTokenExpiry, 'setUserTokens', 'Failed to set user tokens');
+                const refreshExpiry = yield* optionalTokenExpiryTimestamp(refreshTokenExpiry, 'setUserTokens', 'Failed to set user tokens');
+                yield* api
+                    .setUserTokens(accessToken, refreshToken, accessExpiry, refreshExpiry)
+                    .pipe(Effect.mapError((error) => tokenToolError('setUserTokens', 'Failed to set user tokens', error)));
                 if (autoRefresh) {
-                    try {
-                        const authClient = api.getAuthClient().getOAuthClient();
-                        await authClient.getAccessToken();
+                    const refreshResult = yield* Effect.either(api.getAuthClient().getOAuthClient().getAccessToken());
+                    if (Either.isRight(refreshResult)) {
                         return {
                             success: true,
                             message: 'User tokens stored successfully in memory. Access token validated and refreshed if needed. To persist tokens, update EBAY_USER_REFRESH_TOKEN in .env file.',
@@ -145,15 +166,13 @@ export const tokenManagementEntries = [
                             refreshed: true,
                         };
                     }
-                    catch (refreshError) {
-                        return {
-                            success: true,
-                            message: 'User tokens stored, but failed to validate/refresh access token. You may need to re-authorize.',
-                            tokenInfo: api.getTokenInfo(),
-                            refreshed: false,
-                            refreshError: getErrorMessage(refreshError),
-                        };
-                    }
+                    return {
+                        success: true,
+                        message: 'User tokens stored, but failed to validate/refresh access token. You may need to re-authorize.',
+                        tokenInfo: api.getTokenInfo(),
+                        refreshed: false,
+                        refreshError: getErrorMessage(refreshResult.left),
+                    };
                 }
                 return {
                     success: true,
@@ -161,28 +180,28 @@ export const tokenManagementEntries = [
                     tokenInfo: api.getTokenInfo(),
                     refreshed: false,
                 };
-            }
-            catch (error) {
-                throw new Error(`Failed to set user tokens: ${getErrorMessage(error, String(error))}`);
-            }
+            }));
         },
     }),
     defineTool({
         name: 'ebay_get_token_status',
         description: 'Check the current OAuth token status. Returns information about whether user tokens or client credentials are being used, and whether tokens are valid.',
-        inputSchema: {},
+        inputSchema: getTokenStatusInputSchema.shape,
         handler: (api) => {
             const tokenInfo = api.getTokenInfo();
             const hasUserTokens = api.hasUserTokens();
+            let currentTokenType = 'none';
+            if (tokenInfo.hasUserToken) {
+                currentTokenType = 'user_token (10,000-50,000 req/day)';
+            }
+            else if (tokenInfo.hasAppAccessToken) {
+                currentTokenType = 'app_access_token (1,000 req/day)';
+            }
             return {
                 hasUserToken: tokenInfo.hasUserToken,
                 hasAppAccessToken: tokenInfo.hasAppAccessToken,
                 authenticated: api.isAuthenticated(),
-                currentTokenType: tokenInfo.hasUserToken
-                    ? 'user_token (10,000-50,000 req/day)'
-                    : tokenInfo.hasAppAccessToken
-                        ? 'app_access_token (1,000 req/day)'
-                        : 'none',
+                currentTokenType,
                 message: hasUserTokens
                     ? 'Using user access token with automatic refresh'
                     : 'Using app access token from client credentials flow (lower rate limits). Consider setting user tokens for higher rate limits.',
@@ -192,7 +211,7 @@ export const tokenManagementEntries = [
     defineTool({
         name: 'ebay_clear_tokens',
         description: 'Clear all stored OAuth tokens (both user tokens and client credentials). This will require re-authentication for subsequent API calls.',
-        inputSchema: {},
+        inputSchema: clearTokensInputSchema.shape,
         handler: (api) => {
             const authClient = api.getAuthClient().getOAuthClient();
             authClient.clearAllTokens();
@@ -205,44 +224,28 @@ export const tokenManagementEntries = [
     defineTool({
         name: 'ebay_validate_token_expiry',
         description: 'Validate token expiry times and get recommendations. Checks if access/refresh tokens are expired or expiring soon, and provides actionable recommendations (e.g., refresh access token, re-authorize user).',
-        inputSchema: {
-            accessTokenExpiry: z
-                .union([z.string(), z.number()])
-                .describe('Access token expiry time. Can be ISO date string, Unix timestamp (seconds or milliseconds), or relative time'),
-            refreshTokenExpiry: z
-                .union([z.string(), z.number()])
-                .describe('Refresh token expiry time. Can be ISO date string, Unix timestamp (seconds or milliseconds), or relative time'),
-        },
-        handler: (_api, args) => {
-            try {
-                const accessExpiry = convertToTimestamp(args.accessTokenExpiry);
-                const refreshExpiry = convertToTimestamp(args.refreshTokenExpiry);
-                const validation = validateTokenExpiry(accessExpiry, refreshExpiry);
-                return {
-                    ...validation,
-                    accessTokenExpiryTimestamp: accessExpiry,
-                    refreshTokenExpiryTimestamp: refreshExpiry,
-                    accessTokenExpiryDate: new Date(accessExpiry).toISOString(),
-                    refreshTokenExpiryDate: new Date(refreshExpiry).toISOString(),
-                };
-            }
-            catch (error) {
-                throw new Error(`Failed to validate token expiry: ${getErrorMessage(error, String(error))}`);
-            }
-        },
+        inputSchema: validateTokenExpiryInputSchema.shape,
+        handler: (_api, args) => Effect.runPromise(Effect.gen(function* () {
+            const accessExpiry = yield* convertToTimestamp(args.accessTokenExpiry).pipe(Effect.mapError((error) => tokenToolError('validateTokenExpiry', 'Failed to validate token expiry', error)));
+            const refreshExpiry = yield* convertToTimestamp(args.refreshTokenExpiry).pipe(Effect.mapError((error) => tokenToolError('validateTokenExpiry', 'Failed to validate token expiry', error)));
+            const validation = validateTokenExpiry(accessExpiry, refreshExpiry);
+            return {
+                ...validation,
+                accessTokenExpiryTimestamp: accessExpiry,
+                refreshTokenExpiryTimestamp: refreshExpiry,
+                accessTokenExpiryDate: new Date(accessExpiry).toISOString(),
+                refreshTokenExpiryDate: new Date(refreshExpiry).toISOString(),
+            };
+        })),
     }),
     defineTool({
         name: 'ebay_convert_date_to_timestamp',
         description: 'Convert a date string or number to Unix timestamp (milliseconds). Supports ISO 8601 dates, Unix timestamps (seconds or milliseconds), and relative time (e.g., "in 2 hours", "in 7200 seconds"). Useful when setting token expiry times from user input.',
-        inputSchema: {
-            dateInput: z
-                .union([z.string(), z.number()])
-                .describe('Date to convert. Supports ISO 8601 strings (e.g., "2025-01-15T10:30:00Z"), Unix timestamps (seconds or milliseconds), or relative time (e.g., "in 2 hours")'),
-        },
+        inputSchema: convertDateToTimestampInputSchema.shape,
         handler: (_api, args) => {
             const { dateInput } = args;
-            try {
-                const timestamp = convertToTimestamp(dateInput);
+            return Effect.runPromise(Effect.gen(function* () {
+                const timestamp = yield* convertToTimestamp(dateInput).pipe(Effect.mapError((error) => tokenToolError('convertDateToTimestamp', 'Failed to convert date', error)));
                 return {
                     success: true,
                     timestamp,
@@ -250,16 +253,13 @@ export const tokenManagementEntries = [
                     formattedDate: new Date(timestamp).toISOString(),
                     message: `Successfully converted to timestamp: ${timestamp}ms (${new Date(timestamp).toISOString()})`,
                 };
-            }
-            catch (error) {
-                throw new Error(`Failed to convert date: ${getErrorMessage(error, String(error))}`);
-            }
+            }));
         },
     }),
     defineTool({
         name: 'ebay_display_credentials',
         description: 'Display all eBay API credentials and current token information. Shows client ID, client secret (masked), environment (production/sandbox), redirect URI, and current token status including access token (masked), refresh token (masked), app token (masked), and their expiry times. Useful for debugging authentication issues and verifying configuration.',
-        inputSchema: {},
+        inputSchema: displayCredentialsInputSchema.shape,
         handler: (api) => {
             const tokenInfo = api.getTokenInfo();
             const authClient = api.getAuthClient().getOAuthClient();
@@ -267,7 +267,7 @@ export const tokenManagementEntries = [
                 appAccessToken: authClient.getCachedAppAccessToken(),
                 appAccessTokenExpiry: authClient.getCachedAppAccessTokenExpiry(),
                 authenticated: api.isAuthenticated(),
-                env: process.env,
+                config: api.getConfig(),
                 tokenInfo,
                 userTokens: authClient.getUserTokens(),
             });
@@ -276,39 +276,40 @@ export const tokenManagementEntries = [
     defineTool({
         name: 'ebay_refresh_access_token',
         description: 'Manually refresh the user access token using the stored refresh token. This is useful when you want to proactively refresh an access token before it expires, or when recovering from authentication errors. Requires that user tokens are already set (either via EBAY_USER_REFRESH_TOKEN in .env or via ebay_set_user_tokens_with_expiry). Returns the new access token and expiry time.',
-        inputSchema: {},
+        inputSchema: refreshAccessTokenInputSchema.shape,
         outputSchema: {
             type: 'object',
             properties: {},
             description: 'Success response',
         },
-        handler: async (api) => {
+        handler: (api) => {
             const authClient = api.getAuthClient().getOAuthClient();
-            if (!api.hasUserTokens()) {
-                throw new Error('No user tokens available. Please set user tokens first using ebay_set_user_tokens_with_expiry or add EBAY_USER_REFRESH_TOKEN to your .env file.');
-            }
-            try {
-                await authClient.refreshUserToken();
-                const internalTokens = authClient.getUserTokens();
-                return {
-                    success: true,
-                    message: 'Access token refreshed successfully',
-                    accessToken: internalTokens?.userAccessToken
-                        ? maskToken(internalTokens.userAccessToken)
-                        : 'Not available',
-                    accessTokenExpiry: internalTokens?.userAccessTokenExpiry
-                        ? {
-                            timestamp: internalTokens.userAccessTokenExpiry,
-                            date: new Date(internalTokens.userAccessTokenExpiry).toISOString(),
-                            expiresInSeconds: Math.floor((internalTokens.userAccessTokenExpiry - Date.now()) / 1000),
-                        }
-                        : 'Not available',
-                    tokenInfo: api.getTokenInfo(),
-                };
-            }
-            catch (error) {
-                throw new Error(`Failed to refresh access token: ${getErrorMessage(error, String(error))}`);
-            }
+            return Effect.runPromise(Effect.gen(function* () {
+                if (!api.hasUserTokens()) {
+                    return yield* Effect.fail(missingUserTokensError);
+                }
+                yield* authClient
+                    .refreshUserToken()
+                    .pipe(Effect.mapError((error) => tokenToolError('refreshAccessToken', 'Failed to refresh access token', error)));
+                return yield* Effect.sync(() => {
+                    const internalTokens = authClient.getUserTokens();
+                    return {
+                        success: true,
+                        message: 'Access token refreshed successfully',
+                        accessToken: internalTokens?.userAccessToken
+                            ? maskToken(internalTokens.userAccessToken)
+                            : null,
+                        accessTokenExpiry: internalTokens?.userAccessTokenExpiry
+                            ? {
+                                timestamp: internalTokens.userAccessTokenExpiry,
+                                date: new Date(internalTokens.userAccessTokenExpiry).toISOString(),
+                                expiresInSeconds: Math.floor((internalTokens.userAccessTokenExpiry - Date.now()) / 1000),
+                            }
+                            : null,
+                        tokenInfo: api.getTokenInfo(),
+                    };
+                });
+            }));
         },
     }),
     defineTool({
@@ -324,27 +325,24 @@ export const tokenManagementEntries = [
             '- "invalid or was issued to another client": Code expired, get fresh code\n' +
             '- "Insufficient permissions": Re-run OAuth flow with additional scopes in ebay_get_oauth_url\n\n' +
             'For complete OAuth guide with scopes, troubleshooting, and examples, see: docs/auth/OAUTH_QUICK_REFERENCE.md',
-        inputSchema: {
-            code: z
-                .string()
-                .min(1)
-                .describe('The authorization code received from eBay after user authorization. This is the "code" parameter in the redirect URL.'),
-        },
+        inputSchema: exchangeAuthorizationCodeInputSchema.shape,
         outputSchema: {
             type: 'object',
             properties: {},
             description: 'Token exchange response including access token, refresh token, and expiry times',
         },
-        handler: async (api, args) => {
+        handler: (api, args) => {
             const { code } = args;
-            if (!code) {
-                throw new Error('Authorization code is required');
-            }
-            try {
+            return Effect.runPromise(Effect.gen(function* () {
                 // Codes arriving from a redirect URL may be percent-encoded.
-                const decodedCode = code.includes('%') ? decodeURIComponent(code) : code;
+                const decodedCode = yield* Effect.try({
+                    try: () => (code.includes('%') ? decodeURIComponent(code) : code),
+                    catch: (error) => tokenToolError('exchangeAuthorizationCode', 'Failed to exchange authorization code', error),
+                });
                 const authClient = api.getAuthClient().getOAuthClient();
-                const tokenData = await authClient.exchangeCodeForToken(decodedCode);
+                const tokenData = yield* authClient
+                    .exchangeCodeForToken(decodedCode)
+                    .pipe(Effect.mapError((error) => tokenToolError('exchangeAuthorizationCode', 'Failed to exchange authorization code', error)));
                 return {
                     success: true,
                     message: 'Authorization code successfully exchanged for tokens. Tokens have been stored and will be used for subsequent API requests.',
@@ -358,10 +356,7 @@ export const tokenManagementEntries = [
                     },
                     note: 'The refresh token has been saved to your .env file for future use.',
                 };
-            }
-            catch (error) {
-                throw new Error(`Failed to exchange authorization code: ${getErrorMessage(error, String(error))}`);
-            }
+            }));
         },
     }),
 ];

package/build/tools/categories/trading.js

@@ -1,79 +1,48 @@
-import { z } from 'zod';
-import { defineTool } from '../../tools/define-tool.js';
-/** Trading API tools for legacy listing, order, feedback, and dispute operations. */
+import { defineTool } from '../../tools/defineTool.js';
+import { createListingSchema, endListingSchema, getActiveListingsSchema, getListingSchema, relistItemSchema, reviseListingSchema, } from '../../utils/trading/trading.js';
+import { Effect } from 'effect';
+/** Trading API tools for fixed-price listing operations. */
 export const tradingEntries = [
     defineTool({
         name: 'ebay_get_active_listings',
         description: 'Get all active fixed-price listings with SKU, quantity, price, and watch count.\n\nUses the Trading API (GetMyeBaySelling). Returns listings created via any method (UI, Trading API, or REST API).\n\nRequired: User OAuth token.',
-        inputSchema: {
-            page: z.number().optional().describe('Page number (default 1)'),
-            entriesPerPage: z.number().optional().describe('Items per page, max 200 (default 50)'),
-        },
+        inputSchema: getActiveListingsSchema.shape,
         annotations: { readOnlyHint: true },
-        handler: (api, args) => api.trading.getActiveListings(args.page, args.entriesPerPage),
+        handler: (api, args) => Effect.runPromise(api.trading.getActiveListings(args)),
     }),
     defineTool({
         name: 'ebay_get_listing',
         description: 'Get full details for a single listing by item ID.\n\nUses the Trading API (GetItem). Returns all listing fields including description, specifics, shipping, and images.\n\nRequired: User OAuth token.',
-        inputSchema: {
-            itemId: z.string().describe('The eBay item ID (e.g., "167382780779")'),
-        },
+        inputSchema: getListingSchema.shape,
         annotations: { readOnlyHint: true },
-        handler: (api, args) => api.trading.getListing(args.itemId),
+        handler: (api, args) => Effect.runPromise(api.trading.getListing(args)),
     }),
     defineTool({
         name: 'ebay_create_listing',
         description: 'Create a new fixed-price listing.\n\nUses the Trading API (AddFixedPriceItem). Requires complete item details.\n\nRequired: User OAuth token.',
-        inputSchema: {
-            item: z
-                .record(z.unknown())
-                .describe('Item details object. Required fields: Title, PrimaryCategory.CategoryID, StartPrice, ConditionID, Country, Currency, DispatchTimeMax, ListingDuration, ListingType ("FixedPriceItem"), Quantity, SKU.'),
-        },
+        inputSchema: createListingSchema.shape,
         annotations: { readOnlyHint: false },
-        handler: (api, args) => api.trading.createListing(args.item),
+        handler: (api, args) => Effect.runPromise(api.trading.createListing(args)),
     }),
     defineTool({
         name: 'ebay_revise_listing',
         description: 'Revise an existing fixed-price listing. Update quantity, price, title, description, or any other field.\n\nUses the Trading API (ReviseFixedPriceItem). Only send the fields you want to change.\n\nExamples:\n- Update quantity: { "Quantity": 10 }\n- Update price: { "StartPrice": 14.99 }\n- Update title: { "Title": "New Title" }\n- Multiple fields: { "Quantity": 10, "StartPrice": 14.99 }\n\nRequired: User OAuth token.',
-        inputSchema: {
-            itemId: z.string().describe('The eBay item ID to revise'),
-            fields: z
-                .record(z.unknown())
-                .describe('Fields to update (e.g., { "Quantity": 10, "StartPrice": 14.99 })'),
-        },
+        inputSchema: reviseListingSchema.shape,
         annotations: { readOnlyHint: false },
-        handler: (api, args) => api.trading.reviseListing(args.itemId, args.fields),
+        handler: (api, args) => Effect.runPromise(api.trading.reviseListing(args)),
     }),
     defineTool({
         name: 'ebay_end_listing',
         description: 'End/remove an active fixed-price listing.\n\nUses the Trading API (EndFixedPriceItem).\n\nRequired: User OAuth token.',
-        inputSchema: {
-            itemId: z.string().describe('The eBay item ID to end'),
-            reason: z
-                .enum([
-                'NotAvailable',
-                'Incorrect',
-                'LostOrBroken',
-                'OtherListingError',
-                'SellToHighBidder',
-            ])
-                .optional()
-                .describe('Reason for ending (default: NotAvailable)'),
-        },
+        inputSchema: endListingSchema.shape,
         annotations: { readOnlyHint: false, destructiveHint: true },
-        handler: (api, args) => api.trading.endListing(args.itemId, args.reason),
+        handler: (api, args) => Effect.runPromise(api.trading.endListing(args)),
     }),
     defineTool({
         name: 'ebay_relist_item',
         description: 'Relist an ended fixed-price listing, optionally with modifications.\n\nUses the Trading API (RelistFixedPriceItem).\n\nRequired: User OAuth token.',
-        inputSchema: {
-            itemId: z.string().describe('The eBay item ID to relist'),
-            modifications: z
-                .record(z.unknown())
-                .optional()
-                .describe('Optional fields to change when relisting (e.g., { "Quantity": 20 })'),
-        },
+        inputSchema: relistItemSchema.shape,
         annotations: { readOnlyHint: false },
-        handler: (api, args) => api.trading.relistItem(args.itemId, args.modifications),
+        handler: (api, args) => Effect.runPromise(api.trading.relistItem(args)),
     }),
 ];