@shipfox/api-workflows 8.0.0 → 9.0.2

package/src/db/workflow-runs/run-create.test.ts

@@ -1,15 +1,12 @@
-import {normalizeWorkflowDocument as normalizeWorkflowDocumentImpl} from '@shipfox/api-definitions';
 import {WORKFLOWS_WORKFLOW_RUN_ATTEMPT_CREATED} from '@shipfox/api-workflows-dto';
 import {and, eq, sql} from 'drizzle-orm';
 import type {AgentDefaultsResolver} from '#core/agent-defaults.js';
 import {InterpolationUnresolvableError} from '#core/errors.js';
 import {nextStepForJob, recordStepResult} from '#core/job-execution.js';
-import {
-  agentValidationCatalog,
-  resolveTestAgentDefaults,
-} from '#test/fixtures/agent-inter-module.js';
+import {resolveTestAgentDefaults} from '#test/fixtures/agent-inter-module.js';
 import {createTestSecretsClient} from '#test/fixtures/secrets-inter-module.js';
 import {buildModel, expression, shellRef, template} from '#test/helpers/workflow-runs.js';
+import {workflowModel} from '#test/index.js';
 import {db} from '../db.js';
 import {workflowsOutbox} from '../schema/outbox.js';
 import {workflowRuns} from '../schema/workflow-runs.js';
@@ -26,12 +23,6 @@ import {
   updateJobExecutionStatus,
 } from '../workflow-runs.js';
 
-function normalizeWorkflowDocument(
-  document: Parameters<typeof normalizeWorkflowDocumentImpl>[0],
-): ReturnType<typeof normalizeWorkflowDocumentImpl> {
-  return normalizeWorkflowDocumentImpl(document, {agentValidationCatalog});
-}
-
 describe('workflow run queries', () => {
   let workspaceId: string;
   let projectId: string;
@@ -339,7 +330,7 @@ describe('workflow run queries', () => {
       const displayNameSource = ['Review batch $', '{{ execution.index }}'].join('');
       const stepNameSource = ['Review $', '{{ execution.index }}'].join('');
       const promptSource = ['Review $', '{{ execution.events[0].data.body }}'].join('');
-      const model = normalizeWorkflowDocument({
+      const model = workflowModel({
         name: 'Listening workflow',
         runner: 'ubuntu-latest',
         jobs: {
@@ -348,10 +339,10 @@ describe('workflow run queries', () => {
             listening: {
               on: [{source: 'github', event: 'pull_request_review'}],
               until: [{source: 'github', event: 'pull_request'}],
-              timeout: '30d',
-              max_executions: 3,
-              batch: {debounce: '5s', max_size: 10, max_wait: '1h'},
-              on_resolve: 'cancel',
+              timeoutMs: 30 * 24 * 60 * 60 * 1000,
+              maxExecutions: 3,
+              batch: {debounceMs: 5000, maxSize: 10, maxWaitMs: 60 * 60 * 1000},
+              onResolve: 'cancel',
             },
             steps: [{name: stepNameSource, prompt: promptSource}],
           },
@@ -409,7 +400,7 @@ describe('workflow run queries', () => {
     test('persists the listening workflow model on the run attempt', async () => {
       const displayNameSource = ['Review batch $', '{{ execution.index }}'].join('');
       const promptSource = ['Review $', '{{ execution.events[0].data.body }}'].join('');
-      const model = normalizeWorkflowDocument({
+      const model = workflowModel({
         name: 'Listening workflow',
         runner: 'ubuntu-latest',
         jobs: {
@@ -418,10 +409,10 @@ describe('workflow run queries', () => {
             listening: {
               on: [{source: 'github', event: 'pull_request_review'}],
               until: [{source: 'github', event: 'pull_request'}],
-              timeout: '30d',
-              max_executions: 3,
-              batch: {debounce: '5s', max_size: 10, max_wait: '1h'},
-              on_resolve: 'cancel',
+              timeoutMs: 30 * 24 * 60 * 60 * 1000,
+              maxExecutions: 3,
+              batch: {debounceMs: 5000, maxSize: 10, maxWaitMs: 60 * 60 * 1000},
+              onResolve: 'cancel',
             },
             steps: [{prompt: promptSource}],
           },
@@ -450,7 +441,7 @@ describe('workflow run queries', () => {
     });
 
     test('does not load variables referenced only by listening job executions at run creation', async () => {
-      const model = normalizeWorkflowDocument({
+      const model = workflowModel({
         name: 'Listening vars workflow',
         runner: 'ubuntu-latest',
         jobs: {
@@ -458,6 +449,7 @@ describe('workflow run queries', () => {
             listening: {
               on: [{source: 'github', event: 'pull_request_review'}],
               until: [{source: 'github', event: 'pull_request'}],
+              onResolve: 'finish',
             },
             steps: [
               {
@@ -492,7 +484,7 @@ describe('workflow run queries', () => {
       {
         field: 'run',
         model: () =>
-          normalizeWorkflowDocument({
+          workflowModel({
             name: 'Missing run var',
             runner: 'ubuntu-latest',
             jobs: {build: {steps: [{run: `echo ${template('vars.REQUIRED')}`}]}},
@@ -502,7 +494,7 @@ describe('workflow run queries', () => {
       {
         field: 'env',
         model: () =>
-          normalizeWorkflowDocument({
+          workflowModel({
             name: 'Missing env var',
             runner: 'ubuntu-latest',
             jobs: {
@@ -516,7 +508,7 @@ describe('workflow run queries', () => {
       {
         field: 'agent.prompt',
         model: () =>
-          normalizeWorkflowDocument({
+          workflowModel({
             name: 'Missing prompt var',
             runner: 'ubuntu-latest',
             jobs: {fix: {steps: [{prompt: template('vars.REQUIRED')}]}},
@@ -526,7 +518,7 @@ describe('workflow run queries', () => {
       {
         field: 'agent.model',
         model: () =>
-          normalizeWorkflowDocument({
+          workflowModel({
             name: 'Missing model var',
             runner: 'ubuntu-latest',
             jobs: {fix: {steps: [{prompt: 'Fix it', model: template('vars.REQUIRED')}]}},
@@ -536,7 +528,7 @@ describe('workflow run queries', () => {
       {
         field: 'agent.provider',
         model: () =>
-          normalizeWorkflowDocument({
+          workflowModel({
             name: 'Missing provider var',
             runner: 'ubuntu-latest',
             jobs: {fix: {steps: [{prompt: 'Fix it', provider: template('vars.REQUIRED')}]}},
@@ -546,17 +538,23 @@ describe('workflow run queries', () => {
       {
         field: 'job.runner',
         model: () =>
-          normalizeWorkflowDocument({
+          workflowModel({
             name: 'Missing runner var',
             runner: 'ubuntu-latest',
-            jobs: {build: {runner: template('vars.REQUIRED'), steps: [{run: 'echo ok'}]}},
+            jobs: {
+              build: {
+                runner: [],
+                runnerTemplates: [template('vars.REQUIRED')],
+                steps: [{run: 'echo ok'}],
+              },
+            },
           }),
         expected: {field: 'job.runner', source: 'vars.REQUIRED'},
       },
       {
         field: 'step.name',
         model: () =>
-          normalizeWorkflowDocument({
+          workflowModel({
             name: 'Missing step name var',
             runner: 'ubuntu-latest',
             jobs: {build: {steps: [{name: template('vars.REQUIRED'), run: 'echo ok'}]}},
@@ -623,7 +621,7 @@ describe('workflow run queries', () => {
     });
 
     test('persists resolved step config and authored step config separately', async () => {
-      const model = normalizeWorkflowDocument({
+      const model = workflowModel({
         name: 'Interpolated workflow',
         runner: 'ubuntu-latest',
         env: {RUN_ID: template('run.id'), REF: template('event.ref')},
@@ -674,7 +672,7 @@ describe('workflow run queries', () => {
     });
 
     test('resolves webhook trigger payload body and headers into step config', async () => {
-      const model = normalizeWorkflowDocument({
+      const model = workflowModel({
         name: 'Webhook workflow',
         runner: 'ubuntu-latest',
         env: {
@@ -720,7 +718,7 @@ describe('workflow run queries', () => {
     });
 
     test('fails for missing available untrusted interpolation paths', async () => {
-      const model = normalizeWorkflowDocument({
+      const model = workflowModel({
         name: 'Diagnostic workflow',
         runner: 'ubuntu-latest',
         env: {REF: template('event.ref')},

package/src/db/workflow-runs.ts

@@ -9,7 +9,6 @@ export {
   getJobExecutionsByJobId,
   getJobExecutionsByWorkflowRunAttemptId,
   getLatestJobExecutionByJobId,
-  lockActiveJobExecutionLeaseForUpdate,
   recordJobExecutionQueuedAt,
   recordJobExecutionStartedAt,
   resolveJobExecutionAfterLeaseExpiry,

package/src/index.ts

@@ -95,7 +95,7 @@ export function createWorkflowsModule({
 }): ShipfoxModule {
   return {
     name: 'workflows',
-    database: {db, migrationsPath},
+    database: {db, migrationsPath, databaseNamespace: 'workflows'},
     routes: createWorkflowRoutes({
       agent,
       annotations,

package/src/presentation/dto/checkout-token.test.ts

@@ -1,6 +1,12 @@
-import type {CheckoutSpec} from '@shipfox/api-integration-core';
 import {toCheckoutTokenDto} from './checkout-token.js';
 
+type CheckoutSpec = {
+  repositoryUrl: string;
+  ref: string;
+  credentials?: {username: string; token: string; expiresAt: Date};
+  gitAuthor?: {name: string; email: string};
+};
+
 describe('toCheckoutTokenDto', () => {
   it('maps credentials to basic auth with an ISO expiry', () => {
     const spec: CheckoutSpec = {

package/src/presentation/routes/agent-runtime-config.test.ts

@@ -1,19 +1,11 @@
 import {
-  createAgentModule,
-  createCustomModelProviderConfig,
-  testAndSaveModelProviderConfig,
-} from '@shipfox/api-agent';
-import {resolveRuntimeCredentials} from '@shipfox/api-agent/core/resolve-runtime-credentials';
-import {agentInterModuleContract} from '@shipfox/api-agent-dto/inter-module';
+  type AgentInterModuleClient,
+  agentInterModuleContract,
+} from '@shipfox/api-agent-dto/inter-module';
 import type {WorkflowModel} from '@shipfox/api-definitions-dto';
-import {secretsInterModuleContract} from '@shipfox/api-secrets-dto/inter-module';
 import {createInterModuleKnownError} from '@shipfox/inter-module';
 import {closeApp, createApp, type FastifyInstance} from '@shipfox/node-fastify';
 import {createCapturingLogger} from '@shipfox/node-log/test';
-import {
-  createInMemoryInterModuleTransport,
-  registerInterModulePresentations,
-} from '@shipfox/node-module/inter-module';
 import {eq} from 'drizzle-orm';
 import type {StepStatus} from '#core/entities/step.js';
 import {db} from '#db/db.js';
@@ -32,22 +24,32 @@ import {createTestSecretsClient} from '#test/fixtures/secrets-inter-module.js';
 import {createLeaseTokenRouteGroup} from './index.js';
 
 const {captureExceptionMock} = vi.hoisted(() => ({captureExceptionMock: vi.fn()}));
-vi.mock('@shipfox/api-agent/core/resolve-runtime-credentials', async (importOriginal) => {
-  const actual =
-    await importOriginal<typeof import('@shipfox/api-agent/core/resolve-runtime-credentials')>();
-  return {...actual, resolveRuntimeCredentials: vi.fn(actual.resolveRuntimeCredentials)};
-});
 vi.mock('@shipfox/node-error-monitoring', () => ({captureException: captureExceptionMock}));
 
 const URL = '/runs/jobs/current/agent-runtime-config';
 const secrets = createTestSecretsClient();
-const agentTransport = createInMemoryInterModuleTransport();
-const agentTestClient = agentTransport.createClient(agentInterModuleContract);
-registerInterModulePresentations({
-  transport: agentTransport,
-  modules: [createAgentModule({secrets})],
-});
-agentTransport.seal();
+const runtimeConfigs = new Map<
+  string,
+  Awaited<ReturnType<AgentInterModuleClient['resolveRuntimeCredentials']>>
+>();
+const resolveRuntimeCredentials = vi.fn<AgentInterModuleClient['resolveRuntimeCredentials']>(
+  ({workspaceId}) => {
+    const runtimeConfig = runtimeConfigs.get(workspaceId);
+    if (runtimeConfig) return Promise.resolve(runtimeConfig);
+    return Promise.reject(
+      createInterModuleKnownError(
+        agentInterModuleContract.methods.resolveRuntimeCredentials,
+        'model-provider-not-configured',
+        {},
+      ),
+    );
+  },
+);
+const agentTestClient: AgentInterModuleClient = {
+  getValidationCatalog: vi.fn(),
+  resolveAgentConfig: vi.fn(),
+  resolveRuntimeCredentials,
+};
 
 describe('GET /runs/jobs/current/agent-runtime-config', () => {
   let app: FastifyInstance;
@@ -76,7 +78,8 @@ describe('GET /runs/jobs/current/agent-runtime-config', () => {
   beforeEach(() => {
     clearLogLines();
     captureExceptionMock.mockReset();
-    vi.mocked(resolveRuntimeCredentials).mockClear();
+    runtimeConfigs.clear();
+    resolveRuntimeCredentials.mockClear();
   });
 
   afterAll(async () => {
@@ -160,67 +163,6 @@ describe('GET /runs/jobs/current/agent-runtime-config', () => {
     expect(res.json().credentials.api_key).toBe('sk-gated-workspace-secret');
   });
 
-  test('returns custom provider descriptors for a running leased custom agent step', async () => {
-    const workspaceId = crypto.randomUUID();
-    await createCustomModelProviderConfig(
-      {
-        workspaceId,
-        body: {
-          slug: 'local-vllm',
-          display_name: 'Local vLLM',
-          api: 'openai-responses',
-          base_url: 'http://127.0.0.1:11434/v1',
-          api_key: 'sk-local-secret',
-          headers: [{name: 'authorization', value: 'Bearer local', secret: true}],
-          models: [{id: 'llama-3.1', label: 'Llama 3.1'}],
-        },
-      },
-      {probe: async () => undefined, secrets},
-    );
-    const {job, step} = await createRunningAgentStep({
-      workspaceId,
-      resolveAgentDefaults: () => ({
-        harness: 'pi',
-        provider: 'local-vllm',
-        model: 'llama-3.1',
-        thinking: 'high',
-      }),
-      steps: [
-        {
-          provider: 'local-vllm',
-          model: 'llama-3.1',
-          thinking: 'high',
-          prompt: 'Fix the tests.',
-        },
-      ],
-    });
-    const token = await mintActiveLeaseToken({jobId: job.id});
-
-    const res = await app.inject({
-      method: 'GET',
-      url: runtimeConfigUrl(step.id, step.currentAttempt),
-      headers: {authorization: `Bearer ${token}`},
-    });
-
-    expect(res.statusCode).toBe(200);
-    expect(res.json()).toMatchObject({
-      harness: 'pi',
-      provider_id: 'local-vllm',
-      model: 'llama-3.1',
-      credentials: {
-        api_key: 'sk-local-secret',
-        'header:authorization': 'Bearer local',
-      },
-      custom_provider: {
-        api: 'openai-responses',
-        base_url: 'http://127.0.0.1:11434/v1',
-        secret_header_names: ['authorization'],
-        models: [{id: 'llama-3.1', label: 'Llama 3.1'}],
-        requires_api_key: true,
-      },
-    });
-  });
-
   test('returns 404 when the lease token is no longer the active job lease', async () => {
     const {run, job, step} = await createRunningAgentStep();
     await insertRunningJobLease({
@@ -348,10 +290,10 @@ describe('GET /runs/jobs/current/agent-runtime-config', () => {
 
   test('returns 409 and reports when workspace credentials cannot be decrypted', async () => {
     const {job, step} = await createRunningAgentStep();
-    vi.mocked(resolveRuntimeCredentials).mockRejectedValueOnce(
+    resolveRuntimeCredentials.mockRejectedValueOnce(
       createInterModuleKnownError(
-        secretsInterModuleContract.methods.getSecretsByNamespace,
-        'secret-decryption-failed',
+        agentInterModuleContract.methods.resolveRuntimeCredentials,
+        'model-provider-credentials-invalid',
         {},
       ),
     );
@@ -397,15 +339,14 @@ function runtimeConfigUrl(stepId: string, attempt: number): string {
   return `${URL}?${search.toString()}`;
 }
 
-async function saveWorkspaceCredential(workspaceId: string, apiKey: string) {
-  return await testAndSaveModelProviderConfig(
-    {
-      workspaceId,
-      providerId: 'anthropic',
-      credentials: {api_key: apiKey},
-    },
-    {probe: async () => undefined, secrets},
-  );
+function saveWorkspaceCredential(workspaceId: string, apiKey: string): void {
+  runtimeConfigs.set(workspaceId, {
+    harness: 'pi',
+    provider_id: 'anthropic',
+    model: 'claude-opus-4-8',
+    thinking: 'xhigh',
+    credentials: {api_key: apiKey},
+  });
 }
 
 type TestStepInput =

package/src/presentation/routes/next-step.test.ts

@@ -1,6 +1,6 @@
 import type {AnnotationsInterModuleClient} from '@shipfox/annotations-dto/inter-module';
 import {closeApp, createApp, type FastifyInstance} from '@shipfox/node-fastify';
-import {eq, sql} from 'drizzle-orm';
+import {eq} from 'drizzle-orm';
 import {JobNotFoundError} from '#core/errors.js';
 import {recordStepResult as recordJobExecutionStepResult} from '#core/job-execution.js';
 import {db} from '#db/db.js';
@@ -21,7 +21,10 @@ import {
   mintLeaseToken,
 } from '#test/fixtures/lease-token.js';
 import {projectsTestClient} from '#test/fixtures/projects-inter-module.js';
-import {runnersTestClient} from '#test/fixtures/runners-inter-module.js';
+import {
+  runnersTestClient,
+  setRunnerToolCapabilities as setTestRunnerToolCapabilities,
+} from '#test/fixtures/runners-inter-module.js';
 import {createTestSecretsClient} from '#test/fixtures/secrets-inter-module.js';
 import {createLeaseTokenRouteGroup} from './index.js';
 
@@ -39,16 +42,11 @@ async function recordStepResult(
   return recordJobExecutionStepResult({...rest, jobExecutionId: step.jobExecutionId});
 }
 
-async function setRunnerToolCapabilities(
+function setRunnerToolCapabilities(
   runnerSessionId: string,
-  capabilities: Record<string, unknown>,
-): Promise<void> {
-  await db().execute(sql`
-    UPDATE runners_runner_sessions
-    SET tool_capabilities = ${JSON.stringify(capabilities)}::jsonb,
-      tool_capabilities_reported_at = now()
-    WHERE id = ${runnerSessionId}
-  `);
+  capabilities: {harnesses: {pi?: {tools: string[]}; claude?: {tools: string[]}}},
+): void {
+  setTestRunnerToolCapabilities(runnerSessionId, {capabilities, reportFresh: true});
 }
 
 const annotationWrites = vi.fn<AnnotationsInterModuleClient['replaceOrRemoveAnnotation']>();
@@ -116,6 +114,9 @@ describe('POST /runs/jobs/current/steps/next', () => {
   test('returns the lowest-position pending step and marks it running', async () => {
     const {jobId, steps} = await arrangeJobWithSteps(3);
     const token = await mintActiveLeaseToken({jobId});
+    const lease = getLeaseTokenClaims(token);
+    if (!lease) throw new Error('Expected minted lease token to verify');
+    const getLeaseState = vi.spyOn(runnersTestClient, 'getLeaseState');
 
     const res = await app.inject({
       method: 'POST',
@@ -124,6 +125,11 @@ describe('POST /runs/jobs/current/steps/next', () => {
     });
 
     expect(res.statusCode).toBe(200);
+    expect(getLeaseState).toHaveBeenCalledWith({
+      jobId: lease.jobId,
+      jobExecutionId: lease.jobExecutionId,
+      runnerSessionId: lease.runnerSessionId,
+    });
     const body = res.json();
     expect(body.kind).toBe('step');
     expect(body.step.id).toBe(steps[0]?.id);
@@ -182,7 +188,7 @@ describe('POST /runs/jobs/current/steps/next', () => {
     const token = await mintActiveLeaseToken({jobId});
     const lease = getLeaseTokenClaims(token);
     if (!lease) throw new Error('Expected minted lease token to verify');
-    await setRunnerToolCapabilities(lease.runnerSessionId, {harnesses: {pi: {tools: ['read']}}});
+    setRunnerToolCapabilities(lease.runnerSessionId, {harnesses: {pi: {tools: ['read']}}});
 
     const first = await app.inject({
       method: 'POST',

package/src/presentation/routes/next-step.ts

@@ -6,7 +6,7 @@ import type {RunnersInterModuleClient} from '@shipfox/api-runners-dto/inter-modu
 import {nextStepResponseSchema} from '@shipfox/api-workflows-dto';
 import {ClientError, defineRoute} from '@shipfox/node-fastify';
 import {warnAgentToolCapabilityMismatchOnDispatch} from '#core/agent-tool-capability-warning.js';
-import {JobLeaseNotActiveError, JobNotFoundError} from '#core/errors.js';
+import {JobNotFoundError} from '#core/errors.js';
 import {nextStepForLeasedJobExecution} from '#core/job-execution.js';
 import {toStepDto} from '#presentation/dto/step.js';
 
@@ -30,17 +30,21 @@ export function createNextStepRoute(params: {
       if (error instanceof JobNotFoundError) {
         throw new ClientError(error.message, 'job-not-found', {status: 404});
       }
-      if (error instanceof JobLeaseNotActiveError) {
-        throw new ClientError('Job lease is no longer active', 'lease-not-active', {status: 404});
-      }
       throw error;
     },
     handler: async (request) => {
       const leasedJob = requireLeasedJobContext(request);
-      const next = await nextStepForLeasedJobExecution({
+      const {active: leaseIsActive} = await params.runners.getLeaseState({
         jobId: leasedJob.jobId,
         jobExecutionId: leasedJob.jobExecutionId,
         runnerSessionId: leasedJob.runnerSessionId,
+      });
+      if (!leaseIsActive) {
+        throw new ClientError('Job lease is no longer active', 'lease-not-active', {status: 404});
+      }
+
+      const next = await nextStepForLeasedJobExecution({
+        jobExecutionId: leasedJob.jobExecutionId,
         agent: params.agent,
       });
 

package/test/factories/workflow-model.ts

@@ -49,6 +49,7 @@ interface TestWorkflowJob {
   readonly success?: string | undefined;
   readonly outputs?: Readonly<Record<string, string>> | undefined;
   readonly env?: WorkflowModel['env'] | undefined;
+  readonly listening?: WorkflowModel['jobs'][number]['listening'] | undefined;
   readonly steps: readonly TestWorkflowStep[];
 }
 
@@ -70,7 +71,7 @@ export function workflowModel(input: TestWorkflowModelInput = {}): WorkflowModel
     return {
       id: jobId,
       key,
-      mode: 'one_shot' as const,
+      mode: job.listening === undefined ? ('one_shot' as const) : ('listening' as const),
       runner: normalizeStringArray(job.runner ?? input.runner ?? DEFAULT_RUNNER_LABELS),
       ...(job.runnerTemplates === undefined
         ? {}
@@ -90,6 +91,7 @@ export function workflowModel(input: TestWorkflowModelInput = {}): WorkflowModel
               {kind: 'literal' as const, value: job.name},
             ],
           }),
+      ...(job.listening === undefined ? {} : {listening: job.listening}),
       ...optionalScopedEnv(job.env),
       dependencies: normalizeStringArray(job.needs).map(stableId),
       steps: job.steps.map((step, stepIndex) => normalizeStep(step, jobId, stepIndex)),

package/test/fixtures/active-lease-token.ts

@@ -1,11 +1,10 @@
-import {db} from '#db/db.js';
-import {runnerSessions, runningJobExecutions} from '#db/runner-lease-table.js';
 import {
   getFirstJobExecutionByJobId,
   getJobById,
   getWorkflowRunByAttemptId,
 } from '#db/workflow-runs.js';
 import {mintLeaseToken} from './lease-token.js';
+import {registerActiveRunnerLease} from './runners-inter-module.js';
 
 export interface MintActiveLeaseTokenParams {
   jobId: string;
@@ -26,13 +25,9 @@ export async function mintActiveLeaseToken(params: MintActiveLeaseTokenParams):
   if (!run) throw new Error('Expected workflow run to exist');
   const runnerSessionId = crypto.randomUUID();
 
-  await insertRunningJobLease({
-    workspaceId: run.workspaceId,
-    workflowRunId: run.id,
-    workflowRunAttemptId: job.workflowRunAttemptId,
+  registerActiveRunnerLease({
     jobId: params.jobId,
     jobExecutionId: jobExecution.id,
-    projectId: run.projectId,
     runnerSessionId,
   });
 
@@ -57,29 +52,7 @@ export interface InsertRunningJobLeaseParams {
   runnerSessionId: string;
 }
 
-export async function insertRunningJobLease(params: InsertRunningJobLeaseParams): Promise<void> {
-  await db()
-    .insert(runnerSessions)
-    .values({
-      id: params.runnerSessionId,
-      workspaceId: params.workspaceId,
-      scope: 'workspace',
-      registrationTokenId: crypto.randomUUID(),
-      registrationTokenKind: 'manual',
-      labels: ['linux'],
-    });
-
-  await db()
-    .insert(runningJobExecutions)
-    .values({
-      workspaceId: params.workspaceId,
-      workflowRunId: params.workflowRunId,
-      workflowRunAttemptId: params.workflowRunAttemptId,
-      jobId: params.jobId,
-      jobExecutionId: params.jobExecutionId,
-      projectId: params.projectId,
-      runnerSessionId: params.runnerSessionId,
-      requiredLabels: ['linux'],
-      runnerLabels: ['linux'],
-    });
+export function insertRunningJobLease(params: InsertRunningJobLeaseParams): Promise<void> {
+  registerActiveRunnerLease(params);
+  return Promise.resolve();
 }

package/test/fixtures/agent-inter-module.ts

@@ -1,8 +1,8 @@
 import {
   DEFAULT_HARNESS_TOOL_DEPLOYMENT_CONFIG,
-  getModelProviderEntry,
   listEnabledHarnessTools,
   listHarnessDescriptors,
+  MODEL_PROVIDER_CATALOG_SEED,
   MODEL_PROVIDER_IDS,
 } from '@shipfox/api-agent-dto';
 import type {
@@ -15,7 +15,8 @@ export const agentValidationCatalog: AgentValidationCatalog = {
   version: 1,
   providers: MODEL_PROVIDER_IDS.map((id) => ({
     id,
-    support_status: getModelProviderEntry(id)?.support_status ?? 'unsupported',
+    support_status:
+      MODEL_PROVIDER_CATALOG_SEED.find((entry) => entry.id === id)?.support_status ?? 'unsupported',
   })),
   harnesses: listHarnessDescriptors().map((harness) => ({
     id: harness.id,