@shipfox/api-integration-core 12.4.0 → 12.6.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-integration-core",
   "license": "MIT",
-  "version": "12.4.0",
+  "version": "12.6.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -26,17 +26,17 @@
     "zod": "^4.4.3",
     "@shipfox/api-agent-dto": "12.2.0",
     "@shipfox/api-auth-context": "12.2.0",
-    "@shipfox/api-workflows-dto": "12.3.0",
+    "@shipfox/api-workflows-dto": "12.6.0",
     "@shipfox/api-integration-core-dto": "12.2.0",
-    "@shipfox/api-integration-spi": "1.1.0",
+    "@shipfox/api-integration-spi": "1.1.1",
     "@shipfox/api-workspaces-dto": "12.0.0",
-    "@shipfox/api-integration-gitea": "12.3.0",
-    "@shipfox/api-integration-github": "12.3.0",
-    "@shipfox/api-integration-jira": "12.4.0",
-    "@shipfox/api-integration-linear": "12.3.0",
-    "@shipfox/api-integration-sentry": "12.3.0",
-    "@shipfox/api-integration-slack": "12.3.0",
-    "@shipfox/api-integration-webhook": "12.3.0",
+    "@shipfox/api-integration-gitea": "12.5.0",
+    "@shipfox/api-integration-github": "12.6.0",
+    "@shipfox/api-integration-jira": "12.5.0",
+    "@shipfox/api-integration-linear": "12.5.0",
+    "@shipfox/api-integration-sentry": "12.5.0",
+    "@shipfox/api-integration-slack": "12.5.0",
+    "@shipfox/api-integration-webhook": "12.5.0",
     "@shipfox/config": "1.2.4",
     "@shipfox/inter-module": "0.2.3",
     "@shipfox/node-drizzle": "0.3.5",

package/src/metrics/instance.ts

@@ -1,3 +1,4 @@
+import type {IntegrationProviderErrorReason} from '@shipfox/api-integration-spi';
 import {instanceMetrics} from '@shipfox/node-opentelemetry';
 
 const meter = instanceMetrics.getMeter('integrations');
@@ -8,13 +9,42 @@ export type IntegrationAgentToolCallOutcome =
   | 'invalid-request'
   | 'exception';
 
+export type IntegrationAgentToolCallErrorCode =
+  | 'invalid-request'
+  | 'unknown'
+  | 'provider-timeout'
+  | 'credentials-unavailable'
+  | IntegrationProviderErrorReason;
+
+export type IntegrationAgentToolCallErrorLabel = IntegrationAgentToolCallErrorCode | 'none';
+
+const integrationAgentToolCallErrorCodes = new Set<string>([
+  'invalid-request',
+  'unknown',
+  'provider-timeout',
+  'credentials-unavailable',
+  'repository-not-found',
+  'installation-not-found',
+  'file-not-found',
+  'access-denied',
+  'rate-limited',
+  'timeout',
+  'provider-unavailable',
+  'provider-rejected',
+  'malformed-provider-response',
+  'content-too-large',
+  'too-many-files',
+]);
+
 const agentToolCallCount = meter.createCounter<{
   provider: string;
   tool: string;
   method: string;
   outcome: IntegrationAgentToolCallOutcome;
+  error_code: IntegrationAgentToolCallErrorLabel;
 }>('integrations_agent_tool_call', {
-  description: 'Integration agent tool calls by provider, tool, method, and outcome',
+  description:
+    'Integration agent tool calls by provider, tool, method, outcome, and bounded error code',
 });
 
 function recordMetric(record: () => void): void {
@@ -30,6 +60,15 @@ export function recordIntegrationAgentToolCall(params: {
   tool: string;
   method: string;
   outcome: IntegrationAgentToolCallOutcome;
+  error_code: IntegrationAgentToolCallErrorLabel;
 }): void {
   recordMetric(() => agentToolCallCount.add(1, params));
 }
+
+export function normalizeIntegrationAgentToolCallErrorCode(
+  value: unknown,
+): IntegrationAgentToolCallErrorCode {
+  return typeof value === 'string' && integrationAgentToolCallErrorCodes.has(value)
+    ? (value as IntegrationAgentToolCallErrorCode)
+    : 'unknown';
+}

package/src/presentation/routes/agent-tools-gateway/agent-tools-gateway.route.test.ts

@@ -9,6 +9,7 @@ import {
 } from '@shipfox/api-auth-context';
 import {type AuthMethod, ClientError, closeApp, createApp} from '@shipfox/node-fastify';
 import type {FastifyInstance, FastifyRequest} from 'fastify';
+import {IntegrationProviderError} from '#core/errors.js';
 import {
   agentStepConfig,
   catalogTool,
@@ -227,13 +228,19 @@ describe('agent tools gateway route', () => {
     });
   });
 
-  it('returns bounded MCP errors when provider dispatch fails', async () => {
+  it('returns the provider message and terminal code for rejected calls', async () => {
     const lease = leaseContext({workspaceId: 'workspace-1'});
     const integration = materializedIntegration({connectionId: 'connection-1'});
     leases.set('provider-error-lease', lease);
+    const providerError = new IntegrationProviderError(
+      'provider-rejected',
+      'commit_id is missing',
+      undefined,
+      422,
+    );
     const app = await createGatewayApp({
       registry: registryWithAgentTools([catalogTool()], {
-        callError: new Error('remote provider leaked implementation detail'),
+        callError: providerError,
       }),
       loadLeasedAgentStep: async () => ({
         workspaceId: lease.workspaceId,
@@ -269,8 +276,8 @@ describe('agent tools gateway route', () => {
 
     expect(result).toEqual({
       isError: true,
-      content: [{type: 'text', text: 'Integration provider call failed'}],
-      structuredContent: {code: 'provider-unavailable'},
+      content: [{type: 'text', text: 'commit_id is missing'}],
+      structuredContent: {code: 'provider-rejected', status: 422},
     });
   });
 

package/src/presentation/routes/agent-tools-gateway/audit.test.ts

@@ -43,6 +43,7 @@ describe('integration tool call audit', () => {
       },
       method: 'get',
       outcome: 'success',
+      errorCode: 'none',
     });
 
     expect(recordMetric).toHaveBeenCalledWith({
@@ -50,6 +51,7 @@ describe('integration tool call audit', () => {
       tool: 'issue_read',
       method: 'get',
       outcome: 'success',
+      error_code: 'none',
     });
     expect(logInfo).toHaveBeenCalledWith(
       expect.objectContaining({
@@ -65,6 +67,7 @@ describe('integration tool call audit', () => {
         toolId: 'issue_read',
         method: 'get',
         outcome: 'success',
+        errorCode: 'none',
         argumentSummary: {
           keys: ['owner', 'repo', 'token'],
           serializedSizeBytes: expect.any(Number),
@@ -75,6 +78,54 @@ describe('integration tool call audit', () => {
     expect(JSON.stringify(logInfo.mock.calls)).not.toContain('must-not-appear');
   });
 
+  it('records bounded provider error details without logging arguments', () => {
+    const recordMetric = vi.fn();
+    const logInfo = vi.fn();
+    const lease = leaseContext({jobId: 'job-1', workspaceId: 'workspace-1'});
+    const integration = materializedIntegration({connectionId: 'connection-1'});
+    const tool = materializedTool();
+    const recorder = createIntegrationToolCallRecorder(lease, {recordMetric, logInfo});
+
+    recorder({
+      authorizedTool: {
+        mcpName: 'github_main__issue_read',
+        integration,
+        tool,
+        connection: connection({
+          id: 'connection-1',
+          workspaceId: 'workspace-1',
+          slug: integration.connectionSlug,
+        }),
+        description: 'Read issues',
+        inputSchema: tool.inputSchema,
+      },
+      arguments: {repo: 'private-repository', token: 'must-not-appear'},
+      method: 'get',
+      outcome: 'tool-error',
+      errorCode: 'provider-rejected',
+      providerStatus: 422,
+    });
+
+    expect(recordMetric).toHaveBeenCalledWith({
+      provider: 'github',
+      tool: 'issue_read',
+      method: 'get',
+      outcome: 'tool-error',
+      error_code: 'provider-rejected',
+    });
+    expect(logInfo).toHaveBeenCalledWith(
+      expect.objectContaining({
+        jobId: 'job-1',
+        workspaceId: 'workspace-1',
+        errorCode: 'provider-rejected',
+        providerStatus: 422,
+      }),
+      'integration tool call audited',
+    );
+    expect(JSON.stringify(logInfo.mock.calls)).not.toContain('private-repository');
+    expect(JSON.stringify(logInfo.mock.calls)).not.toContain('must-not-appear');
+  });
+
   it('summarizes arguments without values', () => {
     const summary = summarizeIntegrationToolArguments({z: 'secret', a: 1});
 

package/src/presentation/routes/agent-tools-gateway/audit.ts

@@ -1,11 +1,14 @@
 import type {LeasedJobContext} from '@shipfox/api-auth-context';
 import {logger} from '@shipfox/node-opentelemetry';
 import {
+  type IntegrationAgentToolCallErrorLabel,
   type IntegrationAgentToolCallOutcome,
   recordIntegrationAgentToolCall,
 } from '#metrics/index.js';
 import type {AuthorizedIntegrationTool} from './resolve-authorized-tools.js';
 
+export type {IntegrationAgentToolCallErrorCode} from '#metrics/index.js';
+
 export const UNKNOWN_TOOL_LABEL = 'unknown';
 export const NO_METHOD_LABEL = 'none';
 export const INVALID_METHOD_LABEL = 'invalid';
@@ -20,6 +23,8 @@ export interface IntegrationToolCallAuditRecord {
   arguments: unknown;
   method: string;
   outcome: IntegrationAgentToolCallOutcome;
+  errorCode: IntegrationAgentToolCallErrorLabel;
+  providerStatus?: number | undefined;
 }
 
 export type IntegrationToolCallRecorder = (record: IntegrationToolCallAuditRecord) => void;
@@ -47,6 +52,7 @@ export function createIntegrationToolCallRecorder(
       tool: toolId,
       method: record.method,
       outcome: record.outcome,
+      error_code: record.errorCode,
     });
 
     logInfo(
@@ -63,6 +69,8 @@ export function createIntegrationToolCallRecorder(
         toolId,
         method: record.method,
         outcome: record.outcome,
+        errorCode: record.errorCode,
+        ...(record.providerStatus === undefined ? {} : {providerStatus: record.providerStatus}),
         argumentSummary: summarizeIntegrationToolArguments(record.arguments),
       },
       'integration tool call audited',

package/src/presentation/routes/agent-tools-gateway/dispatch.test.ts

@@ -0,0 +1,167 @@
+import type {reportError as reportErrorType} from '@shipfox/node-error-monitoring';
+import type {logger as loggerFactoryType} from '@shipfox/node-opentelemetry';
+import {IntegrationProviderError} from '#core/errors.js';
+import {
+  catalogTool,
+  connection,
+  leaseContext,
+  materializedIntegration,
+  materializedTool,
+  registryWithAgentTools,
+} from '#test/agent-tools-gateway-helpers.js';
+import {createIntegrationToolDispatcher} from './dispatch.js';
+import type {AuthorizedIntegrationTool} from './resolve-authorized-tools.js';
+
+const dispatchMocks = vi.hoisted(() => ({
+  loggerError: vi.fn(),
+  reportError: vi.fn(),
+}));
+
+const loggerFactory = (() => ({
+  error: dispatchMocks.loggerError,
+})) as unknown as typeof loggerFactoryType;
+const reportError = dispatchMocks.reportError as unknown as typeof reportErrorType;
+
+describe('createIntegrationToolDispatcher', () => {
+  beforeEach(() => {
+    dispatchMocks.loggerError.mockReset();
+    dispatchMocks.reportError.mockReset();
+  });
+
+  it('preserves terminal provider errors without reporting them as outages', async () => {
+    const providerError = new IntegrationProviderError(
+      'provider-rejected',
+      'commit_id is missing',
+      undefined,
+      422,
+    );
+    const dispatch = createDispatcher(providerError);
+
+    const result = await dispatch({
+      authorizedTool: authorizedTool(),
+      arguments: {method: 'get', owner: 'shipfox', repo: 'platform', issue_number: 1},
+      method: 'get',
+    });
+
+    expect(result).toEqual({
+      isError: true,
+      content: [{type: 'text', text: 'commit_id is missing'}],
+      structuredContent: {code: 'provider-rejected', status: 422},
+    });
+    expect(dispatchMocks.loggerError).not.toHaveBeenCalled();
+    expect(dispatchMocks.reportError).not.toHaveBeenCalled();
+  });
+
+  it('reports provider outages while preserving their message and status', async () => {
+    const providerError = new IntegrationProviderError(
+      'provider-unavailable',
+      'GitHub returned HTTP 503',
+      undefined,
+      503,
+    );
+    const dispatch = createDispatcher(providerError);
+
+    const result = await dispatch({
+      authorizedTool: authorizedTool(),
+      arguments: {method: 'get', owner: 'shipfox', repo: 'platform', issue_number: 1},
+      method: 'get',
+    });
+
+    expect(result).toEqual({
+      isError: true,
+      content: [{type: 'text', text: 'GitHub returned HTTP 503'}],
+      structuredContent: {code: 'provider-unavailable', status: 503},
+    });
+    expect(dispatchMocks.loggerError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        err: providerError,
+        provider: 'github',
+        toolId: 'issue_read',
+        method: 'get',
+        errorCode: 'provider-unavailable',
+        providerStatus: 503,
+      }),
+      'Integration agent tool provider was unavailable',
+    );
+    expect(dispatchMocks.loggerError.mock.calls[0]?.[0]).toMatchObject({
+      jobId: 'job-1',
+      jobExecutionId: 'execution-1',
+      workflowRunId: 'run-1',
+      workflowRunAttemptId: 'attempt-1',
+      workspaceId: 'workspace-1',
+      currentStepId: 'step-1',
+      currentStepAttempt: 2,
+      connectionId: 'connection-1',
+    });
+    expect(dispatchMocks.reportError).toHaveBeenCalledWith(providerError, {
+      boundary: 'integration.agent-tool',
+    });
+  });
+
+  it('classifies unrecognized failures as unknown instead of provider outages', async () => {
+    const internalError = new Error('request timeout configuration is invalid');
+    const dispatch = createDispatcher(internalError);
+
+    const result = await dispatch({
+      authorizedTool: authorizedTool(),
+      arguments: {method: 'get', owner: 'shipfox', repo: 'platform', issue_number: 1},
+      method: 'get',
+    });
+
+    expect(result).toEqual({
+      isError: true,
+      content: [{type: 'text', text: 'Integration tool call failed'}],
+      structuredContent: {code: 'unknown'},
+    });
+    expect(dispatchMocks.loggerError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        err: internalError,
+        provider: 'github',
+        toolId: 'issue_read',
+        method: 'get',
+        errorCode: 'unknown',
+      }),
+      'Integration agent tool call failed',
+    );
+    expect(dispatchMocks.loggerError.mock.calls[0]?.[0]).not.toHaveProperty('providerStatus');
+    expect(dispatchMocks.reportError).toHaveBeenCalledWith(internalError, {
+      boundary: 'integration.agent-tool',
+    });
+  });
+});
+
+function createDispatcher(callError: unknown) {
+  return createIntegrationToolDispatcher(
+    {
+      registry: registryWithAgentTools([catalogTool()], {callError}),
+      lease: leaseContext({
+        jobId: 'job-1',
+        jobExecutionId: 'execution-1',
+        workflowRunId: 'run-1',
+        workflowRunAttemptId: 'attempt-1',
+        workspaceId: 'workspace-1',
+        currentStepId: 'step-1',
+        currentStepAttempt: 2,
+      }),
+    },
+    {logger: loggerFactory, reportError},
+  );
+}
+
+function authorizedTool(): AuthorizedIntegrationTool {
+  const integration = materializedIntegration({connectionId: 'connection-1'});
+  const tool = materializedTool();
+  return {
+    mcpName: 'github_main__issue_read',
+    integration,
+    tool,
+    connection: connection({
+      id: integration.connectionId,
+      workspaceId: 'workspace-1',
+      slug: integration.connectionSlug,
+    }),
+    description: 'Read issue metadata from GitHub.',
+    inputSchema: tool.inputSchema,
+    outputSchema: tool.outputSchema,
+  };
+}

package/src/presentation/routes/agent-tools-gateway/dispatch.ts

@@ -1,4 +1,5 @@
 import type {CallToolResult} from '@modelcontextprotocol/sdk/types.js';
+import type {LeasedJobContext} from '@shipfox/api-auth-context';
 import {reportError} from '@shipfox/node-error-monitoring';
 import {logger} from '@shipfox/node-opentelemetry';
 import {IntegrationProviderError} from '#core/errors.js';
@@ -9,23 +10,45 @@ import type {
   AgentToolsProvider,
 } from '#core/providers/agent-tools.js';
 import type {IntegrationProviderRegistry} from '#core/providers/registry.js';
+import type {IntegrationAgentToolCallErrorCode} from '#metrics/index.js';
+import {NO_METHOD_LABEL} from './audit.js';
 import type {IntegrationToolDispatcher, IntegrationToolDispatchInput} from './mcp-server.js';
 
 export interface CreateIntegrationToolDispatcherParams {
   registry: IntegrationProviderRegistry;
+  lease?: LeasedJobContext | undefined;
 }
 
-const timeoutErrorPattern = /timed?\s*out|timeout/i;
+export interface IntegrationToolDispatcherDependencies {
+  logger?: typeof logger;
+  reportError?: typeof reportError;
+}
+
+const timeoutErrorNamePattern = /timed?\s*out|timeout/i;
+const mcpRequestTimeoutMessagePattern = /^MCP error -32001:\s*Request timed out\b/i;
 const credentialErrorNamePattern = /Token|Credential|Secret|AccessToken/;
 
 export function createIntegrationToolDispatcher(
   params: CreateIntegrationToolDispatcherParams,
+  dependencies: IntegrationToolDispatcherDependencies = {},
 ): IntegrationToolDispatcher {
-  return (input) => dispatchIntegrationToolCall({...input, registry: params.registry});
+  return (input) =>
+    dispatchIntegrationToolCall({
+      ...input,
+      registry: params.registry,
+      lease: params.lease,
+      logger: dependencies.logger ?? logger,
+      reportError: dependencies.reportError ?? reportError,
+    });
 }
 
 async function dispatchIntegrationToolCall(
-  input: IntegrationToolDispatchInput & {registry: IntegrationProviderRegistry},
+  input: IntegrationToolDispatchInput & {
+    registry: IntegrationProviderRegistry;
+    lease?: LeasedJobContext | undefined;
+    logger: typeof logger;
+    reportError: typeof reportError;
+  },
 ): Promise<CallToolResult> {
   let session: AgentToolSession<CallToolResult> | undefined;
 
@@ -51,19 +74,48 @@ async function dispatchIntegrationToolCall(
     });
   } catch (error) {
     const result = errorResult(error);
-    if (result.code === 'provider-unavailable') {
-      logger().error(
-        {err: error, provider: input.authorizedTool.integration.provider},
-        'Integration agent tool provider was unavailable',
+    if (result.code === 'provider-unavailable' || result.code === 'unknown') {
+      input.logger().error(
+        {
+          ...toolCallLogContext(input),
+          err: error,
+          errorCode: result.code,
+          ...(result.status === undefined ? {} : {providerStatus: result.status}),
+        },
+        result.code === 'provider-unavailable'
+          ? 'Integration agent tool provider was unavailable'
+          : 'Integration agent tool call failed',
       );
-      reportError(error, {boundary: 'integration.agent-tool'});
+      input.reportError(error, {boundary: 'integration.agent-tool'});
     }
     return toolError(result);
   } finally {
-    await closeSession(session);
+    await closeSession(session, input.logger, input.reportError);
   }
 }
 
+function toolCallLogContext(
+  input: IntegrationToolDispatchInput & {lease?: LeasedJobContext | undefined},
+): Record<string, unknown> {
+  return {
+    ...(input.lease === undefined
+      ? {}
+      : {
+          jobId: input.lease.jobId,
+          jobExecutionId: input.lease.jobExecutionId,
+          workflowRunId: input.lease.workflowRunId,
+          workflowRunAttemptId: input.lease.workflowRunAttemptId,
+          workspaceId: input.lease.workspaceId,
+          currentStepId: input.lease.currentStepId,
+          currentStepAttempt: input.lease.currentStepAttempt,
+        }),
+    connectionId: input.authorizedTool.connection.id,
+    provider: input.authorizedTool.integration.provider,
+    toolId: input.authorizedTool.tool.id,
+    method: input.method ?? NO_METHOD_LABEL,
+  };
+}
+
 function agentToolCatalogEntry(input: IntegrationToolDispatchInput): AgentToolCatalogEntry {
   const {tool, description, inputSchema, outputSchema} = input.authorizedTool;
   return {
@@ -90,21 +142,36 @@ function agentToolCatalogEntry(input: IntegrationToolDispatchInput): AgentToolCa
   };
 }
 
-async function closeSession(session: {close?(): Promise<void>} | undefined): Promise<void> {
+async function closeSession(
+  session: {close?(): Promise<void>} | undefined,
+  loggerFactory: typeof logger,
+  reportErrorFn: typeof reportError,
+): Promise<void> {
   try {
     await session?.close?.();
   } catch (error) {
     // Cleanup must not mask the tool result returned to the runner.
-    logger().error({err: error}, 'Failed to close integration agent tool session');
-    reportError(error, {boundary: 'integration.agent-tool', operation: 'close-session'});
+    loggerFactory().error({err: error}, 'Failed to close integration agent tool session');
+    reportErrorFn(error, {boundary: 'integration.agent-tool', operation: 'close-session'});
   }
 }
 
-function errorResult(error: unknown): {code: string; message: string} {
+interface IntegrationToolError {
+  code: IntegrationAgentToolCallErrorCode;
+  message: string;
+  retryAfterSeconds?: number | undefined;
+  status?: number | undefined;
+}
+
+function errorResult(error: unknown): IntegrationToolError {
   if (error instanceof IntegrationProviderError) {
     return {
       code: error.reason,
-      message: `Integration provider error: ${error.reason}`,
+      message: error.message,
+      ...(error.retryAfterSeconds === undefined
+        ? {}
+        : {retryAfterSeconds: error.retryAfterSeconds}),
+      ...(error.status === undefined ? {} : {status: error.status}),
     };
   }
 
@@ -123,8 +190,8 @@ function errorResult(error: unknown): {code: string; message: string} {
   }
 
   return {
-    code: 'provider-unavailable',
-    message: 'Integration provider call failed',
+    code: 'unknown',
+    message: 'Integration tool call failed',
   };
 }
 
@@ -132,8 +199,8 @@ function isTimeoutError(error: unknown): boolean {
   if (!(error instanceof Error)) return false;
   return (
     error.name === 'AbortError' ||
-    timeoutErrorPattern.test(error.name) ||
-    timeoutErrorPattern.test(error.message)
+    timeoutErrorNamePattern.test(error.name) ||
+    (error.name === 'McpError' && mcpRequestTimeoutMessagePattern.test(error.message))
   );
 }
 
@@ -142,10 +209,16 @@ function isCredentialError(error: unknown): boolean {
   return credentialErrorNamePattern.test(error.name);
 }
 
-function toolError(params: {code: string; message: string}): CallToolResult {
+function toolError(params: IntegrationToolError): CallToolResult {
   return {
     isError: true,
     content: [{type: 'text', text: params.message}],
-    structuredContent: {code: params.code},
+    structuredContent: {
+      code: params.code,
+      ...(params.retryAfterSeconds === undefined
+        ? {}
+        : {retryAfterSeconds: params.retryAfterSeconds}),
+      ...(params.status === undefined ? {} : {status: params.status}),
+    },
   };
 }

package/src/presentation/routes/agent-tools-gateway/index.ts

@@ -26,8 +26,6 @@ export interface CreateAgentToolsGatewayRoutesParams {
 export function createAgentToolsGatewayRoutes(
   params: CreateAgentToolsGatewayRoutesParams,
 ): RouteGroup {
-  const dispatchIntegrationToolCall = createIntegrationToolDispatcher({registry: params.registry});
-
   return {
     prefix: '/runs/jobs/current/integration-tools',
     auth: AUTH_LEASED_JOB,
@@ -37,6 +35,7 @@ export function createAgentToolsGatewayRoutes(
         path: '/mcp',
         description: 'Gateway MCP endpoint for integration-backed agent tools',
         handler: async (request, reply) => {
+          const lease = requireLeasedJobContext(request);
           const authorizedTools = await resolveAuthorizedIntegrationTools({
             request,
             loadLeasedAgentStep: params.loadLeasedAgentStep,
@@ -45,8 +44,8 @@ export function createAgentToolsGatewayRoutes(
           });
           const server = buildAgentToolsMcpServer({
             authorizedTools,
-            dispatch: dispatchIntegrationToolCall,
-            recordCall: createIntegrationToolCallRecorder(requireLeasedJobContext(request)),
+            dispatch: createIntegrationToolDispatcher({registry: params.registry, lease}),
+            recordCall: createIntegrationToolCallRecorder(lease),
           });
           const transport = new StreamableHTTPServerTransport();