@tryfinch/finch-api-mcp 6.31.0 → 7.0.0

package/src/options.ts

@@ -1,55 +1,26 @@
+import qs from 'qs';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
+import z from 'zod';
 import { endpoints, Filter } from './tools';
-import { ClientCapabilities } from './compat';
-
-type ClientType = 'openai-agents' | 'claude' | 'claude-code' | 'cursor';
-
-// Client presets for compatibility
-// Note that these could change over time as models get better, so this is
-// a best effort.
-const CLIENT_PRESETS: Record<ClientType, ClientCapabilities> = {
-  'openai-agents': {
-    topLevelUnions: false,
-    validJson: true,
-    refs: true,
-    unions: true,
-    formats: true,
-    toolNameLength: undefined,
-  },
-  claude: {
-    topLevelUnions: true,
-    validJson: false,
-    refs: true,
-    unions: true,
-    formats: true,
-    toolNameLength: undefined,
-  },
-  'claude-code': {
-    topLevelUnions: false,
-    validJson: true,
-    refs: true,
-    unions: true,
-    formats: true,
-    toolNameLength: undefined,
-  },
-  cursor: {
-    topLevelUnions: false,
-    validJson: true,
-    refs: false,
-    unions: false,
-    formats: false,
-    toolNameLength: 50,
-  },
-};
+import { ClientCapabilities, knownClients, ClientType } from './compat';
 
-export interface ParsedOptions {
-  includeDynamicTools: boolean | undefined;
-  includeAllTools: boolean | undefined;
-  filters: Filter[];
-  capabilities: ClientCapabilities;
+export type CLIOptions = McpOptions & {
   list: boolean;
-}
+  transport: 'stdio' | 'http';
+  port: number | undefined;
+  socket: string | undefined;
+};
+
+export type McpOptions = {
+  client?: ClientType | undefined;
+  includeDynamicTools?: boolean | undefined;
+  includeAllTools?: boolean | undefined;
+  includeCodeTools?: boolean | undefined;
+  includeDocsTools?: boolean | undefined;
+  filters?: Filter[] | undefined;
+  capabilities?: Partial<ClientCapabilities> | undefined;
+};
 
 const CAPABILITY_CHOICES = [
   'top-level-unions',
@@ -80,18 +51,18 @@ function parseCapabilityValue(cap: string): { name: Capability; value?: number }
   return { name: cap as Capability };
 }
 
-export function parseOptions(): ParsedOptions {
+export function parseCLIOptions(): CLIOptions {
   const opts = yargs(hideBin(process.argv))
     .option('tools', {
       type: 'string',
       array: true,
-      choices: ['dynamic', 'all'],
+      choices: ['dynamic', 'all', 'code', 'docs'],
       description: 'Use dynamic tools or all tools',
     })
     .option('no-tools', {
       type: 'string',
       array: true,
-      choices: ['dynamic', 'all'],
+      choices: ['dynamic', 'all', 'code', 'docs'],
       description: 'Do not use any dynamic or all tools',
     })
     .option('tool', {
@@ -141,7 +112,7 @@ export function parseOptions(): ParsedOptions {
     })
     .option('client', {
       type: 'string',
-      choices: Object.keys(CLIENT_PRESETS),
+      choices: Object.keys(knownClients),
       description: 'Specify the MCP client being used',
     })
     .option('capability', {
@@ -165,6 +136,20 @@ export function parseOptions(): ParsedOptions {
       type: 'boolean',
       description: 'Print detailed explanation of client capabilities and exit',
     })
+    .option('transport', {
+      type: 'string',
+      choices: ['stdio', 'http'],
+      default: 'stdio',
+      description: 'What transport to use; stdio for local servers or http for remote servers',
+    })
+    .option('port', {
+      type: 'number',
+      description: 'Port to serve on if using http transport',
+    })
+    .option('socket', {
+      type: 'string',
+      description: 'Unix socket to serve on if using http transport',
+    })
     .help();
 
   for (const [command, desc] of examples()) {
@@ -220,22 +205,7 @@ export function parseOptions(): ParsedOptions {
   }
 
   // Parse client capabilities
-  const clientCapabilities: ClientCapabilities = {
-    topLevelUnions: true,
-    validJson: true,
-    refs: true,
-    unions: true,
-    formats: true,
-    toolNameLength: undefined,
-  };
-
-  // Apply client preset if specified
-  if (typeof argv.client === 'string') {
-    const clientKey = argv.client as ClientType;
-    if (CLIENT_PRESETS[clientKey]) {
-      Object.assign(clientCapabilities, CLIENT_PRESETS[clientKey]);
-    }
-  }
+  const clientCapabilities: Partial<ClientCapabilities> = {};
 
   // Apply individual capability overrides
   if (Array.isArray(argv.capability)) {
@@ -276,18 +246,160 @@ export function parseOptions(): ParsedOptions {
     }
   }
 
-  const explicitTools = Boolean(argv.tools || argv.noTools);
-  const includeDynamicTools =
-    explicitTools ? argv.tools?.includes('dynamic') && !argv.noTools?.includes('dynamic') : undefined;
-  const includeAllTools =
-    explicitTools ? argv.tools?.includes('all') && !argv.noTools?.includes('all') : undefined;
+  const shouldIncludeToolType = (toolType: 'dynamic' | 'all' | 'code' | 'docs') =>
+    argv.noTools?.includes(toolType) ? false
+    : argv.tools?.includes(toolType) ? true
+    : undefined;
+
+  const includeDynamicTools = shouldIncludeToolType('dynamic');
+  const includeAllTools = shouldIncludeToolType('all');
+  const includeCodeTools = shouldIncludeToolType('code');
+  const includeDocsTools = shouldIncludeToolType('docs');
+
+  const transport = argv.transport as 'stdio' | 'http';
 
+  const client = argv.client as ClientType;
   return {
+    client: client && client !== 'infer' && knownClients[client] ? client : undefined,
     includeDynamicTools,
     includeAllTools,
+    includeCodeTools,
+    includeDocsTools,
     filters,
     capabilities: clientCapabilities,
     list: argv.list || false,
+    transport,
+    port: argv.port,
+    socket: argv.socket,
+  };
+}
+
+const coerceArray = <T extends z.ZodTypeAny>(zodType: T) =>
+  z.preprocess(
+    (val) =>
+      Array.isArray(val) ? val
+      : val ? [val]
+      : val,
+    z.array(zodType).optional(),
+  );
+
+const QueryOptions = z.object({
+  tools: coerceArray(z.enum(['dynamic', 'all', 'code', 'docs'])).describe('Specify which MCP tools to use'),
+  no_tools: coerceArray(z.enum(['dynamic', 'all', 'code', 'docs'])).describe(
+    'Specify which MCP tools to not use.',
+  ),
+  tool: coerceArray(z.string()).describe('Include tools matching the specified names'),
+  resource: coerceArray(z.string()).describe('Include tools matching the specified resources'),
+  operation: coerceArray(z.enum(['read', 'write'])).describe(
+    'Include tools matching the specified operations',
+  ),
+  tag: coerceArray(z.string()).describe('Include tools with the specified tags'),
+  no_tool: coerceArray(z.string()).describe('Exclude tools matching the specified names'),
+  no_resource: coerceArray(z.string()).describe('Exclude tools matching the specified resources'),
+  no_operation: coerceArray(z.enum(['read', 'write'])).describe(
+    'Exclude tools matching the specified operations',
+  ),
+  no_tag: coerceArray(z.string()).describe('Exclude tools with the specified tags'),
+  client: ClientType.optional().describe('Specify the MCP client being used'),
+  capability: coerceArray(z.string()).describe('Specify client capabilities'),
+  no_capability: coerceArray(z.enum(CAPABILITY_CHOICES)).describe('Unset client capabilities'),
+});
+
+export function parseQueryOptions(defaultOptions: McpOptions, query: unknown): McpOptions {
+  const queryObject = typeof query === 'string' ? qs.parse(query) : query;
+  const queryOptions = QueryOptions.parse(queryObject);
+
+  const filters: Filter[] = [...(defaultOptions.filters ?? [])];
+
+  for (const resource of queryOptions.resource || []) {
+    filters.push({ type: 'resource', op: 'include', value: resource });
+  }
+  for (const operation of queryOptions.operation || []) {
+    filters.push({ type: 'operation', op: 'include', value: operation });
+  }
+  for (const tag of queryOptions.tag || []) {
+    filters.push({ type: 'tag', op: 'include', value: tag });
+  }
+  for (const tool of queryOptions.tool || []) {
+    filters.push({ type: 'tool', op: 'include', value: tool });
+  }
+  for (const resource of queryOptions.no_resource || []) {
+    filters.push({ type: 'resource', op: 'exclude', value: resource });
+  }
+  for (const operation of queryOptions.no_operation || []) {
+    filters.push({ type: 'operation', op: 'exclude', value: operation });
+  }
+  for (const tag of queryOptions.no_tag || []) {
+    filters.push({ type: 'tag', op: 'exclude', value: tag });
+  }
+  for (const tool of queryOptions.no_tool || []) {
+    filters.push({ type: 'tool', op: 'exclude', value: tool });
+  }
+
+  // Parse client capabilities
+  const clientCapabilities: Partial<ClientCapabilities> = { ...defaultOptions.capabilities };
+
+  for (const cap of queryOptions.capability || []) {
+    const parsed = parseCapabilityValue(cap);
+    if (parsed.name === 'top-level-unions') {
+      clientCapabilities.topLevelUnions = true;
+    } else if (parsed.name === 'valid-json') {
+      clientCapabilities.validJson = true;
+    } else if (parsed.name === 'refs') {
+      clientCapabilities.refs = true;
+    } else if (parsed.name === 'unions') {
+      clientCapabilities.unions = true;
+    } else if (parsed.name === 'formats') {
+      clientCapabilities.formats = true;
+    } else if (parsed.name === 'tool-name-length') {
+      clientCapabilities.toolNameLength = parsed.value;
+    }
+  }
+
+  for (const cap of queryOptions.no_capability || []) {
+    if (cap === 'top-level-unions') {
+      clientCapabilities.topLevelUnions = false;
+    } else if (cap === 'valid-json') {
+      clientCapabilities.validJson = false;
+    } else if (cap === 'refs') {
+      clientCapabilities.refs = false;
+    } else if (cap === 'unions') {
+      clientCapabilities.unions = false;
+    } else if (cap === 'formats') {
+      clientCapabilities.formats = false;
+    } else if (cap === 'tool-name-length') {
+      clientCapabilities.toolNameLength = undefined;
+    }
+  }
+
+  let dynamicTools: boolean | undefined =
+    queryOptions.no_tools && queryOptions.no_tools?.includes('dynamic') ? false
+    : queryOptions.tools?.includes('dynamic') ? true
+    : defaultOptions.includeDynamicTools;
+
+  let allTools: boolean | undefined =
+    queryOptions.no_tools && queryOptions.no_tools?.includes('all') ? false
+    : queryOptions.tools?.includes('all') ? true
+    : defaultOptions.includeAllTools;
+
+  let docsTools: boolean | undefined =
+    queryOptions.no_tools && queryOptions.no_tools?.includes('docs') ? false
+    : queryOptions.tools?.includes('docs') ? true
+    : defaultOptions.includeDocsTools;
+
+  let codeTools: boolean | undefined =
+    queryOptions.no_tools && queryOptions.no_tools?.includes('code') ? false
+    : queryOptions.tools?.includes('code') && defaultOptions.includeCodeTools ? true
+    : defaultOptions.includeCodeTools;
+
+  return {
+    client: queryOptions.client ?? defaultOptions.client,
+    includeDynamicTools: dynamicTools,
+    includeAllTools: allTools,
+    includeCodeTools: codeTools,
+    includeDocsTools: docsTools,
+    filters,
+    capabilities: clientCapabilities,
   };
 }
 
@@ -323,7 +435,7 @@ Client Presets (--client):
 Presets like '--client=openai-agents' or '--client=cursor' automatically configure these capabilities based on current known limitations of those clients, simplifying setup.
 
 Current presets:
-${JSON.stringify(CLIENT_PRESETS, null, 2)}
+${JSON.stringify(knownClients, null, 2)}
   `;
 }
 

package/src/server.ts

@@ -3,86 +3,174 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { Endpoint, endpoints, HandlerFunction, query } from './tools';
-import { CallToolRequestSchema, ListToolsRequestSchema, Tool } from '@modelcontextprotocol/sdk/types.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  SetLevelRequestSchema,
+  Implementation,
+  Tool,
+} from '@modelcontextprotocol/sdk/types.js';
+import { ClientOptions } from '@tryfinch/finch-api';
 import Finch from '@tryfinch/finch-api';
 import {
   applyCompatibilityTransformations,
   ClientCapabilities,
   defaultClientCapabilities,
+  knownClients,
   parseEmbeddedJSON,
 } from './compat';
 import { dynamicTools } from './dynamic-tools';
-import { ParsedOptions } from './options';
+import { codeTool } from './code-tool';
+import docsSearchTool from './docs-search-tool';
+import { McpOptions } from './options';
+
+export { McpOptions } from './options';
+export { ClientType } from './compat';
+export { Filter } from './tools';
+export { ClientOptions } from '@tryfinch/finch-api';
 export { endpoints } from './tools';
 
-// Create server instance
-export const server = new McpServer(
-  {
-    name: 'tryfinch_finch_api_api',
-    version: '6.31.0',
-  },
-  {
-    capabilities: {
-      tools: {},
+export const newMcpServer = () =>
+  new McpServer(
+    {
+      name: 'tryfinch_finch_api_api',
+      version: '7.0.0',
     },
-  },
-);
+    { capabilities: { tools: {}, logging: {} } },
+  );
+
+// Create server instance
+export const server = newMcpServer();
 
 /**
  * Initializes the provided MCP Server with the given tools and handlers.
  * If not provided, the default client, tools and handlers will be used.
  */
-export function init(params: {
+export function initMcpServer(params: {
   server: Server | McpServer;
-  client?: Finch;
-  endpoints?: { tool: Tool; handler: HandlerFunction }[];
-  capabilities?: Partial<ClientCapabilities>;
+  clientOptions?: ClientOptions;
+  mcpOptions?: McpOptions;
 }) {
   const server = params.server instanceof McpServer ? params.server.server : params.server;
-  const providedEndpoints = params.endpoints || endpoints;
+  const mcpOptions = params.mcpOptions ?? {};
+
+  let providedEndpoints: Endpoint[] | null = null;
+  let endpointMap: Record<string, Endpoint> | null = null;
+
+  const initTools = async (implementation?: Implementation) => {
+    if (implementation && (!mcpOptions.client || mcpOptions.client === 'infer')) {
+      mcpOptions.client =
+        implementation.name.toLowerCase().includes('claude') ? 'claude'
+        : implementation.name.toLowerCase().includes('cursor') ? 'cursor'
+        : undefined;
+      mcpOptions.capabilities = {
+        ...(mcpOptions.client && knownClients[mcpOptions.client]),
+        ...mcpOptions.capabilities,
+      };
+    }
+    providedEndpoints ??= await selectTools(endpoints, mcpOptions);
+    endpointMap ??= Object.fromEntries(providedEndpoints.map((endpoint) => [endpoint.tool.name, endpoint]));
+  };
 
-  const endpointMap = Object.fromEntries(providedEndpoints.map((endpoint) => [endpoint.tool.name, endpoint]));
+  const logAtLevel =
+    (level: 'debug' | 'info' | 'warning' | 'error') =>
+    (message: string, ...rest: unknown[]) => {
+      void server.sendLoggingMessage({
+        level,
+        data: { message, rest },
+      });
+    };
+  const logger = {
+    debug: logAtLevel('debug'),
+    info: logAtLevel('info'),
+    warn: logAtLevel('warning'),
+    error: logAtLevel('error'),
+  };
 
-  const client = params.client || new Finch({ accessToken: readEnv('FINCH_ACCESS_TOKEN') });
+  let client = new Finch({
+    ...{ accessToken: readEnv('FINCH_ACCESS_TOKEN') },
+    logger,
+    ...params.clientOptions,
+    defaultHeaders: {
+      ...params.clientOptions?.defaultHeaders,
+      'X-Stainless-MCP': 'true',
+    },
+  });
 
   server.setRequestHandler(ListToolsRequestSchema, async () => {
+    if (providedEndpoints === null) {
+      await initTools(server.getClientVersion());
+    }
     return {
-      tools: providedEndpoints.map((endpoint) => endpoint.tool),
+      tools: providedEndpoints!.map((endpoint) => endpoint.tool),
     };
   });
 
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    if (endpointMap === null) {
+      await initTools(server.getClientVersion());
+    }
     const { name, arguments: args } = request.params;
-    const endpoint = endpointMap[name];
+    const endpoint = endpointMap![name];
     if (!endpoint) {
       throw new Error(`Unknown tool: ${name}`);
     }
 
-    return executeHandler(endpoint.tool, endpoint.handler, client, args, params.capabilities);
+    return executeHandler(endpoint.tool, endpoint.handler, client, args, mcpOptions.capabilities);
+  });
+
+  server.setRequestHandler(SetLevelRequestSchema, async (request) => {
+    const { level } = request.params;
+    switch (level) {
+      case 'debug':
+        client = client.withOptions({ logLevel: 'debug' });
+        break;
+      case 'info':
+        client = client.withOptions({ logLevel: 'info' });
+        break;
+      case 'notice':
+      case 'warning':
+        client = client.withOptions({ logLevel: 'warn' });
+        break;
+      case 'error':
+        client = client.withOptions({ logLevel: 'error' });
+        break;
+      default:
+        client = client.withOptions({ logLevel: 'off' });
+        break;
+    }
+    return {};
   });
 }
 
 /**
  * Selects the tools to include in the MCP Server based on the provided options.
  */
-export function selectTools(endpoints: Endpoint[], options: ParsedOptions) {
-  const filteredEndpoints = query(options.filters, endpoints);
-
-  const includedTools = filteredEndpoints;
+export async function selectTools(endpoints: Endpoint[], options?: McpOptions): Promise<Endpoint[]> {
+  const filteredEndpoints = query(options?.filters ?? [], endpoints);
 
-  if (options.includeAllTools && includedTools.length === 0) {
-    includedTools.push(...endpoints);
-  }
+  let includedTools = filteredEndpoints.slice();
 
-  if (options.includeDynamicTools) {
-    includedTools.push(...dynamicTools(endpoints));
+  if (includedTools.length > 0) {
+    if (options?.includeDynamicTools) {
+      includedTools = dynamicTools(includedTools);
+    }
+  } else {
+    if (options?.includeAllTools) {
+      includedTools = endpoints.slice();
+    } else if (options?.includeDynamicTools) {
+      includedTools = dynamicTools(endpoints);
+    } else if (options?.includeCodeTools) {
+      includedTools = [await codeTool()];
+    } else {
+      includedTools = endpoints.slice();
+    }
   }
-
-  if (includedTools.length === 0) {
-    includedTools.push(...endpoints);
+  if (options?.includeDocsTools ?? true) {
+    includedTools.push(docsSearchTool);
   }
-
-  return applyCompatibilityTransformations(includedTools, options.capabilities);
+  const capabilities = { ...defaultClientCapabilities, ...options?.capabilities };
+  return applyCompatibilityTransformations(includedTools, capabilities);
 }
 
 /**
@@ -96,18 +184,10 @@ export async function executeHandler(
   compatibilityOptions?: Partial<ClientCapabilities>,
 ) {
   const options = { ...defaultClientCapabilities, ...compatibilityOptions };
-  if (options.validJson && args) {
-    args = args = parseEmbeddedJSON(args, tool.inputSchema);
+  if (!options.validJson && args) {
+    args = parseEmbeddedJSON(args, tool.inputSchema);
   }
-  const result = await handler(client, args || {});
-  return {
-    content: [
-      {
-        type: 'text',
-        text: JSON.stringify(result, null, 2),
-      },
-    ],
-  };
+  return await handler(client, args || {});
 }
 
 export const readEnv = (env: string): string | undefined => {

package/src/stdio.ts

@@ -0,0 +1,13 @@
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { initMcpServer, newMcpServer } from './server';
+import { McpOptions } from './options';
+
+export const launchStdioServer = async (options: McpOptions) => {
+  const server = newMcpServer();
+
+  initMcpServer({ server, mcpOptions: options });
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('MCP Server running on stdio');
+};

package/src/tools/access-tokens/create-access-tokens.ts

@@ -1,40 +1,65 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+import { isJqError, maybeFilter } from '@tryfinch/finch-api-mcp/filtering';
+import { Metadata, asErrorResult, asTextContentResult } from '@tryfinch/finch-api-mcp/tools/types';
+
 import { Tool } from '@modelcontextprotocol/sdk/types.js';
-import type { Metadata } from '../';
 import Finch from '@tryfinch/finch-api';
 
 export const metadata: Metadata = {
   resource: 'access_tokens',
   operation: 'write',
   tags: [],
+  httpMethod: 'post',
+  httpPath: '/auth/token',
+  operationId: 'create-access-token',
 };
 
 export const tool: Tool = {
   name: 'create_access_tokens',
-  description: 'Exchange the authorization code for an access token',
+  description:
+    "When using this tool, always use the `jq_filter` parameter to reduce the response size and improve performance.\n\nOnly omit if you're sure you don't need the data.\n\nExchange the authorization code for an access token\n\n# Response Schema\n```json\n{\n  $ref: '#/$defs/create_access_token_response',\n  $defs: {\n    create_access_token_response: {\n      type: 'object',\n      properties: {\n        access_token: {\n          type: 'string',\n          description: 'The access token for the connection'\n        },\n        client_type: {\n          type: 'string',\n          title: 'ClientType',\n          description: 'The type of application associated with a token.',\n          enum: [            'development',\n            'production',\n            'sandbox'\n          ]\n        },\n        connection_id: {\n          type: 'string',\n          description: 'The Finch UUID of the connection associated with the `access_token`'\n        },\n        connection_type: {\n          type: 'string',\n          title: 'ConnectionType',\n          description: 'The type of the connection associated with the token.\\n- `provider` - connection to an external provider\\n- `finch` - finch-generated data.',\n          enum: [            'finch',\n            'provider'\n          ]\n        },\n        entity_ids: {\n          type: 'array',\n          description: 'An array of entity IDs that can be accessed with this access token',\n          items: {\n            type: 'string'\n          }\n        },\n        products: {\n          type: 'array',\n          description: 'An array of the authorized products associated with the `access_token`',\n          items: {\n            type: 'string'\n          }\n        },\n        provider_id: {\n          type: 'string',\n          description: 'The ID of the provider associated with the `access_token`'\n        },\n        token_type: {\n          type: 'string',\n          description: 'The RFC 8693 token type (Finch uses `bearer` tokens)'\n        },\n        account_id: {\n          type: 'string',\n          description: '[DEPRECATED] Use `connection_id` to identify the connection instead of this account ID'\n        },\n        company_id: {\n          type: 'string',\n          description: '[DEPRECATED] Use `connection_id` to identify the connection instead of this company ID'\n        },\n        customer_id: {\n          type: 'string',\n          description: 'The ID of your customer you provided to Finch when a connect session was created for this connection'\n        }\n      },\n      required: [        'access_token',\n        'client_type',\n        'connection_id',\n        'connection_type',\n        'entity_ids',\n        'products',\n        'provider_id',\n        'token_type'\n      ]\n    }\n  }\n}\n```",
   inputSchema: {
     type: 'object',
     properties: {
       code: {
         type: 'string',
+        description: 'The authorization code received from the authorization server',
       },
       client_id: {
         type: 'string',
+        description: 'The client ID for your application',
       },
       client_secret: {
         type: 'string',
+        description: 'The client secret for your application',
       },
       redirect_uri: {
         type: 'string',
+        description: 'The redirect URI used in the authorization request (optional)',
+      },
+      jq_filter: {
+        type: 'string',
+        title: 'jq Filter',
+        description:
+          'A jq filter to apply to the response to include certain fields. Consult the output schema in the tool description to see the fields that are available.\n\nFor example: to include only the `name` field in every object of a results array, you can provide ".results[].name".\n\nFor more information, see the [jq documentation](https://jqlang.org/manual/).',
       },
     },
+    required: ['code'],
   },
+  annotations: {},
 };
 
-export const handler = (client: Finch, args: Record<string, unknown> | undefined) => {
-  const body = args as any;
-  return client.accessTokens.create(body);
+export const handler = async (client: Finch, args: Record<string, unknown> | undefined) => {
+  const { jq_filter, ...body } = args as any;
+  try {
+    return asTextContentResult(await maybeFilter(jq_filter, await client.accessTokens.create(body)));
+  } catch (error) {
+    if (error instanceof Finch.APIError || isJqError(error)) {
+      return asErrorResult(error.message);
+    }
+    throw error;
+  }
 };
 
 export default { metadata, tool, handler };