@shipfox/api-workflows 4.0.0 → 6.0.0

package/src/core/step-config/materialize-workflow-model.ts

@@ -1,6 +1,6 @@
-import type {AgentDefaultsResolver} from '@shipfox/api-agent/core/resolve-agent-config';
-import type {WorkflowModel} from '@shipfox/api-definitions';
+import type {WorkflowModel} from '@shipfox/api-definitions-dto';
 import {canonicalizeLabels, findInvalidLabels, MAX_RUNNER_LABELS} from '@shipfox/runner-labels';
+import type {AgentDefaultsResolver} from '#core/agent-defaults.js';
 import type {
   AgentToolMaterializationContext,
   AgentToolMaterializationSnapshot,
@@ -38,9 +38,9 @@ export interface MaterializeWorkflowModelParams {
   readonly agentToolSnapshot?: AgentToolMaterializationSnapshot | null | undefined;
 }
 
-export function materializeWorkflowModel(
+export async function materializeWorkflowModel(
   params: MaterializeWorkflowModelParams,
-): readonly MaterializedWorkflowJob[] {
+): Promise<readonly MaterializedWorkflowJob[]> {
   const {
     model,
     context = {site: 'run-creation', values: {}},
@@ -51,31 +51,33 @@ export function materializeWorkflowModel(
   } = params;
   const jobsById = new Map(model.jobs.map((job) => [job.id, job]));
 
-  return model.jobs.map((job, position) => ({
-    key: job.key,
-    mode: job.mode,
-    ...(job.success === undefined ? {} : {success: job.success}),
-    ...(job.executionTimeoutMs === undefined ? {} : {executionTimeoutMs: job.executionTimeoutMs}),
-    checkout: job.checkout,
-    ...(job.listening === undefined ? {} : {listening: job.listening}),
-    ...(job.name === undefined ? {} : {name: job.name}),
-    ...(job.outputs === undefined ? {} : {outputs: job.outputs}),
-    dependencies: dependencySourceNames(job, jobsById),
-    runner: job.runner,
-    position,
-    steps:
-      job.mode === 'listening'
-        ? []
-        : materializeJobExecutionSteps({
-            model,
-            job,
-            context,
-            resolveAgentDefaults,
-            definitionId,
-            agentToolContext,
-            agentToolSnapshot,
-          }),
-  }));
+  return await Promise.all(
+    model.jobs.map(async (job, position) => ({
+      key: job.key,
+      mode: job.mode,
+      ...(job.success === undefined ? {} : {success: job.success}),
+      ...(job.executionTimeoutMs === undefined ? {} : {executionTimeoutMs: job.executionTimeoutMs}),
+      checkout: job.checkout,
+      ...(job.listening === undefined ? {} : {listening: job.listening}),
+      ...(job.name === undefined ? {} : {name: job.name}),
+      ...(job.outputs === undefined ? {} : {outputs: job.outputs}),
+      dependencies: dependencySourceNames(job, jobsById),
+      runner: job.runner,
+      position,
+      steps:
+        job.mode === 'listening'
+          ? []
+          : await materializeJobExecutionSteps({
+              model,
+              job,
+              context,
+              resolveAgentDefaults,
+              definitionId,
+              agentToolContext,
+              agentToolSnapshot,
+            }),
+    })),
+  );
 }
 
 export function materializeJobRunner(params: {

package/src/core/step-config/resolve-job-execution-name.ts

@@ -1,4 +1,4 @@
-import type {WorkflowModel} from '@shipfox/api-definitions';
+import type {WorkflowModel} from '@shipfox/api-definitions-dto';
 import {
   capTraceEntries,
   getWorkflowInterpolationFieldFailurePolicy,

package/src/core/step-config/resolve-step-config.ts

@@ -1,11 +1,11 @@
-import type {AgentDefaultsResolver} from '@shipfox/api-agent/core/resolve-agent-config';
-import type {WorkflowEnvTemplates, WorkflowModel} from '@shipfox/api-definitions';
+import type {WorkflowEnvTemplates, WorkflowModel} from '@shipfox/api-definitions-dto';
 import {
   type AvailabilitySite,
   capTraceEntries,
   type EvaluationTraceLimitEntry,
   type WorkflowExpressionEvaluationContext,
 } from '@shipfox/expression';
+import type {AgentDefaultsResolver} from '#core/agent-defaults.js';
 import type {
   AgentToolMaterializationContext,
   AgentToolMaterializationSnapshot,
@@ -46,7 +46,7 @@ export interface ResolveStepConfigParams {
   readonly jobEnvTemplates: WorkflowEnvTemplates | undefined;
   readonly context: WorkflowExpressionEvaluationContext;
   readonly site: AvailabilitySite;
-  readonly resolveAgentDefaults: AgentDefaultsResolver;
+  readonly resolveAgentDefaults?: AgentDefaultsResolver | undefined;
   readonly definitionId: string;
   readonly agentToolContext?: AgentToolMaterializationContext | undefined;
   readonly agentToolSnapshot?: AgentToolMaterializationSnapshot | null | undefined;
@@ -62,11 +62,13 @@ interface BuiltStepConfig {
   readonly hasTemplates: boolean;
 }
 
-export function resolveStepConfig(params: ResolveStepConfigParams): ResolvedStepConfig {
+export async function resolveStepConfig(
+  params: ResolveStepConfigParams,
+): Promise<ResolvedStepConfig> {
   const context = evaluationContext(params);
-  const effective = buildStepConfig({...params, context, mode: 'effective'});
+  const effective = await buildStepConfig({...params, context, mode: 'effective'});
   const authoredConfig = effective.hasTemplates
-    ? buildStepConfig({...params, context, mode: 'authored'}).config
+    ? (await buildStepConfig({...params, context, mode: 'authored'})).config
     : null;
   const name = resolveStepName(params.step, context, params.definitionId);
 
@@ -80,9 +82,9 @@ export function resolveStepConfig(params: ResolveStepConfigParams): ResolvedStep
   };
 }
 
-function buildStepConfig(
+async function buildStepConfig(
   params: Omit<BuildStepConfigParams, 'context'> & {readonly context: WorkflowEvaluationContext},
-): BuiltStepConfig {
+): Promise<BuiltStepConfig> {
   const gate = gateConfigForStep(params.step);
   const outputs = outputsConfigForStep(params.step);
   const runStep = runStepOrNull(params.step);
@@ -102,7 +104,7 @@ function buildStepConfig(
   const agentStep = agentStepOrNull(params.step);
   if (agentStep === null) throw new Error(`Unsupported workflow step kind: ${params.step.kind}`);
 
-  const agent = resolveAgentStepConfig({...params, step: agentStep});
+  const agent = await resolveAgentStepConfig({...params, step: agentStep});
   return {
     config: {...agent.config, ...gate, ...outputs},
     configPlan: agent.configPlan,

package/src/core/step-config/run.ts

@@ -1,4 +1,4 @@
-import type {WorkflowModel} from '@shipfox/api-definitions';
+import type {WorkflowModel} from '@shipfox/api-definitions-dto';
 import {
   type MaterializedSecretBindingDto,
   materializedSecretBindingSchema,

package/src/core/workflow-run-creation.test.ts

@@ -1,6 +1,7 @@
-import type {WorkflowModel} from '@shipfox/api-definitions';
+import type {WorkflowModel} from '@shipfox/api-definitions-dto';
 import {buildModel, template} from '#test/helpers/workflow-runs.js';
 import type {TriggerPayload, WorkflowRun} from './entities/workflow-run.js';
+import type {MaterializedWorkflowJob} from './step-config/materialize-workflow-model.js';
 import {
   deriveInitialJobExecutionPlan,
   materializeWorkflowRunJobs,
@@ -14,7 +15,7 @@ const triggerPayload: TriggerPayload = {
 };
 
 describe('deriveInitialJobExecutionPlan', () => {
-  it('resolves initial execution name and runner templates from creation context', () => {
+  it('resolves initial execution name and runner templates from creation context', async () => {
     const model = buildModel({
       jobs: {
         deploy: {
@@ -26,7 +27,7 @@ describe('deriveInitialJobExecutionPlan', () => {
       },
     });
     const run = workflowRun({inputs: {environment: 'prod', runner: 'GPU'}});
-    const {modelJob, job} = materializedJob(model, run, {inputs: run.inputs});
+    const {modelJob, job} = await materializedJob(model, run, {inputs: run.inputs});
 
     const plan = deriveInitialJobExecutionPlan({
       run,
@@ -55,7 +56,7 @@ describe('deriveInitialJobExecutionPlan', () => {
     });
   });
 
-  it('resolves variables referenced only by job runner templates', () => {
+  it('resolves variables referenced only by job runner templates', async () => {
     const model = buildModel({
       jobs: {
         build: {
@@ -65,7 +66,7 @@ describe('deriveInitialJobExecutionPlan', () => {
       },
     });
     const run = workflowRun();
-    const {modelJob, job} = materializedJob(model, run, {vars: {RUNNER: 'GPU'}});
+    const {modelJob, job} = await materializedJob(model, run, {vars: {RUNNER: 'GPU'}});
 
     const plan = deriveInitialJobExecutionPlan({
       run,
@@ -81,7 +82,7 @@ describe('deriveInitialJobExecutionPlan', () => {
     expect(plan.runner).toEqual(['gpu', 'ubuntu-latest']);
   });
 
-  it('uses the fallback name for execution-name self references', () => {
+  it('uses the fallback name for execution-name self references', async () => {
     const model = buildModel({
       jobs: {
         deploy: {
@@ -91,7 +92,7 @@ describe('deriveInitialJobExecutionPlan', () => {
       },
     });
     const run = workflowRun();
-    const {modelJob, job} = materializedJob(model, run);
+    const {modelJob, job} = await materializedJob(model, run);
 
     const plan = deriveInitialJobExecutionPlan({
       run,
@@ -107,15 +108,18 @@ describe('deriveInitialJobExecutionPlan', () => {
   });
 });
 
-function materializedJob(
+async function materializedJob(
   model: WorkflowModel,
   run: WorkflowRun,
   context: {
     inputs?: Record<string, unknown> | null | undefined;
     vars?: Record<string, string> | undefined;
   } = {},
-) {
-  const [job] = materializeWorkflowRunJobs({
+): Promise<{
+  job: MaterializedWorkflowJob;
+  modelJob: WorkflowModel['jobs'][number];
+}> {
+  const [job] = await materializeWorkflowRunJobs({
     run,
     model,
     triggerPayload,

package/src/core/workflow-run-creation.ts

@@ -1,8 +1,5 @@
-import {
-  type AgentDefaultsResolver,
-  catalogDefaultAgentResolver,
-} from '@shipfox/api-agent/core/resolve-agent-config';
-import type {WorkflowModel} from '@shipfox/api-definitions';
+import type {WorkflowModel} from '@shipfox/api-definitions-dto';
+import type {AgentDefaultsResolver} from './agent-defaults.js';
 import type {
   AgentToolMaterializationContext,
   AgentToolMaterializationSnapshot,
@@ -20,7 +17,7 @@ import {
 } from './step-config/materialize-workflow-model.js';
 import {resolveJobExecutionName} from './step-config/resolve-job-execution-name.js';
 
-export function materializeWorkflowRunJobs(params: {
+export async function materializeWorkflowRunJobs(params: {
   run: WorkflowRun;
   model: WorkflowModel;
   triggerPayload: TriggerPayload;
@@ -30,17 +27,17 @@ export function materializeWorkflowRunJobs(params: {
   definitionId: string;
   agentToolContext?: AgentToolMaterializationContext | undefined;
   agentToolSnapshot?: AgentToolMaterializationSnapshot | null | undefined;
-}): readonly MaterializedWorkflowJob[] {
+}): Promise<readonly MaterializedWorkflowJob[]> {
   const context = assembleCreationContext({
     run: params.run,
     triggerPayload: params.triggerPayload,
     inputs: params.inputs ?? null,
     vars: params.vars,
   });
-  return materializeWorkflowModel({
+  return await materializeWorkflowModel({
     model: params.model,
     context,
-    resolveAgentDefaults: params.resolveAgentDefaults ?? catalogDefaultAgentResolver,
+    resolveAgentDefaults: params.resolveAgentDefaults,
     definitionId: params.definitionId,
     agentToolContext: params.agentToolContext,
     agentToolSnapshot: params.agentToolSnapshot,

package/src/db/job-listeners.ts

@@ -1,9 +1,13 @@
-import type {AgentDefaultsResolver} from '@shipfox/api-agent/core/resolve-agent-config';
+import type {AgentInterModuleClient} from '@shipfox/api-agent-dto/inter-module';
+import {readPersistedWorkflowModel} from '@shipfox/api-definitions-dto';
+import type {IntegrationsModuleClient} from '@shipfox/api-integration-core-dto';
+import type {ProjectsModuleClient} from '@shipfox/api-projects-dto';
 import {
   WORKFLOWS_JOB_ACTIVATED,
   type WorkflowsJobActivatedEventDto,
 } from '@shipfox/api-workflows-dto';
 import {and, asc, count, eq, inArray, isNull, notInArray, sql} from 'drizzle-orm';
+import {type AgentDefaultsResolver, createAgentDefaultsResolver} from '#core/agent-defaults.js';
 import {loadAgentToolMaterializationContext} from '#core/agent-tools.js';
 import {isJobTerminal, type JobStatus, type ResolutionReason} from '#core/entities/job.js';
 import type {JobExecutionStatus, WorkflowExecutionEvent} from '#core/entities/job-execution.js';
@@ -174,7 +178,10 @@ export interface DrainListenerEventsParams {
   jobId: string;
   expectedSequence: number;
   maxSize?: number | undefined;
+  integrations?: IntegrationsModuleClient | undefined;
+  projects?: ProjectsModuleClient | undefined;
   resolveAgentDefaults?: AgentDefaultsResolver | undefined;
+  agent?: AgentInterModuleClient | undefined;
 }
 
 export async function drainListenerEventsIntoExecution(
@@ -191,22 +198,30 @@ export async function drainListenerEventsIntoExecution(
     if (bufferedEvents.length === 0) return {result: {kind: 'empty' as const}};
 
     const target = await loadListenerMaterializationTarget(params.jobId, tx);
+    const model =
+      target.attempt.model === null ? null : readPersistedWorkflowModel(target.attempt.model);
     const agentToolContext =
       target.attempt.agentToolMaterialization === null
         ? await loadAgentToolMaterializationContext({
-            model: target.attempt.model,
+            model,
             workspaceId: target.run.workspaceId,
             projectId: target.run.projectId,
+            integrations: params.integrations,
+            projects: params.projects,
           })
         : undefined;
-    const materialized = materializeListenerExecution({
-      model: target.attempt.model,
+    const materialized = await materializeListenerExecution({
+      model,
       run: toWorkflowRun(target.run),
       job: toJob(target.job),
       sequence: params.expectedSequence,
       triggerEvents: listenerTriggerEvents(bufferedEvents),
       priorExecutions: target.priorExecutions,
-      resolveAgentDefaults: params.resolveAgentDefaults,
+      resolveAgentDefaults:
+        params.resolveAgentDefaults ??
+        (params.agent
+          ? createAgentDefaultsResolver(params.agent, target.run.workspaceId)
+          : undefined),
       agentToolContext,
       agentToolSnapshot: target.attempt.agentToolMaterialization,
     });

package/src/db/runner-lease-table.ts

@@ -6,7 +6,7 @@ const pgTable = pgTableCreator((name) => `runners_${name}`);
 export const runnerSessionScopeEnum = pgEnum('runners_runner_session_scope', ['workspace']);
 export const runnerSessionRegistrationTokenKindEnum = pgEnum(
   'runners_runner_session_registration_token_kind',
-  ['manual', 'ephemeral'],
+  ['manual', 'ephemeral', 'activation'],
 );
 
 export const runnerSessions = pgTable('runner_sessions', {
@@ -17,7 +17,7 @@ export const runnerSessions = pgTable('runner_sessions', {
   registrationTokenKind:
     runnerSessionRegistrationTokenKindEnum('registration_token_kind').notNull(),
   provisionerId: uuid('provisioner_id'),
-  provisionedRunnerId: text('provisioned_runner_id'),
+  providerRunnerId: text('provider_runner_id'),
   labels: text('labels').array().notNull(),
   maxClaims: integer('max_claims'),
   claimsUsed: integer('claims_used').notNull().default(0),

package/src/db/schema/workflow-run-attempts.ts

@@ -1,4 +1,8 @@
-import type {WorkflowModel} from '@shipfox/api-definitions';
+import {
+  readPersistedWorkflowModel,
+  type WorkflowModel,
+  type WorkflowModelSnapshot,
+} from '@shipfox/api-definitions-dto';
 import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';
 import {sql} from 'drizzle-orm';
 import {check, integer, jsonb, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';
@@ -18,7 +22,7 @@ export const workflowRunAttempts = pgTable(
     status: workflowRunStatusEnum('status').notNull().default('pending'),
     rerunMode: workflowRunRerunModeEnum('rerun_mode'),
     rerunByUserId: uuid('rerun_by_user_id'),
-    model: jsonb('model').$type<WorkflowModel>(),
+    model: jsonb('model').$type<WorkflowModel | WorkflowModelSnapshot>(),
     agentToolMaterialization: jsonb(
       'agent_tool_materialization',
     ).$type<AgentToolMaterializationSnapshot>(),
@@ -48,7 +52,7 @@ export function toWorkflowRunAttempt(row: WorkflowRunAttemptDb): WorkflowRunAtte
     status: row.status,
     rerunMode: row.rerunMode ?? null,
     rerunByUserId: row.rerunByUserId,
-    model: row.model ?? null,
+    model: row.model === null ? null : readPersistedWorkflowModel(row.model),
     agentToolMaterialization: row.agentToolMaterialization ?? null,
     version: row.version,
     createdAt: row.createdAt,

package/src/db/schema/workflow-runs.ts

@@ -1,4 +1,4 @@
-import {DEFAULT_RUN_TIMEOUT_MS} from '@shipfox/api-definitions';
+import {DEFAULT_RUN_TIMEOUT_MS} from '@shipfox/api-definitions-dto';
 import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';
 import {sql} from 'drizzle-orm';
 import {

package/src/db/workflow-runs/job-executions.ts

@@ -1,3 +1,5 @@
+import {readPersistedWorkflowModel} from '@shipfox/api-definitions-dto';
+import type {SecretsInterModuleClient} from '@shipfox/api-secrets-dto/inter-module';
 import {WORKFLOWS_JOB_EXECUTION_TIMED_OUT} from '@shipfox/api-workflows-dto';
 import {and, asc, desc, eq, isNull, notInArray, sql} from 'drizzle-orm';
 import type {JobStatusReason} from '#core/entities/job.js';
@@ -116,6 +118,7 @@ export interface UpdateJobExecutionStatusAtVersionParams {
   expectedVersion: number;
   statusReason?: JobStatusReason | null | undefined;
   markTimedOut?: boolean;
+  secrets?: Pick<SecretsInterModuleClient, 'getVariablesByNamespace'> | undefined;
 }
 
 async function resolveJobExecutionOutputs(
@@ -124,6 +127,7 @@ async function resolveJobExecutionOutputs(
     jobExecutionId: string;
     status: JobExecutionStatus;
     statusReason: JobStatusReason | null;
+    secrets?: Pick<SecretsInterModuleClient, 'getVariablesByNamespace'> | undefined;
   },
 ): Promise<Record<string, unknown> | null> {
   const [target] = await tx
@@ -135,7 +139,8 @@ async function resolveJobExecutionOutputs(
     .where(eq(jobExecutions.id, params.jobExecutionId))
     .limit(1);
   if (!target) throw new JobNotFoundError(params.jobExecutionId);
-  const model = target.attempt.model;
+  const model =
+    target.attempt.model === null ? null : readPersistedWorkflowModel(target.attempt.model);
   if (!model) return null;
   const modelJob = model.jobs.find((job) => job.key === target.job.key);
   if (!modelJob || modelJob.outputs === undefined) return null;
@@ -180,6 +185,7 @@ async function resolveJobExecutionOutputs(
       workspaceId: target.run.workspaceId,
       projectId: target.run.projectId,
       definitionId: target.run.definitionId,
+      secrets: params.secrets,
     }),
   });
 }
@@ -200,6 +206,7 @@ async function updateJobExecutionStatusAtVersion(
         jobExecutionId: params.jobExecutionId,
         status,
         statusReason,
+        secrets: params.secrets,
       });
     } catch (error) {
       if (!(error instanceof InterpolationUnresolvableError)) throw error;
@@ -239,6 +246,7 @@ export interface UpdateJobExecutionStatusParams {
   status: JobExecutionStatus;
   expectedVersion: number;
   statusReason?: JobStatusReason | null | undefined;
+  secrets?: Pick<SecretsInterModuleClient, 'getVariablesByNamespace'> | undefined;
 }
 
 export async function updateJobExecutionStatus(
@@ -253,6 +261,7 @@ export async function updateJobExecutionStatus(
           status: params.status,
           expectedVersion: params.expectedVersion,
           statusReason,
+          secrets: params.secrets,
         }),
       fetchFn: async () => {
         const row = (
@@ -308,6 +317,7 @@ export async function failJobExecutionAsTimedOut(params: {
   jobExecutionId: string;
   workflowRunAttemptId: string;
   expectedVersion: number;
+  secrets?: Pick<SecretsInterModuleClient, 'getVariablesByNamespace'> | undefined;
 }): Promise<JobExecution> {
   const result = await db().transaction(async (tx) => {
     const updated = await optimisticLockRetry({
@@ -318,6 +328,7 @@ export async function failJobExecutionAsTimedOut(params: {
           expectedVersion: params.expectedVersion,
           statusReason: 'timed_out',
           markTimedOut: true,
+          secrets: params.secrets,
         }),
       fetchFn: async () => {
         const row = (
@@ -359,6 +370,7 @@ export async function failJobExecutionAsTimedOut(params: {
 export async function resolveJobExecutionAfterLeaseExpiry(params: {
   jobExecutionId: string;
   expectedVersion: number;
+  secrets?: Pick<SecretsInterModuleClient, 'getVariablesByNamespace'> | undefined;
 }): Promise<{status: RuntimeCompletionStatus; executionVersion: number}> {
   const result = await db().transaction(async (tx) => {
     const jobExecutionSteps = await getStepsByJobExecutionIdForUpdate(params.jobExecutionId, tx);
@@ -375,6 +387,7 @@ export async function resolveJobExecutionAfterLeaseExpiry(params: {
         status,
         expectedVersion: params.expectedVersion,
         statusReason: statusReasonForStepCompletion(status),
+        secrets: params.secrets,
       });
       changedJobExecution = updated?.changed ? updated.execution : null;
     } else {
@@ -383,6 +396,7 @@ export async function resolveJobExecutionAfterLeaseExpiry(params: {
         status: 'failed',
         expectedVersion: params.expectedVersion,
         statusReason: 'runner_lost',
+        secrets: params.secrets,
       });
       if (updated?.changed) {
         changedJobExecution = updated.execution;

package/src/db/workflow-runs/jobs.ts

@@ -1,3 +1,4 @@
+import {readPersistedWorkflowModel} from '@shipfox/api-definitions-dto';
 import {WORKFLOWS_JOB_TERMINATED} from '@shipfox/api-workflows-dto';
 import {and, asc, desc, eq, inArray, notInArray, sql} from 'drizzle-orm';
 import {isJobTerminal, type Job, type JobStatus, type JobStatusReason} from '#core/entities/job.js';
@@ -161,7 +162,9 @@ export async function evaluateJobActivations(
       const target = targetsByJobId.get(input.jobId);
       if (!target) throw new Error(`Cannot evaluate missing activation job: ${input.jobId}`);
       const job = toJob(target.job);
-      const modelJob = target.attempt.model?.jobs.find((item) => item.key === target.job.key);
+      const model =
+        target.attempt.model === null ? null : readPersistedWorkflowModel(target.attempt.model);
+      const modelJob = model?.jobs.find((item) => item.key === target.job.key);
       const decision = decideJobActivation({
         run: toWorkflowRun(target.run),
         job,

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

@@ -1,9 +1,11 @@
-import type {AgentDefaultsResolver} from '@shipfox/api-agent/core/resolve-agent-config';
 import {normalizeWorkflowDocument} 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 {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 {db} from '../db.js';
 import {workflowsOutbox} from '../schema/outbox.js';
@@ -45,6 +47,7 @@ describe('workflow run queries', () => {
           subscriptionId: crypto.randomUUID(),
           userId: crypto.randomUUID(),
         },
+        resolveAgentDefaults: resolveTestAgentDefaults,
       });
 
       expect(run.id).toBeDefined();
@@ -121,6 +124,7 @@ describe('workflow run queries', () => {
           subscriptionId: crypto.randomUUID(),
           userId: crypto.randomUUID(),
         },
+        resolveAgentDefaults: resolveTestAgentDefaults,
       });
       const [build, deploy] = await getJobsByWorkflowRunId(run.id);
       if (!build || !deploy) throw new Error('Expected build and deploy jobs');
@@ -564,6 +568,7 @@ describe('workflow run queries', () => {
             subscriptionId: crypto.randomUUID(),
             userId: crypto.randomUUID(),
           },
+          secrets: createTestSecretsClient(),
         });
       } catch (caught) {
         error = caught;
@@ -842,6 +847,7 @@ describe('workflow run queries', () => {
           subscriptionId: crypto.randomUUID(),
           userId: crypto.randomUUID(),
         },
+        resolveAgentDefaults: resolveTestAgentDefaults,
       });
 
       const runJobs = await getJobsByWorkflowRunId(run.id);

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

@@ -1,12 +1,11 @@
-import {
-  type AgentDefaultsResolver,
-  catalogDefaultAgentResolver,
-} from '@shipfox/api-agent/core/resolve-agent-config';
-import type {WorkflowModel} from '@shipfox/api-definitions';
-import {getVariablesByNamespace} from '@shipfox/api-secrets';
+import {createWorkflowModelSnapshot, type WorkflowModel} from '@shipfox/api-definitions-dto';
+import type {IntegrationsModuleClient} from '@shipfox/api-integration-core-dto';
+import type {ProjectsModuleClient} from '@shipfox/api-projects-dto';
+import type {SecretsInterModuleClient} from '@shipfox/api-secrets-dto/inter-module';
 import {analyzeContextKeyAccess, type ResolvedFieldSegment} from '@shipfox/expression';
 import {logger} from '@shipfox/node-opentelemetry';
 import {eq} from 'drizzle-orm';
+import type {AgentDefaultsResolver} from '#core/agent-defaults.js';
 import {
   createAgentToolMaterializationSnapshot,
   loadAgentToolMaterializationContext,
@@ -49,14 +48,22 @@ export interface CreateWorkflowRunParams {
   sourceSnapshot?: WorkflowSourceSnapshot | null | undefined;
   triggerIdempotencyKey?: string | undefined;
   resolveAgentDefaults?: AgentDefaultsResolver | undefined;
+  secrets?: Pick<SecretsInterModuleClient, 'getVariablesByNamespace'> | undefined;
+  integrations?: IntegrationsModuleClient | undefined;
+  projects?: ProjectsModuleClient | undefined;
 }
 
 export async function createWorkflowRun(params: CreateWorkflowRunParams): Promise<WorkflowRun> {
-  const agentToolContext = await loadAgentToolMaterializationContext({
-    model: params.model,
-    workspaceId: params.workspaceId,
-    projectId: params.projectId,
-  });
+  const agentToolContext =
+    params.integrations === undefined
+      ? undefined
+      : await loadAgentToolMaterializationContext({
+          model: params.model,
+          workspaceId: params.workspaceId,
+          projectId: params.projectId,
+          integrations: params.integrations,
+          projects: params.projects,
+        });
   const agentToolMaterialization = createAgentToolMaterializationSnapshot({
     model: params.model,
     context: agentToolContext,
@@ -109,7 +116,7 @@ export async function createWorkflowRun(params: CreateWorkflowRunParams): Promis
         workflowRunId: runRow.id,
         attempt: 1,
         status: 'pending',
-        model: params.model,
+        model: createWorkflowModelSnapshot(params.model),
         agentToolMaterialization,
       })
       .returning();
@@ -125,14 +132,15 @@ export async function createWorkflowRun(params: CreateWorkflowRunParams): Promis
       workspaceId: params.workspaceId,
       projectId: params.projectId,
       definitionId: params.definitionId,
+      secrets: params.secrets,
     });
-    const materializedJobs = materializeWorkflowRunJobs({
+    const materializedJobs = await materializeWorkflowRunJobs({
       run,
       model: params.model,
       triggerPayload: params.triggerPayload,
       inputs: params.inputs ?? null,
       vars,
-      resolveAgentDefaults: params.resolveAgentDefaults ?? catalogDefaultAgentResolver,
+      resolveAgentDefaults: params.resolveAgentDefaults,
       definitionId: params.definitionId,
       agentToolContext,
       agentToolSnapshot: agentToolMaterialization,
@@ -178,12 +186,14 @@ export async function loadReferencedVariables(params: {
   readonly workspaceId: string;
   readonly projectId: string;
   readonly definitionId: string;
+  readonly secrets?: Pick<SecretsInterModuleClient, 'getVariablesByNamespace'> | undefined;
 }): Promise<Record<string, string> | undefined> {
   const references = referencedVariables(params.model, params.jobs ?? params.model.jobs);
   const keys = [...new Set(references.map((reference) => reference.key))].sort();
   if (keys.length === 0) return undefined;
 
-  const vars = await getVariablesByNamespace({
+  if (!params.secrets) throw new Error('Secrets client is not configured.');
+  const {values: vars} = await params.secrets.getVariablesByNamespace({
     workspaceId: params.workspaceId,
     projectId: params.projectId,
     namespace: '',

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

@@ -1,5 +1,5 @@
-import type {AgentDefaultsResolver} from '@shipfox/api-agent/core/resolve-agent-config';
 import {eq, inArray} from 'drizzle-orm';
+import type {AgentDefaultsResolver} from '#core/agent-defaults.js';
 import type {AgentToolMaterializationSnapshot} from '#core/agent-tools.js';
 import {NoFailedJobsError, RunNotTerminalError, SourceRunNotFoundError} from '#core/errors.js';
 import {nextStepForJob, recordStepResult} from '#core/job-execution.js';