@shipfox/api-workflows 5.0.0 → 6.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-workflows",
   "license": "MIT",
-  "version": "5.0.0",
+  "version": "6.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -26,28 +26,28 @@
     "@temporalio/workflow": "1.18.1",
     "drizzle-orm": "^0.45.2",
     "zod": "^4.4.3",
-    "@shipfox/api-agent": "5.0.0",
-    "@shipfox/api-auth": "5.0.0",
-    "@shipfox/api-auth-context": "5.0.0",
-    "@shipfox/api-agent-dto": "5.0.0",
-    "@shipfox/annotations": "5.0.0",
-    "@shipfox/api-definitions": "5.0.0",
-    "@shipfox/api-integration-core": "5.0.0",
-    "@shipfox/api-projects": "5.0.0",
-    "@shipfox/api-runners": "5.0.0",
-    "@shipfox/api-runners-dto": "5.0.0",
-    "@shipfox/api-secrets": "5.0.0",
-    "@shipfox/api-secrets-dto": "5.0.0",
-    "@shipfox/api-workflows-dto": "5.0.0",
+    "@shipfox/api-auth-context": "6.0.0",
+    "@shipfox/api-auth-dto": "6.0.0",
+    "@shipfox/api-agent-dto": "6.0.0",
+    "@shipfox/annotations-dto": "6.0.0",
+    "@shipfox/api-definitions-dto": "6.0.0",
+    "@shipfox/api-projects-dto": "6.0.0",
+    "@shipfox/api-integration-core-dto": "6.0.0",
+    "@shipfox/api-projects": "6.0.0",
+    "@shipfox/api-runners": "6.0.0",
+    "@shipfox/api-runners-dto": "6.0.0",
+    "@shipfox/api-secrets-dto": "6.0.0",
+    "@shipfox/api-workflows-dto": "6.0.0",
+    "@shipfox/inter-module": "0.2.0",
     "@shipfox/expression": "1.1.3",
-    "@shipfox/node-drizzle": "0.3.1",
+    "@shipfox/node-drizzle": "0.3.2",
     "@shipfox/node-error-monitoring": "0.1.3",
-    "@shipfox/node-fastify": "0.2.3",
-    "@shipfox/node-module": "0.3.2",
+    "@shipfox/node-fastify": "0.2.4",
+    "@shipfox/node-module": "0.4.0",
     "@shipfox/node-opentelemetry": "0.5.2",
-    "@shipfox/node-outbox": "0.2.3",
+    "@shipfox/node-outbox": "0.2.4",
     "@shipfox/node-postgres": "0.4.2",
-    "@shipfox/node-temporal": "0.3.1",
+    "@shipfox/node-temporal": "0.3.2",
     "@shipfox/runner-labels": "0.1.1"
   },
   "devDependencies": {
@@ -60,9 +60,15 @@
     "fastify": "^5.3.3",
     "fastify-type-provider-zod": "^6.0.0",
     "fishery": "^2.4.0",
-    "@shipfox/api-auth-dto": "5.0.0",
+    "@shipfox/node-auth-root-key": "0.2.0",
+    "@shipfox/annotations": "6.0.0",
+    "@shipfox/api-auth": "6.0.0",
+    "@shipfox/api-agent": "6.0.0",
+    "@shipfox/api-definitions": "6.0.0",
+    "@shipfox/api-integration-core": "6.0.0",
     "@shipfox/biome": "1.8.2",
-    "@shipfox/node-jwt": "0.2.1",
+    "@shipfox/depcruise": "1.0.2",
+    "@shipfox/node-jwt": "0.3.0",
     "@shipfox/node-log": "0.3.4",
     "@shipfox/swc": "1.2.6",
     "@shipfox/ts-config": "1.3.8",
@@ -73,6 +79,7 @@
     "build": "shipfox-swc && shipfox-temporal-bundle dist/temporal/workflows/index.js",
     "check": "shipfox-biome-check",
     "check:fix": "shipfox-biome-check --write",
+    "depcruise": "shipfox-depcruise",
     "test": "shipfox-vitest-run",
     "test:watch": "shipfox-vitest-watch",
     "type": "shipfox-tsc-check",

package/src/core/agent-defaults.test.ts

@@ -0,0 +1,28 @@
+import type {AgentInterModuleClient} from '@shipfox/api-agent-dto/inter-module';
+import {createAgentDefaultsResolver} from './agent-defaults.js';
+
+describe('createAgentDefaultsResolver', () => {
+  test('omits unresolved optional fields from the inter-module input', async () => {
+    const resolveAgentConfig = vi.fn().mockResolvedValue({
+      harness: 'pi',
+      provider: 'anthropic',
+      model: 'claude-opus-4-8',
+      thinking: 'xhigh',
+    });
+    const agent = {resolveAgentConfig} as unknown as AgentInterModuleClient;
+    const resolve = createAgentDefaultsResolver(agent, crypto.randomUUID());
+
+    const defaults = await resolve({});
+
+    expect(defaults).toEqual({
+      harness: 'pi',
+      provider: 'anthropic',
+      model: 'claude-opus-4-8',
+      thinking: 'xhigh',
+    });
+    expect(resolveAgentConfig).toHaveBeenCalledWith({
+      workspaceId: expect.any(String),
+      config: {},
+    });
+  });
+});

package/src/core/agent-defaults.ts

@@ -0,0 +1,36 @@
+import type {AgentThinking, Harness, ModelProviderRef} from '@shipfox/api-agent-dto';
+import type {AgentInterModuleClient} from '@shipfox/api-agent-dto/inter-module';
+
+export interface AgentDefaultsInput {
+  readonly harness?: Harness | undefined;
+  readonly provider?: ModelProviderRef | undefined;
+  readonly model?: string | undefined;
+  readonly thinking?: AgentThinking | undefined;
+}
+
+export interface ResolvedAgentDefaults {
+  readonly harness: Harness;
+  readonly provider: ModelProviderRef;
+  readonly model: string;
+  readonly thinking: AgentThinking;
+}
+
+export type AgentDefaultsResolver = (
+  input: AgentDefaultsInput,
+) => ResolvedAgentDefaults | Promise<ResolvedAgentDefaults>;
+
+export function createAgentDefaultsResolver(
+  agent: AgentInterModuleClient,
+  workspaceId: string | null,
+): AgentDefaultsResolver {
+  return async (config) =>
+    await agent.resolveAgentConfig({
+      workspaceId,
+      config: {
+        ...(config.harness === undefined ? {} : {harness: config.harness}),
+        ...(config.provider === undefined ? {} : {provider: config.provider}),
+        ...(config.model === undefined ? {} : {model: config.model}),
+        ...(config.thinking === undefined ? {} : {thinking: config.thinking}),
+      },
+    });
+}

package/src/core/agent-tool-capability-warning.test.ts

@@ -1,9 +1,39 @@
+import type {AnnotationsInterModuleClient} from '@shipfox/annotations-dto/inter-module';
 import type {JobLeaseTokenClaims} from '@shipfox/api-auth';
 import {sql} from 'drizzle-orm';
 import {db} from '#db/db.js';
-import {warnAgentToolCapabilityMismatchOnDispatch} from './agent-tool-capability-warning.js';
+import {runnersTestClient} from '#test/fixtures/runners-inter-module.js';
+import {warnAgentToolCapabilityMismatchOnDispatch as warnAgentToolCapabilityMismatchOnDispatchImpl} from './agent-tool-capability-warning.js';
 import type {Step} from './entities/step.js';
 
+async function warnAgentToolCapabilityMismatchOnDispatch(
+  params: Omit<
+    Parameters<typeof warnAgentToolCapabilityMismatchOnDispatchImpl>[0],
+    'annotations' | 'runners'
+  >,
+) {
+  return await warnAgentToolCapabilityMismatchOnDispatchImpl({
+    annotations: annotationsTestClient,
+    runners: runnersTestClient,
+    ...params,
+  });
+}
+
+const annotationBodiesByExecution = new Map<string, Map<string, string>>();
+
+const annotationsTestClient: AnnotationsInterModuleClient = {
+  replaceOrRemoveAnnotation(input) {
+    const annotations = annotationBodiesByExecution.get(input.jobExecutionId) ?? new Map();
+    annotationBodiesByExecution.set(input.jobExecutionId, annotations);
+    if (input.annotation.op === 'remove') {
+      annotations.delete(input.context);
+    } else {
+      annotations.set(input.context, input.annotation.body);
+    }
+    return Promise.resolve({});
+  },
+};
+
 function lease(params: Partial<JobLeaseTokenClaims> = {}): JobLeaseTokenClaims {
   const now = Math.floor(Date.now() / 1000);
   return {
@@ -97,16 +127,11 @@ async function insertRunnerSession(params: {
   `);
 }
 
-async function annotationsFor(
-  jobExecutionId: string,
-): Promise<Array<{context: string; body: string}>> {
-  const result = await db().execute<{context: string; body: string}>(sql`
-    SELECT context, body
-    FROM annotations_annotations
-    WHERE job_execution_id = ${jobExecutionId}
-    ORDER BY sequence
-  `);
-  return [...result.rows];
+function annotationsFor(jobExecutionId: string): Array<{context: string; body: string}> {
+  return Array.from(annotationBodiesByExecution.get(jobExecutionId) ?? [], ([context, body]) => ({
+    context,
+    body,
+  }));
 }
 
 describe('warnAgentToolCapabilityMismatchOnDispatch', () => {

package/src/core/agent-tool-capability-warning.ts

@@ -1,17 +1,15 @@
 import {
-  AnnotationBodyTooLargeError,
-  AnnotationCountLimitExceededError,
-  AnnotationTotalBytesLimitExceededError,
-  type WriteAnnotationsParams,
-  writeAnnotations,
-} from '@shipfox/annotations';
+  type AnnotationsInterModuleClient,
+  annotationsInterModuleContract,
+} from '@shipfox/annotations-dto/inter-module';
 import {
   harnessSchema,
   type MaterializedAgentStepConfigDto,
   materializedAgentStepConfigSchema,
 } from '@shipfox/api-agent-dto';
 import type {LeasedJobContext} from '@shipfox/api-auth-context';
-import {getEffectiveRunnerToolCapabilities, unadvertisedRunnerTools} from '@shipfox/api-runners';
+import type {RunnersInterModuleClient} from '@shipfox/api-runners-dto/inter-module';
+import {isInterModuleKnownError} from '@shipfox/inter-module';
 import {logger} from '@shipfox/node-opentelemetry';
 import {recordWorkflowAgentToolWarningFailed} from '#metrics/instance.js';
 import type {Step} from './entities/step.js';
@@ -22,6 +20,8 @@ type WarningFailureReason = 'budget' | 'lookup' | 'write';
 type WarningReason = 'known-absence' | 'harness-not-advertised' | 'unknown-or-stale';
 
 export async function warnAgentToolCapabilityMismatchOnDispatch(params: {
+  annotations: AnnotationsInterModuleClient;
+  runners: RunnersInterModuleClient;
   leaseIdentity: LeasedJobContext;
   step: Step;
 }): Promise<void> {
@@ -34,9 +34,11 @@ export async function warnAgentToolCapabilityMismatchOnDispatch(params: {
   const harness = harnessSchema.safeParse(config.harness);
   if (!harness.success) return;
 
-  let effective: Awaited<ReturnType<typeof getEffectiveRunnerToolCapabilities>>;
+  let effective: Awaited<
+    ReturnType<RunnersInterModuleClient['getEffectiveRunnerToolCapabilities']>
+  >;
   try {
-    effective = await getEffectiveRunnerToolCapabilities({
+    effective = await params.runners.getEffectiveRunnerToolCapabilities({
       runnerSessionId: params.leaseIdentity.runnerSessionId,
     });
   } catch (error) {
@@ -48,11 +50,8 @@ export async function warnAgentToolCapabilityMismatchOnDispatch(params: {
     return;
   }
 
-  const missing = unadvertisedRunnerTools({
-    harness: harness.data,
-    requestedTools,
-    capabilities: effective.capabilities,
-  });
+  const advertised = new Set(effective.capabilities.harnesses[harness.data]?.tools ?? []);
+  const missing = requestedTools.filter((tool) => !advertised.has(tool));
   const context = `agent-tool-capability:${params.step.id}`;
 
   const operation =
@@ -67,17 +66,18 @@ export async function warnAgentToolCapabilityMismatchOnDispatch(params: {
             missing,
             reason: warningReason({
               reportFresh: effective.reportFresh,
-              harnessKnown: effective.harnessKnown(harness.data),
+              harnessKnown: effective.capabilities.harnesses[harness.data] !== undefined,
             }),
           }),
         };
 
   try {
-    await writeAnnotations({
-      ...writeParamsFromLease(params.leaseIdentity),
+    await params.annotations.replaceOrRemoveAnnotation({
+      ...annotationTargetFromLease(params.leaseIdentity),
       originStepId: params.step.id,
       originStepAttempt: params.step.currentAttempt,
-      operations: [operation],
+      context,
+      annotation: operation.op === 'remove' ? {op: 'remove'} : operation,
     });
   } catch (error) {
     const reason = isAnnotationBudgetError(error) ? 'budget' : 'write';
@@ -103,7 +103,7 @@ export async function warnAgentToolCapabilityMismatchOnDispatch(params: {
         missing,
         reason: warningReason({
           reportFresh: effective.reportFresh,
-          harnessKnown: effective.harnessKnown(harness.data),
+          harnessKnown: effective.capabilities.harnesses[harness.data] !== undefined,
         }),
       },
       'Runner missing requested agent tools; dispatch is continuing',
@@ -173,9 +173,12 @@ function warningReason(params: {reportFresh: boolean; harnessKnown: boolean}): W
   return params.reportFresh ? 'harness-not-advertised' : 'unknown-or-stale';
 }
 
-function writeParamsFromLease(
+function annotationTargetFromLease(
   lease: LeasedJobContext,
-): Omit<WriteAnnotationsParams, 'originStepId' | 'originStepAttempt' | 'operations'> {
+): Omit<
+  Parameters<AnnotationsInterModuleClient['replaceOrRemoveAnnotation']>[0],
+  'originStepId' | 'originStepAttempt' | 'context' | 'annotation'
+> {
   return {
     workspaceId: lease.workspaceId,
     projectId: lease.projectId,
@@ -188,10 +191,9 @@ function writeParamsFromLease(
 }
 
 function isAnnotationBudgetError(error: unknown): boolean {
-  return (
-    error instanceof AnnotationBodyTooLargeError ||
-    error instanceof AnnotationCountLimitExceededError ||
-    error instanceof AnnotationTotalBytesLimitExceededError
+  return isInterModuleKnownError(
+    annotationsInterModuleContract.methods.replaceOrRemoveAnnotation,
+    error,
   );
 }
 

package/src/core/agent-tools.ts

@@ -2,28 +2,28 @@ import type {
   MaterializedAgentIntegrationConfigDto,
   MaterializedAgentIntegrationToolConfigDto,
 } from '@shipfox/api-agent-dto';
-import type {WorkflowModel} from '@shipfox/api-definitions';
+import type {WorkflowModel} from '@shipfox/api-definitions-dto';
 import type {
   AgentToolCatalogEntry,
   AgentToolCatalogMethod,
-  AgentToolCatalogs,
-  GetIntegrationConnectionByIdFn,
   IntegrationProviderKind,
-  LoadWorkspaceConnectionSnapshot,
-  WorkspaceConnectionSnapshot,
-} from '@shipfox/api-integration-core';
-import {getProjectById} from '@shipfox/api-projects';
+  IntegrationsModuleClient,
+} from '@shipfox/api-integration-core-dto';
+import type {ProjectsModuleClient} from '@shipfox/api-projects-dto';
 import {AgentIntegrationMaterializationError} from './errors.js';
 
 type WorkflowModelJob = WorkflowModel['jobs'][number];
 type WorkflowModelAgentStep = Extract<WorkflowModelJob['steps'][number], {kind: 'agent'}>;
 type WorkflowModelStepIntegration = NonNullable<WorkflowModelAgentStep['integrations']>[number];
-
-interface AgentToolMaterializationServices {
-  readonly catalogs: AgentToolCatalogs;
-  readonly loadWorkspaceConnectionSnapshot: LoadWorkspaceConnectionSnapshot;
-  readonly getIntegrationConnectionById: GetIntegrationConnectionByIdFn;
-}
+type AgentToolCatalogs = ReadonlyMap<IntegrationProviderKind, readonly AgentToolCatalogEntry[]>;
+type WorkspaceConnectionSnapshot = ReadonlyMap<
+  string,
+  {
+    id: string;
+    provider: IntegrationProviderKind;
+    capabilities: readonly ('source_control' | 'agent_tools')[];
+  }
+>;
 
 export interface AgentToolMaterializationContext {
   readonly catalogs: AgentToolCatalogs;
@@ -51,48 +51,45 @@ interface SelectedToolState {
   selectedStandalone: boolean;
 }
 
-let services: AgentToolMaterializationServices | undefined;
-
-export function setAgentToolMaterializationServices(
-  nextServices: AgentToolMaterializationServices,
-): void {
-  services = nextServices;
-}
-
-export function clearAgentToolMaterializationServices(): void {
-  services = undefined;
-}
-
 export async function loadAgentToolMaterializationContext(params: {
   readonly model: WorkflowModel | null;
   readonly workspaceId: string;
   readonly projectId: string;
+  readonly integrations?: IntegrationsModuleClient | undefined;
+  readonly projects?: ProjectsModuleClient | undefined;
   readonly jobs?: readonly WorkflowModelJob[] | undefined;
 }): Promise<AgentToolMaterializationContext | undefined> {
   if (!modelHasAgentStepIntegrations(params.model, params.jobs)) return undefined;
-  if (services === undefined) {
-    throw new AgentIntegrationMaterializationError('Agent tool materialization is not configured');
-  }
 
-  const project = await getProjectById(params.projectId);
-  if (project === undefined) {
+  if (params.projects === undefined) {
+    throw new AgentIntegrationMaterializationError('Project access is not configured');
+  }
+  const {project} = await params.projects.getProjectById({projectId: params.projectId});
+  if (project === null) {
     throw new AgentIntegrationMaterializationError(
       `Project ${params.projectId} was not found while materializing agent integrations`,
     );
   }
 
-  const [workspaceConnectionSnapshot, defaultConnection] = await Promise.all([
-    services.loadWorkspaceConnectionSnapshot(params.workspaceId),
-    services.getIntegrationConnectionById(project.sourceConnectionId),
-  ]);
-  if (defaultConnection === undefined) {
+  if (params.integrations === undefined) {
+    throw new AgentIntegrationMaterializationError('Agent tool materialization is not configured');
+  }
+  const context = await params.integrations.getAgentToolsContext({
+    workspaceId: params.workspaceId,
+    defaultConnectionId: project.sourceConnectionId,
+  });
+  const workspaceConnectionSnapshot = new Map(
+    context.workspaceConnections.map(({slug, ...connection}) => [slug, connection]),
+  );
+  const defaultConnection = context.defaultConnection;
+  if (defaultConnection === null) {
     throw new AgentIntegrationMaterializationError(
       `Source connection ${project.sourceConnectionId} was not found while materializing agent integrations`,
     );
   }
 
   return {
-    catalogs: services.catalogs,
+    catalogs: new Map(context.catalogs.map(({provider, tools}) => [provider, tools])),
     workspaceConnectionSnapshot,
     defaultConnection: {
       id: defaultConnection.id,

package/src/core/checkout.test.ts

@@ -1,5 +1,5 @@
-import type {CheckoutSpec, IntegrationSourceControlService} from '@shipfox/api-integration-core';
-import {getProjectById} from '@shipfox/api-projects';
+import type {IntegrationsModuleClient} from '@shipfox/api-integration-core-dto';
+import type {ProjectsModuleClient} from '@shipfox/api-projects-dto';
 import * as workflowRuns from '#db/workflow-runs.js';
 import {jobFactory} from '#test/factories/job.js';
 import {projectFactory} from '#test/factories/project.js';
@@ -10,16 +10,16 @@ import {
   WorkflowRunNotFoundError,
 } from './errors.js';
 
-vi.mock('@shipfox/api-projects', () => ({getProjectById: vi.fn()}));
-const mockGetProjectById = vi.mocked(getProjectById);
+const getProjectById = vi.fn();
+const projects = {getProjectById} as Pick<ProjectsModuleClient, 'getProjectById'>;
 
 describe('resolveCheckoutIntent', () => {
   it('resolves connection + repo from the project, using the project workspace', async () => {
     const project = projectFactory.build();
-    mockGetProjectById.mockResolvedValue(project);
+    getProjectById.mockResolvedValue({project});
     const job = await jobFactory.create({}, {transient: {projectId: project.id}});
 
-    const intent = await resolveCheckoutIntent(job.id);
+    const intent = await resolveCheckoutIntent(job.id, projects as ProjectsModuleClient);
 
     expect(intent).toEqual({
       workspaceId: project.workspaceId,
@@ -31,79 +31,92 @@ describe('resolveCheckoutIntent', () => {
   });
 
   it('throws JobNotFoundError for an unknown job', async () => {
-    const act = resolveCheckoutIntent(crypto.randomUUID());
+    const act = resolveCheckoutIntent(crypto.randomUUID(), projects as ProjectsModuleClient);
 
     await expect(act).rejects.toBeInstanceOf(JobNotFoundError);
   });
 
   it('resolves the checkout target while the parent job projection is still pending', async () => {
     const project = projectFactory.build();
-    mockGetProjectById.mockResolvedValue(project);
+    getProjectById.mockResolvedValue({project});
     const job = await jobFactory.create(
       {},
       {transient: {projectId: project.id, status: 'pending'}},
     );
 
-    const intent = await resolveCheckoutIntent(job.id);
+    const intent = await resolveCheckoutIntent(job.id, projects as ProjectsModuleClient);
 
     expect(intent.connectionId).toBe(project.sourceConnectionId);
   });
 
   it('throws WorkflowRunNotFoundError when the run is missing', async () => {
     const project = projectFactory.build();
-    mockGetProjectById.mockResolvedValue(project);
+    getProjectById.mockResolvedValue({project});
     const job = await jobFactory.create({}, {transient: {projectId: project.id}});
     vi.spyOn(workflowRuns, 'getWorkflowRunByAttemptId').mockResolvedValue(undefined);
 
-    const act = resolveCheckoutIntent(job.id);
+    const act = resolveCheckoutIntent(job.id, projects as ProjectsModuleClient);
 
     await expect(act).rejects.toBeInstanceOf(WorkflowRunNotFoundError);
   });
 
   it('throws CheckoutIntentUnresolvedError when the project is missing', async () => {
     const project = projectFactory.build();
-    mockGetProjectById.mockResolvedValue(undefined);
+    getProjectById.mockResolvedValue({project: null});
     const job = await jobFactory.create({}, {transient: {projectId: project.id}});
 
-    const act = resolveCheckoutIntent(job.id);
+    const act = resolveCheckoutIntent(job.id, projects as ProjectsModuleClient);
 
     await expect(act).rejects.toBeInstanceOf(CheckoutIntentUnresolvedError);
   });
 });
 
 describe('createJobCheckoutSpec', () => {
-  it('passes the resolved intent and an undefined ref to the service', async () => {
+  it('passes the resolved intent without a ref to the service', async () => {
     const project = projectFactory.build();
-    mockGetProjectById.mockResolvedValue(project);
+    getProjectById.mockResolvedValue({project});
     const job = await jobFactory.create({}, {transient: {projectId: project.id}});
-    const spec: CheckoutSpec = {repositoryUrl: 'https://github.com/acme/repo.git', ref: 'main'};
+    const spec = {repositoryUrl: 'https://github.com/acme/repo.git', ref: 'main'};
     const createCheckoutSpec = vi.fn().mockResolvedValue(spec);
-    const sourceControl = {createCheckoutSpec} as unknown as IntegrationSourceControlService;
-
-    const result = await createJobCheckoutSpec({jobId: job.id, sourceControl});
+    const integrations = {createCheckoutSpec} as Pick<
+      IntegrationsModuleClient,
+      'createCheckoutSpec'
+    >;
+
+    const result = await createJobCheckoutSpec({
+      jobId: job.id,
+      integrations: integrations as IntegrationsModuleClient,
+      projects: projects as ProjectsModuleClient,
+    });
 
     expect(result).toEqual({spec, persistCredentials: true});
     expect(createCheckoutSpec).toHaveBeenCalledWith({
       workspaceId: project.workspaceId,
       connectionId: project.sourceConnectionId,
       externalRepositoryId: project.sourceExternalRepositoryId,
-      ref: undefined,
       permissions: {contents: 'read'},
     });
   });
 
   it('passes requested write contents permission to the service', async () => {
     const project = projectFactory.build();
-    mockGetProjectById.mockResolvedValue(project);
+    getProjectById.mockResolvedValue({project});
     const job = await jobFactory.create(
       {},
       {transient: {projectId: project.id, checkout: {permissions: {contents: 'write'}}}},
     );
-    const spec: CheckoutSpec = {repositoryUrl: 'https://github.com/acme/repo.git', ref: 'main'};
+    const spec = {repositoryUrl: 'https://github.com/acme/repo.git', ref: 'main'};
     const createCheckoutSpec = vi.fn().mockResolvedValue(spec);
-    const sourceControl = {createCheckoutSpec} as unknown as IntegrationSourceControlService;
-
-    await createJobCheckoutSpec({jobId: job.id, sourceControl});
+    const integrations = {createCheckoutSpec} as Pick<
+      IntegrationsModuleClient,
+      'createCheckoutSpec'
+    >;
+
+    await createJobCheckoutSpec({
+      jobId: job.id,
+      integrations: integrations as IntegrationsModuleClient,
+      projects: projects as ProjectsModuleClient,
+    });
 
     expect(createCheckoutSpec).toHaveBeenCalledWith(
       expect.objectContaining({permissions: {contents: 'write'}}),