@shipfox/api-runners-dto 5.0.0 → 7.0.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-runners-dto",
   "license": "MIT",
-  "version": "5.0.0",
+  "version": "7.0.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -19,10 +19,15 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./inter-module": {
+      "types": "./dist/inter-module.d.ts",
+      "default": "./dist/inter-module.js"
     }
   },
   "dependencies": {
     "zod": "^4.4.3",
+    "@shipfox/inter-module": "0.2.0",
     "@shipfox/runner-labels": "0.1.1"
   },
   "devDependencies": {

package/src/index.ts

@@ -3,20 +3,29 @@ export {
   type ActiveRunnerDto,
   type ActiveRunnerStateDto,
   type ActiveRunnersResponseDto,
+  type AssignRunnerInstancesBodyDto,
+  type AssignRunnerInstancesResponseDto,
   activeProvisionerDtoSchema,
   activeRunnerDtoSchema,
   activeRunnerStateSchema,
   activeRunnersResponseSchema,
+  assignRunnerInstancesBodySchema,
+  assignRunnerInstancesResponseSchema,
+  attachRunnerControlProviderIdBodySchema,
   type ClaimedJobResponseDto,
   type CreateManualRegistrationTokenBodyDto,
   type CreateManualRegistrationTokenResponseDto,
   type CreateProvisionerTokenBodyDto,
   type CreateProvisionerTokenResponseDto,
+  type CreateRunnerInstancesBodyDto,
+  type CreateRunnerInstancesResponseDto,
   claimedJobResponseSchema,
   createManualRegistrationTokenBodySchema,
   createManualRegistrationTokenResponseSchema,
   createProvisionerTokenBodySchema,
   createProvisionerTokenResponseSchema,
+  createRunnerInstancesBodySchema,
+  createRunnerInstancesResponseSchema,
   type DemandStatDto,
   demandStatSchema,
   type HeartbeatBodyDto,
@@ -30,65 +39,64 @@ export {
   listManualRegistrationTokensResponseSchema,
   listProvisionerTokensResponseSchema,
   MAX_MANUAL_REGISTRATION_TOKEN_TTL_SECONDS,
-  MAX_OBSERVED_PROVISIONED_RUNNER_ID_LENGTH,
+  MAX_OBSERVED_PROVIDER_RUNNER_ID_LENGTH,
   MAX_PROVIDER_KIND_LENGTH,
-  MAX_PROVISIONED_RUNNER_REASON_LENGTH,
-  MAX_PROVISIONED_RUNNER_REPORT_EVENTS,
+  MAX_PROVIDER_RUNNER_REASON_LENGTH,
+  MAX_PROVIDER_RUNNER_REPORT_EVENTS,
   MAX_PROVISIONER_TOKEN_TTL_SECONDS,
   MAX_RECONCILE_OBSERVED_RUNNERS,
   type ManualRegistrationTokenDto,
-  type MintedRegistrationTokenDto,
-  type MintRegistrationTokensBatchBodyDto,
-  type MintRegistrationTokensBatchResponseDto,
-  type MintRegistrationTokensProvisionedRunnerDto,
   manualRegistrationTokenDtoSchema,
-  mintedRegistrationTokenSchema,
-  mintRegistrationTokensBatchBodySchema,
-  mintRegistrationTokensBatchResponseSchema,
-  mintRegistrationTokensProvisionedRunnerSchema,
   type PollDemandBodyDto,
   type PollDemandResponseDto,
   type PollDemandTemplateDto,
-  type ProvisionedRunnerReportEventDto,
-  type ProvisionedRunnerStateDto,
   type ProvisionerIdentityResponseDto,
   type ProvisionerTokenDto,
   pollDemandBodySchema,
   pollDemandResponseSchema,
   pollDemandTemplateSchema,
   providerKindSchema,
-  provisionedRunnerReportEventSchema,
-  provisionedRunnerStateSchema,
+  providerRunnerReportEventSchema,
+  providerRunnerStateSchema,
   provisionerIdentityResponseSchema,
   provisionerTokenDtoSchema,
-  REGISTRATION_TOKEN_BATCH_HARD_MAX,
   type ReconcileDesiredIntentDto,
   type ReconciledBoundJobDto,
-  type ReconciledProvisionedRunnerDto,
-  type ReconcileProvisionedRunnersBodyDto,
-  type ReconcileProvisionedRunnersResponseDto,
+  type ReconciledRunnerInstanceDto,
+  type ReconcileRunnerInstancesBodyDto,
+  type ReconcileRunnerInstancesResponseDto,
   type RegisterRunnerBodyDto,
   type RegisterRunnerResponseDto,
-  type ReportProvisionedRunnersBodyDto,
-  type ReportProvisionedRunnersResponseDto,
+  type ReportRunnerInstancesBodyDto,
+  type ReportRunnerInstancesResponseDto,
   type ReservationGrantDto,
   type RevokeManualRegistrationTokenResponseDto,
   type RevokeProvisionerTokenResponseDto,
   RUNNER_SESSION_EXHAUSTED_CODE,
+  type RunnerBootstrapExchangeBodyDto,
+  type RunnerBootstrapExchangeResponseDto,
+  type RunnerEnrollmentBodyDto,
   type RunnerHarnessToolCapabilitiesDto,
+  type RunnerInstanceReportEventDto,
+  type RunnerInstanceStateDto,
   type RunnerToolCapabilitiesDto,
   reconcileDesiredIntentSchema,
   reconciledBoundJobSchema,
-  reconciledProvisionedRunnerSchema,
-  reconcileProvisionedRunnersBodySchema,
-  reconcileProvisionedRunnersResponseSchema,
+  reconciledRunnerInstanceSchema,
+  reconcileRunnerInstancesBodySchema,
+  reconcileRunnerInstancesResponseSchema,
   registerRunnerBodySchema,
   registerRunnerResponseSchema,
-  reportProvisionedRunnersBodySchema,
-  reportProvisionedRunnersResponseSchema,
+  reportRunnerInstancesBodySchema,
+  reportRunnerInstancesResponseSchema,
   reservationGrantSchema,
   revokeManualRegistrationTokenResponseSchema,
   revokeProvisionerTokenResponseSchema,
+  runnerAssignmentPollResponseSchema,
+  runnerBootstrapExchangeBodySchema,
+  runnerBootstrapExchangeResponseSchema,
+  runnerControlHeartbeatResponseSchema,
+  runnerEnrollmentBodySchema,
   runnerHarnessToolCapabilitiesSchema,
   runnerToolCapabilitiesSchema,
 } from '#schemas/index.js';

package/src/inter-module.test.ts

@@ -0,0 +1,40 @@
+import {runnersInterModuleContract} from './inter-module.js';
+
+const id = '00000000-0000-4000-8000-000000000001';
+
+describe('runnersInterModuleContract', () => {
+  test('accepts stable job-execution identities for idempotent commands', () => {
+    const input = runnersInterModuleContract.methods.enqueueJobExecution.input.parse({
+      workspaceId: id,
+      workflowRunId: id,
+      workflowRunAttemptId: id,
+      jobId: id,
+      jobExecutionId: id,
+      projectId: id,
+      requiredLabels: ['linux'],
+    });
+
+    expect(input.jobExecutionId).toBe(id);
+  });
+
+  test('exposes bounded JSON capability results', () => {
+    const result =
+      runnersInterModuleContract.methods.getEffectiveRunnerToolCapabilities.output.parse({
+        capabilities: {harnesses: {pi: {tools: ['read']}}},
+        reportFresh: true,
+      });
+
+    expect(result).toEqual({
+      capabilities: {harnesses: {pi: {tools: ['read']}}},
+      reportFresh: true,
+    });
+  });
+
+  test('defines the scheduling validation failure', () => {
+    const details = runnersInterModuleContract.methods.enqueueJobExecution.errors[
+      'empty-required-labels'
+    ].parse({});
+
+    expect(details).toEqual({});
+  });
+});

package/src/inter-module.ts

@@ -0,0 +1,51 @@
+import {defineInterModuleContract, type InterModuleClient} from '@shipfox/inter-module';
+import {z} from 'zod';
+import {runnerToolCapabilitiesSchema} from '#schemas/tool-capabilities.js';
+
+const idSchema = z.string().uuid();
+
+export const runnersInterModuleContract = defineInterModuleContract({
+  module: 'runners',
+  methods: {
+    enqueueJobExecution: {
+      input: z.object({
+        workspaceId: idSchema,
+        workflowRunId: idSchema,
+        workflowRunAttemptId: idSchema,
+        jobId: idSchema,
+        jobExecutionId: idSchema,
+        projectId: idSchema,
+        requiredLabels: z.array(z.string()),
+      }),
+      output: z.object({}),
+      errors: {
+        'empty-required-labels': z.object({}),
+      },
+    },
+    releaseJobExecution: {
+      input: z.object({jobExecutionId: idSchema}),
+      output: z.object({}),
+    },
+    cancelJobs: {
+      input: z.object({jobIds: z.array(idSchema)}),
+      output: z.object({}),
+    },
+    getLeaseState: {
+      input: z.object({
+        jobId: idSchema,
+        jobExecutionId: idSchema,
+        runnerSessionId: idSchema,
+      }),
+      output: z.object({active: z.boolean()}),
+    },
+    getEffectiveRunnerToolCapabilities: {
+      input: z.object({runnerSessionId: idSchema}),
+      output: z.object({
+        capabilities: runnerToolCapabilitiesSchema,
+        reportFresh: z.boolean(),
+      }),
+    },
+  },
+});
+
+export type RunnersInterModuleClient = InterModuleClient<typeof runnersInterModuleContract>;

package/src/schemas/assign-runner-instances.test.ts

@@ -0,0 +1,27 @@
+import {assignRunnerInstancesBodySchema} from './assign-runner-instances.js';
+
+describe('assignRunnerInstancesBodySchema', () => {
+  it('accepts a reservation and unique runner instances', () => {
+    const result = assignRunnerInstancesBodySchema.safeParse({
+      reservation_id: '018f0d4c-5f42-7b7e-9d9b-4a7d8e6f0001',
+      runner_instance_ids: [
+        '018f0d4c-5f42-7b7e-9d9b-4a7d8e6f0002',
+        '018f0d4c-5f42-7b7e-9d9b-4a7d8e6f0003',
+      ],
+    });
+
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects duplicate runner instances', () => {
+    const result = assignRunnerInstancesBodySchema.safeParse({
+      reservation_id: '018f0d4c-5f42-7b7e-9d9b-4a7d8e6f0001',
+      runner_instance_ids: [
+        '018f0d4c-5f42-7b7e-9d9b-4a7d8e6f0002',
+        '018f0d4c-5f42-7b7e-9d9b-4a7d8e6f0002',
+      ],
+    });
+
+    expect(result.success).toBe(false);
+  });
+});

package/src/schemas/assign-runner-instances.ts

@@ -0,0 +1,19 @@
+import {z} from 'zod';
+
+export const assignRunnerInstancesBodySchema = z
+  .object({
+    reservation_id: z.string().uuid(),
+    runner_instance_ids: z.array(z.string().uuid()).min(1).max(1000),
+  })
+  .strict()
+  .refine((body) => new Set(body.runner_instance_ids).size === body.runner_instance_ids.length, {
+    message: 'runner_instance_ids values must be unique',
+    path: ['runner_instance_ids'],
+  });
+
+export const assignRunnerInstancesResponseSchema = z.object({
+  runner_instance_ids: z.array(z.string().uuid()),
+});
+
+export type AssignRunnerInstancesBodyDto = z.infer<typeof assignRunnerInstancesBodySchema>;
+export type AssignRunnerInstancesResponseDto = z.infer<typeof assignRunnerInstancesResponseSchema>;

package/src/schemas/index.ts

@@ -1,3 +1,9 @@
+export {
+  type AssignRunnerInstancesBodyDto,
+  type AssignRunnerInstancesResponseDto,
+  assignRunnerInstancesBodySchema,
+  assignRunnerInstancesResponseSchema,
+} from './assign-runner-instances.js';
 export {
   type ClaimedJobResponseDto,
   claimedJobResponseSchema,
@@ -28,17 +34,6 @@ export {
   type RevokeManualRegistrationTokenResponseDto,
   revokeManualRegistrationTokenResponseSchema,
 } from './manual-registration-token.js';
-export {
-  type MintedRegistrationTokenDto,
-  type MintRegistrationTokensBatchBodyDto,
-  type MintRegistrationTokensBatchResponseDto,
-  type MintRegistrationTokensProvisionedRunnerDto,
-  mintedRegistrationTokenSchema,
-  mintRegistrationTokensBatchBodySchema,
-  mintRegistrationTokensBatchResponseSchema,
-  mintRegistrationTokensProvisionedRunnerSchema,
-  REGISTRATION_TOKEN_BATCH_HARD_MAX,
-} from './mint-registration-tokens.js';
 export {
   type DemandStatDto,
   demandStatSchema,
@@ -67,19 +62,19 @@ export {
   revokeProvisionerTokenResponseSchema,
 } from './provisioner-token.js';
 export {
-  MAX_OBSERVED_PROVISIONED_RUNNER_ID_LENGTH,
+  MAX_OBSERVED_PROVIDER_RUNNER_ID_LENGTH,
   MAX_RECONCILE_OBSERVED_RUNNERS,
   type ReconcileDesiredIntentDto,
   type ReconciledBoundJobDto,
-  type ReconciledProvisionedRunnerDto,
-  type ReconcileProvisionedRunnersBodyDto,
-  type ReconcileProvisionedRunnersResponseDto,
+  type ReconciledRunnerInstanceDto,
+  type ReconcileRunnerInstancesBodyDto,
+  type ReconcileRunnerInstancesResponseDto,
   reconcileDesiredIntentSchema,
   reconciledBoundJobSchema,
-  reconciledProvisionedRunnerSchema,
-  reconcileProvisionedRunnersBodySchema,
-  reconcileProvisionedRunnersResponseSchema,
-} from './reconcile-provisioned-runners.js';
+  reconciledRunnerInstanceSchema,
+  reconcileRunnerInstancesBodySchema,
+  reconcileRunnerInstancesResponseSchema,
+} from './reconcile-runner-instances.js';
 export {
   type RegisterRunnerBodyDto,
   type RegisterRunnerResponseDto,
@@ -95,18 +90,33 @@ export {
   activeRunnerStateSchema,
   activeRunnersResponseSchema,
   MAX_PROVIDER_KIND_LENGTH,
-  MAX_PROVISIONED_RUNNER_REASON_LENGTH,
-  MAX_PROVISIONED_RUNNER_REPORT_EVENTS,
-  type ProvisionedRunnerReportEventDto,
-  type ProvisionedRunnerStateDto,
+  MAX_PROVIDER_RUNNER_REASON_LENGTH,
+  MAX_PROVIDER_RUNNER_REPORT_EVENTS,
   providerKindSchema,
-  provisionedRunnerReportEventSchema,
-  provisionedRunnerStateSchema,
-  type ReportProvisionedRunnersBodyDto,
-  type ReportProvisionedRunnersResponseDto,
-  reportProvisionedRunnersBodySchema,
-  reportProvisionedRunnersResponseSchema,
-} from './report-provisioned-runners.js';
+  providerRunnerReportEventSchema,
+  providerRunnerStateSchema,
+  type ReportRunnerInstancesBodyDto,
+  type ReportRunnerInstancesResponseDto,
+  type RunnerInstanceReportEventDto,
+  type RunnerInstanceStateDto,
+  reportRunnerInstancesBodySchema,
+  reportRunnerInstancesResponseSchema,
+} from './report-runner-instances.js';
+export {
+  attachRunnerControlProviderIdBodySchema,
+  type CreateRunnerInstancesBodyDto,
+  type CreateRunnerInstancesResponseDto,
+  createRunnerInstancesBodySchema,
+  createRunnerInstancesResponseSchema,
+  type RunnerBootstrapExchangeBodyDto,
+  type RunnerBootstrapExchangeResponseDto,
+  type RunnerEnrollmentBodyDto,
+  runnerAssignmentPollResponseSchema,
+  runnerBootstrapExchangeBodySchema,
+  runnerBootstrapExchangeResponseSchema,
+  runnerControlHeartbeatResponseSchema,
+  runnerEnrollmentBodySchema,
+} from './runner-enrollment.js';
 export {
   type RunnerHarnessToolCapabilitiesDto,
   type RunnerToolCapabilitiesDto,

package/src/schemas/poll-demand.test.ts

@@ -19,7 +19,7 @@ describe('pollDemandResponseSchema', () => {
           expires_at: 'not-a-date',
         },
       ],
-      terminate_provisioned_runner_ids: [],
+      terminate_provider_runner_ids: [],
     });
 
     expect(result.success).toBe(false);

package/src/schemas/poll-demand.ts

@@ -13,10 +13,11 @@ export const pollDemandTemplateSchema = z.object({
 export const pollDemandBodySchema = z.object({
   wait_seconds: z.number().int().min(0).optional(),
   max_reservations: z.number().int().min(0).max(1000),
-  templates: z.array(pollDemandTemplateSchema).min(1).max(100),
+  templates: z.array(pollDemandTemplateSchema).max(100),
 });
 
 export const demandStatSchema = z.object({
+  workspace_id: z.string().uuid().optional(),
   labels: z.array(z.string()),
   queued: z.number().int().min(0),
   reserved: z
@@ -31,6 +32,7 @@ export const demandStatSchema = z.object({
 
 export const reservationGrantSchema = z.object({
   reservation_id: z.string().uuid(),
+  workspace_id: z.string().uuid().optional(),
   labels: z.array(z.string()),
   count: z.number().int().positive(),
   expires_at: z.string().datetime(),
@@ -39,7 +41,7 @@ export const reservationGrantSchema = z.object({
 export const pollDemandResponseSchema = z.object({
   stats: z.array(demandStatSchema),
   reservations: z.array(reservationGrantSchema),
-  terminate_provisioned_runner_ids: z.array(z.string()),
+  terminate_provider_runner_ids: z.array(z.string()),
 });
 
 export type PollDemandTemplateDto = z.infer<typeof pollDemandTemplateSchema>;

package/src/schemas/provisioner-token.test.ts

@@ -28,6 +28,7 @@ describe('provisioner token schemas', () => {
   it('parses provisioner identity responses', () => {
     const identity = {
       id: crypto.randomUUID(),
+      scope: 'workspace',
       workspace_id: crypto.randomUUID(),
     };
 
@@ -35,4 +36,12 @@ describe('provisioner token schemas', () => {
 
     expect(result).toEqual(identity);
   });
+
+  it('parses installation provisioner identities without a workspace', () => {
+    const identity = {id: crypto.randomUUID(), scope: 'installation'};
+
+    const result = provisionerIdentityResponseSchema.parse(identity);
+
+    expect(result).toEqual(identity);
+  });
 });

package/src/schemas/provisioner-token.ts

@@ -22,6 +22,7 @@ export const createProvisionerTokenResponseSchema = z.object({
   last_seen_at: z.string().nullable(),
   created_at: z.string(),
   updated_at: z.string(),
+  scope: z.literal('workspace'),
 });
 
 export type CreateProvisionerTokenResponseDto = z.infer<
@@ -40,6 +41,7 @@ export const provisionerTokenDtoSchema = z.object({
   last_seen_at: z.string().nullable(),
   created_at: z.string(),
   updated_at: z.string(),
+  scope: z.literal('workspace'),
 });
 
 export type ProvisionerTokenDto = z.infer<typeof provisionerTokenDtoSchema>;
@@ -56,9 +58,9 @@ export type RevokeProvisionerTokenResponseDto = z.infer<
   typeof revokeProvisionerTokenResponseSchema
 >;
 
-export const provisionerIdentityResponseSchema = z.object({
-  id: z.string().uuid(),
-  workspace_id: z.string().uuid(),
-});
+export const provisionerIdentityResponseSchema = z.discriminatedUnion('scope', [
+  z.object({id: z.string().uuid(), scope: z.literal('workspace'), workspace_id: z.string().uuid()}),
+  z.object({id: z.string().uuid(), scope: z.literal('installation')}),
+]);
 
 export type ProvisionerIdentityResponseDto = z.infer<typeof provisionerIdentityResponseSchema>;

package/src/schemas/{reconcile-provisioned-runners.test.ts → reconcile-runner-instances.test.ts}

@@ -1,30 +1,30 @@
 import {
-  MAX_OBSERVED_PROVISIONED_RUNNER_ID_LENGTH,
+  MAX_OBSERVED_PROVIDER_RUNNER_ID_LENGTH,
   MAX_RECONCILE_OBSERVED_RUNNERS,
-  reconcileProvisionedRunnersBodySchema,
-  reconcileProvisionedRunnersResponseSchema,
-} from './reconcile-provisioned-runners.js';
+  reconcileRunnerInstancesBodySchema,
+  reconcileRunnerInstancesResponseSchema,
+} from './reconcile-runner-instances.js';
 
-describe('reconcileProvisionedRunnersBodySchema', () => {
+describe('reconcileRunnerInstancesBodySchema', () => {
   it('accepts observed provisioned runner ids', () => {
-    const result = reconcileProvisionedRunnersBodySchema.safeParse({
-      observed_provisioned_runner_ids: ['01JPROVISIONEDRUNNER000001'],
+    const result = reconcileRunnerInstancesBodySchema.safeParse({
+      observed_provider_runner_ids: ['01JPROVISIONEDRUNNER000001'],
     });
 
     expect(result.success).toBe(true);
   });
 
   it('accepts an empty observed set', () => {
-    const result = reconcileProvisionedRunnersBodySchema.safeParse({
-      observed_provisioned_runner_ids: [],
+    const result = reconcileRunnerInstancesBodySchema.safeParse({
+      observed_provider_runner_ids: [],
     });
 
     expect(result.success).toBe(true);
   });
 
   it('rejects observed sets above the reconcile limit', () => {
-    const result = reconcileProvisionedRunnersBodySchema.safeParse({
-      observed_provisioned_runner_ids: Array.from(
+    const result = reconcileRunnerInstancesBodySchema.safeParse({
+      observed_provider_runner_ids: Array.from(
         {length: MAX_RECONCILE_OBSERVED_RUNNERS + 1},
         (_, index) => `runner-${index}`,
       ),
@@ -34,24 +34,24 @@ describe('reconcileProvisionedRunnersBodySchema', () => {
   });
 
   it('rejects over-length provisioned runner ids', () => {
-    const result = reconcileProvisionedRunnersBodySchema.safeParse({
-      observed_provisioned_runner_ids: ['a'.repeat(MAX_OBSERVED_PROVISIONED_RUNNER_ID_LENGTH + 1)],
+    const result = reconcileRunnerInstancesBodySchema.safeParse({
+      observed_provider_runner_ids: ['a'.repeat(MAX_OBSERVED_PROVIDER_RUNNER_ID_LENGTH + 1)],
     });
 
     expect(result.success).toBe(false);
   });
 
   it('rejects duplicate provisioned runner ids', () => {
-    const result = reconcileProvisionedRunnersBodySchema.safeParse({
-      observed_provisioned_runner_ids: ['provisioned-runner-1', 'provisioned-runner-1'],
+    const result = reconcileRunnerInstancesBodySchema.safeParse({
+      observed_provider_runner_ids: ['provisioned-runner-1', 'provisioned-runner-1'],
     });
 
     expect(result.success).toBe(false);
   });
 
   it('rejects extra fields', () => {
-    const result = reconcileProvisionedRunnersBodySchema.safeParse({
-      observed_provisioned_runner_ids: [],
+    const result = reconcileRunnerInstancesBodySchema.safeParse({
+      observed_provider_runner_ids: [],
       provisioner_hostname: 'worker-1',
     });
 
@@ -59,12 +59,12 @@ describe('reconcileProvisionedRunnersBodySchema', () => {
   });
 });
 
-describe('reconcileProvisionedRunnersResponseSchema', () => {
+describe('reconcileRunnerInstancesResponseSchema', () => {
   it('parses reconciled provisioned runner responses', () => {
-    const result = reconcileProvisionedRunnersResponseSchema.safeParse({
+    const result = reconcileRunnerInstancesResponseSchema.safeParse({
       runners: [
         {
-          provisioned_runner_id: 'provisioned-runner-1',
+          provider_runner_id: 'provisioned-runner-1',
           state: 'running',
           reservation_id: crypto.randomUUID(),
           runner_session_id: crypto.randomUUID(),
@@ -77,7 +77,7 @@ describe('reconcileProvisionedRunnersResponseSchema', () => {
           desired_intent: 'keep',
         },
       ],
-      terminated_absent_provisioned_runner_ids: ['provisioned-runner-2'],
+      terminated_absent_provider_runner_ids: ['provisioned-runner-2'],
     });
 
     expect(result.success).toBe(true);

package/src/schemas/reconcile-runner-instances.ts

@@ -0,0 +1,58 @@
+import {z} from 'zod';
+import {providerRunnerStateSchema} from './report-runner-instances.js';
+
+export const MAX_RECONCILE_OBSERVED_RUNNERS = 5000;
+export const MAX_OBSERVED_PROVIDER_RUNNER_ID_LENGTH = 255;
+
+export const reconcileRunnerInstancesBodySchema = z
+  .object({
+    observed_provider_runner_ids: z
+      .array(z.string().min(1).max(MAX_OBSERVED_PROVIDER_RUNNER_ID_LENGTH))
+      .max(MAX_RECONCILE_OBSERVED_RUNNERS),
+  })
+  .strict()
+  .refine(
+    (body) =>
+      new Set(body.observed_provider_runner_ids).size === body.observed_provider_runner_ids.length,
+    {
+      message: 'observed_provider_runner_ids values must be unique',
+      path: ['observed_provider_runner_ids'],
+    },
+  );
+
+export const reconcileDesiredIntentSchema = z.enum(['keep', 'terminate']);
+
+export const reconciledBoundJobSchema = z
+  .object({
+    job_id: z.string().uuid(),
+    workflow_run_attempt_id: z.string().uuid(),
+    last_heartbeat_at: z.string().datetime(),
+    cancellation_requested_at: z.string().datetime().nullable(),
+  })
+  .strict();
+
+export const reconciledRunnerInstanceSchema = z
+  .object({
+    provider_runner_id: z.string(),
+    state: providerRunnerStateSchema.nullable(),
+    reservation_id: z.string().uuid().nullable(),
+    runner_session_id: z.string().uuid().nullable(),
+    bound_job: reconciledBoundJobSchema.nullable(),
+    desired_intent: reconcileDesiredIntentSchema,
+  })
+  .strict();
+
+export const reconcileRunnerInstancesResponseSchema = z
+  .object({
+    runners: z.array(reconciledRunnerInstanceSchema),
+    terminated_absent_provider_runner_ids: z.array(z.string()),
+  })
+  .strict();
+
+export type ReconcileRunnerInstancesBodyDto = z.infer<typeof reconcileRunnerInstancesBodySchema>;
+export type ReconcileDesiredIntentDto = z.infer<typeof reconcileDesiredIntentSchema>;
+export type ReconciledBoundJobDto = z.infer<typeof reconciledBoundJobSchema>;
+export type ReconciledRunnerInstanceDto = z.infer<typeof reconciledRunnerInstanceSchema>;
+export type ReconcileRunnerInstancesResponseDto = z.infer<
+  typeof reconcileRunnerInstancesResponseSchema
+>;

package/src/schemas/register.ts

@@ -20,7 +20,7 @@ export const registerRunnerBodySchema = z.object({
 export const registerRunnerResponseSchema = z.object({
   session_token: z.string().min(1),
   session_id: z.string().uuid(),
-  mode: z.enum(['manual', 'ephemeral']),
+  mode: z.enum(['manual', 'ephemeral', 'activation']),
   max_claims: z.number().int().positive().nullable(),
 });