@shipfox/api-definitions 7.1.0 → 8.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-definitions",
   "license": "MIT",
-  "version": "7.1.0",
+  "version": "8.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -30,11 +30,11 @@
     "js-yaml": "^4.1.0",
     "yaml": "^2.8.3",
     "zod": "^4.4.3",
-    "@shipfox/api-agent-dto": "6.0.0",
+    "@shipfox/api-agent-dto": "8.0.0",
     "@shipfox/api-auth-context": "7.1.0",
     "@shipfox/api-definitions-dto": "6.0.0",
-    "@shipfox/api-integration-core-dto": "6.0.0",
-    "@shipfox/api-projects-dto": "6.0.0",
+    "@shipfox/api-integration-core-dto": "8.0.0",
+    "@shipfox/api-projects-dto": "8.0.0",
     "@shipfox/api-secrets-dto": "6.0.0",
     "@shipfox/config": "1.2.2",
     "@shipfox/expression": "1.1.3",

package/src/config.ts

@@ -1,8 +1,4 @@
-import {
-  buildHarnessToolDeploymentConfig,
-  type HarnessToolDeploymentConfig,
-} from '@shipfox/api-agent-dto';
-import {bool, createConfig, str} from '@shipfox/config';
+import {createConfig, str} from '@shipfox/config';
 import {findInvalidLabels, MAX_RUNNER_LABELS, parseLabelList} from '@shipfox/runner-labels';
 
 export const config = createConfig({
@@ -10,14 +6,6 @@ export const config = createConfig({
     desc: 'Default runner label(s) applied to workflow jobs that do not declare a "runner" at the job or workflow level. Set it to a comma-separated list, for example ubuntu-latest or ubuntu-latest,node-22. Leave it empty to require every workflow job to declare runner labels explicitly; with no value set, a job without a runner fails definition validation.',
     default: '',
   }),
-  AGENT_PI_ENABLED_TOOL_PACKAGES: str({
-    desc: 'Comma-separated optional Pi tool packages enabled for this deployment. Defaults to pi-web-access so Pi web access is available. Set it to an empty value to enable only Pi built-in tools. Accepted values: pi-web-access.',
-    default: 'pi-web-access',
-  }),
-  AGENT_PI_WEB_SEARCH_ENABLED: bool({
-    desc: 'Enables Pi web search tools when pi-web-access is enabled. Set it to false to disable web_search and get_search_content while keeping fetch_content available.',
-    default: true,
-  }),
 });
 
 export function parseDefinitionDefaultRunnerLabels(value: string): readonly string[] {
@@ -42,9 +30,3 @@ export function parseDefinitionDefaultRunnerLabels(value: string): readonly stri
 export const definitionDefaultRunnerLabels = parseDefinitionDefaultRunnerLabels(
   config.DEFINITION_DEFAULT_RUNNER_LABEL,
 );
-
-export const definitionHarnessToolDeploymentConfig: HarnessToolDeploymentConfig =
-  buildHarnessToolDeploymentConfig({
-    piEnabledToolPackages: config.AGENT_PI_ENABLED_TOOL_PACKAGES,
-    piWebSearchEnabled: config.AGENT_PI_WEB_SEARCH_ENABLED,
-  });

package/src/core/index.ts

@@ -1,5 +1,8 @@
 export type * from './entities/index.js';
-export {DefinitionParseError, DefinitionSyncPermanentError} from './errors.js';
+export {
+  DefinitionParseError,
+  DefinitionSyncPermanentError,
+} from './errors.js';
 export {parseDefinition} from './parse-definition.js';
 export {
   classifySyncFailure,

package/src/core/integrations.ts

@@ -1,7 +1,7 @@
 import {
   type IntegrationsModuleClient,
   integrationsInterModuleContract,
-} from '@shipfox/api-integration-core-dto';
+} from '@shipfox/api-integration-core-dto/inter-module';
 
 export type DefinitionsSourceControl = {
   resolveRepository: IntegrationsModuleClient['resolveSourceRepository'];

package/src/core/parse-definition.test.ts

@@ -1,11 +1,16 @@
 import {readFileSync} from 'node:fs';
 import {dirname, resolve} from 'node:path';
 import {fileURLToPath} from 'node:url';
+import {agentValidationCatalog} from '#test/agent-validation-catalog.js';
 import {DefinitionParseError} from './errors.js';
-import {parseDefinition} from './parse-definition.js';
+import {parseDefinition as parseDefinitionBase} from './parse-definition.js';
 
 const fixturesDir = resolve(dirname(fileURLToPath(import.meta.url)), '../../test/fixtures');
 
+function parseDefinition(yaml: string, options = {}) {
+  return parseDefinitionBase(yaml, {agentValidationCatalog, ...options});
+}
+
 function readFixture(name: string): string {
   return readFileSync(resolve(fixturesDir, name), 'utf-8');
 }

package/src/core/parse-definition.ts

@@ -1,4 +1,4 @@
-import type {HarnessToolDeploymentConfig} from '@shipfox/api-agent-dto';
+import type {AgentValidationCatalog} from '@shipfox/api-agent-dto/inter-module';
 import type {IntegrationValidationContext} from './entities/integration-context.js';
 import type {WorkflowDefinitionPayload} from './entities/workflow-definition.js';
 import {DefinitionParseError} from './errors.js';
@@ -6,9 +6,9 @@ import {validateDefinition} from './validate-definition.js';
 
 export function parseDefinition(
   yamlString: string,
-  options?: {
+  options: {
     defaultRunnerLabels?: readonly string[];
-    harnessToolDeploymentConfig?: HarnessToolDeploymentConfig;
+    agentValidationCatalog: AgentValidationCatalog;
     integrationValidationContext?: IntegrationValidationContext;
   },
 ): WorkflowDefinitionPayload {

package/src/core/sync-definitions.test.ts

@@ -1,16 +1,23 @@
 import type {IntegrationSourceControlService} from '@shipfox/api-integration-core';
-import {integrationsInterModuleContract} from '@shipfox/api-integration-core-dto';
+import {integrationsInterModuleContract} from '@shipfox/api-integration-core-dto/inter-module';
 import {createInterModuleKnownError} from '@shipfox/inter-module';
 import {LOWERCASE_SHA256_HEX_RE} from '@shipfox/regex';
+import {agentValidationCatalog} from '#test/agent-validation-catalog.js';
 import type {IntegrationValidationContext} from './entities/integration-context.js';
 import {DefinitionSyncPermanentError} from './errors.js';
 import {
   classifySyncFailure,
   discoverWorkflowFiles,
-  fetchAndParseWorkflows,
+  fetchAndParseWorkflows as fetchAndParseWorkflowsBase,
   resolveSyncSource,
 } from './sync-definitions.js';
 
+function fetchAndParseWorkflows(
+  params: Omit<Parameters<typeof fetchAndParseWorkflowsBase>[0], 'agentValidationCatalog'>,
+) {
+  return fetchAndParseWorkflowsBase({...params, agentValidationCatalog});
+}
+
 const validYaml = `
 name: CI
 runner: ubuntu-latest

package/src/core/sync-definitions.ts

@@ -1,8 +1,7 @@
 import {createHash} from 'node:crypto';
-import {
-  integrationsInterModuleContract,
-  MAX_REPOSITORY_FILE_BYTES,
-} from '@shipfox/api-integration-core-dto';
+import type {AgentValidationCatalog} from '@shipfox/api-agent-dto/inter-module';
+import {MAX_REPOSITORY_FILE_BYTES} from '@shipfox/api-integration-core-dto';
+import {integrationsInterModuleContract} from '@shipfox/api-integration-core-dto/inter-module';
 import {isInterModuleKnownError} from '@shipfox/inter-module';
 import {boundedMap} from '@shipfox/node-module';
 import type {IntegrationValidationContext} from './entities/integration-context.js';
@@ -84,6 +83,7 @@ export interface FetchAndParseWorkflowsParams extends SyncSourceContext {
   ref: string;
   paths: string[];
   onProgress?: ((path: string) => void) | undefined;
+  agentValidationCatalog: AgentValidationCatalog;
   loadIntegrationValidationContext?: (() => Promise<IntegrationValidationContext>) | undefined;
 }
 
@@ -112,7 +112,11 @@ export async function fetchAndParseWorkflows(
       }
 
       return {
-        ...parseWorkflowSnapshot({path: snapshot.path, content: snapshot.content}),
+        ...parseWorkflowSnapshot({
+          path: snapshot.path,
+          content: snapshot.content,
+          agentValidationCatalog: params.agentValidationCatalog,
+        }),
         rawContent: snapshot.content,
       };
     },
@@ -131,6 +135,7 @@ export async function fetchAndParseWorkflows(
     parseWorkflowSnapshot({
       path: entry.path,
       content: entry.rawContent,
+      agentValidationCatalog: params.agentValidationCatalog,
       integrationValidationContext,
     }),
   );
@@ -140,12 +145,14 @@ function parseWorkflowSnapshot(params: {
   path: string;
   content: string;
   integrationValidationContext?: IntegrationValidationContext | undefined;
+  agentValidationCatalog: AgentValidationCatalog;
 }): ParsedWorkflow {
   try {
     const definition =
       params.integrationValidationContext === undefined
-        ? parseDefinition(params.content)
+        ? parseDefinition(params.content, {agentValidationCatalog: params.agentValidationCatalog})
         : parseDefinition(params.content, {
+            agentValidationCatalog: params.agentValidationCatalog,
             integrationValidationContext: params.integrationValidationContext,
           });
     const contentHash = sha256Hex(params.content);

package/src/core/validate-definition.test.ts

@@ -1,4 +1,9 @@
-import {validateDefinition} from './validate-definition.js';
+import {agentValidationCatalog} from '#test/agent-validation-catalog.js';
+import {validateDefinition as validateDefinitionBase} from './validate-definition.js';
+
+function validateDefinition(yaml: string, options = {}) {
+  return validateDefinitionBase(yaml, {agentValidationCatalog, ...options});
+}
 
 describe('validateDefinition', () => {
   test('valid YAML returns { valid: true, definition }', () => {
@@ -129,9 +134,18 @@ jobs:
 `;
 
     const result = validateDefinition(yaml, {
-      harnessToolDeploymentConfig: {
-        pi: {enabledToolPackages: ['pi-web-access'], webSearchEnabled: false},
-        claude: {enabledToolPackages: []},
+      agentValidationCatalog: {
+        ...agentValidationCatalog,
+        harnesses: agentValidationCatalog.harnesses.map((harness) => {
+          if (harness.id !== 'pi') return harness;
+          return {
+            ...harness,
+            effective_tools: harness.effective_tools.filter(
+              (tool) =>
+                tool === 'fetch_content' || !['web_search', 'get_search_content'].includes(tool),
+            ),
+          };
+        }),
       },
     });
 

package/src/core/validate-definition.ts

@@ -1,6 +1,6 @@
-import type {HarnessToolDeploymentConfig} from '@shipfox/api-agent-dto';
+import type {AgentValidationCatalog} from '@shipfox/api-agent-dto/inter-module';
 import {InvalidWorkflowDocumentError} from '@shipfox/workflow-document';
-import {definitionDefaultRunnerLabels, definitionHarnessToolDeploymentConfig} from '../config.js';
+import {definitionDefaultRunnerLabels} from '../config.js';
 import type {IntegrationValidationContext} from './entities/integration-context.js';
 import type {WorkflowDefinitionPayload} from './entities/workflow-definition.js';
 import {InvalidWorkflowModelError, normalizeWorkflowDocument} from './workflow-model/index.js';
@@ -16,16 +16,15 @@ export function validateDefinition(
   yamlContent: string,
   options: {
     defaultRunnerLabels?: readonly string[];
-    harnessToolDeploymentConfig?: HarnessToolDeploymentConfig;
+    agentValidationCatalog: AgentValidationCatalog;
     integrationValidationContext?: IntegrationValidationContext;
-  } = {},
+  },
 ): ValidationResult {
   try {
     const {document, stepSourceLocations} = parseWorkflowYamlWithLocations(yamlContent);
     const model = normalizeWorkflowDocument(document, {
       defaultRunnerLabels: options.defaultRunnerLabels ?? definitionDefaultRunnerLabels,
-      harnessToolDeploymentConfig:
-        options.harnessToolDeploymentConfig ?? definitionHarnessToolDeploymentConfig,
+      agentValidationCatalog: options.agentValidationCatalog,
       integrationValidationContext: options.integrationValidationContext,
       stepSourceLocations,
     });

package/src/core/workflow-model/normalize-jobs.ts

@@ -1,10 +1,4 @@
-import {
-  agentThinkingByHarness,
-  getHarnessDescriptor,
-  getModelProviderEntry,
-  type HarnessToolDeploymentConfig,
-  listEnabledHarnessTools,
-} from '@shipfox/api-agent-dto';
+import type {AgentValidationCatalog} from '@shipfox/api-agent-dto/inter-module';
 import {
   type AvailabilitySite,
   buildTypedRootsEnvironment,
@@ -53,7 +47,7 @@ import {issue} from './validation-issue.js';
 
 export interface NormalizeContext {
   readonly defaultRunnerLabels: readonly string[];
-  readonly harnessToolDeploymentConfig: HarnessToolDeploymentConfig;
+  readonly agentValidationCatalog: AgentValidationCatalog;
   readonly integrationValidationContext?: IntegrationValidationContext | undefined;
 }
 
@@ -719,7 +713,7 @@ function normalizeAgentStep(params: {
     stepIndex: params.stepIndex,
     issues: params.issues,
     validateLiteralProvider: providerTemplate === undefined,
-    harnessToolDeploymentConfig: params.context.harnessToolDeploymentConfig,
+    agentValidationCatalog: params.context.agentValidationCatalog,
   });
   const integrations = normalizeAgentIntegrations({
     integrations: params.step.integrations,
@@ -755,7 +749,7 @@ function validateAgentStep(params: {
   stepIndex: number;
   issues: WorkflowModelValidationIssue[];
   validateLiteralProvider: boolean;
-  harnessToolDeploymentConfig: HarnessToolDeploymentConfig;
+  agentValidationCatalog: AgentValidationCatalog;
 }): void {
   validateHarnessThinking(params);
   validateHarnessTools(params);
@@ -764,7 +758,7 @@ function validateAgentStep(params: {
   const providerId = params.step.provider;
   if (providerId === undefined) return;
 
-  const provider = getModelProviderEntry(providerId);
+  const provider = params.agentValidationCatalog.providers.find((entry) => entry.id === providerId);
   const harness = params.step.harness;
   if (provider === undefined && harness === 'pi') return;
 
@@ -782,15 +776,19 @@ function validateAgentStep(params: {
 
   if (harness === undefined) return;
 
-  const descriptor = getHarnessDescriptor(harness);
-  if (descriptor.supportedProviderIds.includes(providerId)) return;
+  const descriptor = params.agentValidationCatalog.harnesses.find((entry) => entry.id === harness);
+  if (descriptor?.supported_provider_ids.includes(providerId)) return;
 
   params.issues.push(
     issue({
       code: 'harness-provider-incompatible',
-      message: `Harness "${harness}" does not support provider: ${providerId}. Supported providers: ${descriptor.supportedProviderIds.join(', ')}.`,
+      message: `Harness "${harness}" does not support provider: ${providerId}. Supported providers: ${descriptor?.supported_provider_ids.join(', ') ?? ''}.`,
       path: ['jobs', params.sourceName, 'steps', params.stepIndex, 'provider'],
-      details: {harness, provider: providerId, supportedProviders: descriptor.supportedProviderIds},
+      details: {
+        harness,
+        provider: providerId,
+        supportedProviders: descriptor?.supported_provider_ids ?? [],
+      },
     }),
   );
 }
@@ -800,7 +798,7 @@ function validateHarnessTools(params: {
   sourceName: string;
   stepIndex: number;
   issues: WorkflowModelValidationIssue[];
-  harnessToolDeploymentConfig: HarnessToolDeploymentConfig;
+  agentValidationCatalog: AgentValidationCatalog;
 }): void {
   const {harness, tools} = params.step;
   if (tools === undefined) return;
@@ -818,9 +816,9 @@ function validateHarnessTools(params: {
     return;
   }
 
-  const supportedTools = listEnabledHarnessTools(harness, params.harnessToolDeploymentConfig).map(
-    (tool) => tool.name,
-  );
+  const supportedTools =
+    params.agentValidationCatalog.harnesses.find((entry) => entry.id === harness)
+      ?.effective_tools ?? [];
   const supportedToolSet = new Set(supportedTools);
 
   tools.forEach((tool, toolIndex) => {
@@ -842,14 +840,15 @@ function validateHarnessThinking(params: {
   sourceName: string;
   stepIndex: number;
   issues: WorkflowModelValidationIssue[];
+  agentValidationCatalog: AgentValidationCatalog;
 }): void {
   const {harness, thinking} = params.step;
   if (harness === undefined || thinking === undefined) return;
 
-  const thinkingSchema = agentThinkingByHarness[harness];
-  if (thinkingSchema.safeParse(thinking).success) return;
-
-  const supportedLevels = thinkingSchema.options;
+  const supportedLevels =
+    params.agentValidationCatalog.harnesses.find((entry) => entry.id === harness)
+      ?.thinking_levels ?? [];
+  if (supportedLevels.includes(thinking)) return;
   params.issues.push(
     issue({
       code: 'harness-thinking-incompatible',

package/src/core/workflow-model/normalize-workflow-document.test.ts

@@ -1,4 +1,5 @@
 import type {WorkflowDocument} from '@shipfox/workflow-document';
+import {agentValidationCatalog} from '#test/agent-validation-catalog.js';
 import type {IntegrationValidationContext} from '../entities/integration-context.js';
 import {InvalidWorkflowModelError} from './invalid-workflow-model-error.js';
 import {DEFAULT_JOB_CHECKOUT} from './normalize-job-checkout.js';
@@ -6,14 +7,22 @@ import {normalizeWorkflowDocument as normalizeWorkflowDocumentBase} from './norm
 
 function normalizeWorkflowDocument(
   document: WorkflowDocument,
-  options?: Parameters<typeof normalizeWorkflowDocumentBase>[1],
+  options?: Omit<Parameters<typeof normalizeWorkflowDocumentBase>[1], 'agentValidationCatalog'> &
+    Partial<Pick<Parameters<typeof normalizeWorkflowDocumentBase>[1], 'agentValidationCatalog'>>,
 ) {
-  return normalizeWorkflowDocumentBase({runner: 'ubuntu-latest', ...document}, options);
+  return normalizeWorkflowDocumentBase(
+    {runner: 'ubuntu-latest', ...document},
+    {
+      agentValidationCatalog: options?.agentValidationCatalog ?? agentValidationCatalog,
+      ...options,
+    },
+  );
 }
 
 function expectInvalid(
   document: WorkflowDocument,
-  options?: Parameters<typeof normalizeWorkflowDocumentBase>[1],
+  options?: Omit<Parameters<typeof normalizeWorkflowDocumentBase>[1], 'agentValidationCatalog'> &
+    Partial<Pick<Parameters<typeof normalizeWorkflowDocumentBase>[1], 'agentValidationCatalog'>>,
 ): InvalidWorkflowModelError {
   try {
     normalizeWorkflowDocument(document, options);
@@ -578,12 +587,7 @@ describe('normalizeWorkflowDocument', () => {
       },
     };
 
-    const error = expectInvalid(document, {
-      harnessToolDeploymentConfig: {
-        pi: {enabledToolPackages: ['pi-web-access'], webSearchEnabled: true},
-        claude: {enabledToolPackages: []},
-      },
-    });
+    const error = expectInvalid(document);
 
     expect(error.issues).toEqual([
       {
@@ -670,9 +674,20 @@ describe('normalizeWorkflowDocument', () => {
     };
 
     const error = expectInvalid(document, {
-      harnessToolDeploymentConfig: {
-        pi: {enabledToolPackages: ['pi-web-access'], webSearchEnabled: false},
-        claude: {enabledToolPackages: []},
+      agentValidationCatalog: {
+        ...agentValidationCatalog,
+        harnesses: agentValidationCatalog.harnesses.map((harness) =>
+          harness.id === 'pi'
+            ? {
+                ...harness,
+                effective_tools: harness.effective_tools.filter(
+                  (tool) =>
+                    tool === 'fetch_content' ||
+                    !['web_search', 'get_search_content'].includes(tool),
+                ),
+              }
+            : harness,
+        ),
       },
     });
 
@@ -1169,7 +1184,7 @@ describe('normalizeWorkflowDocument', () => {
     };
 
     try {
-      normalizeWorkflowDocumentBase(document);
+      normalizeWorkflowDocumentBase(document, {agentValidationCatalog});
       expect.fail('Expected InvalidWorkflowModelError');
     } catch (error) {
       expect(error).toBeInstanceOf(InvalidWorkflowModelError);
@@ -1193,6 +1208,7 @@ describe('normalizeWorkflowDocument', () => {
     };
 
     const model = normalizeWorkflowDocumentBase(document, {
+      agentValidationCatalog,
       defaultRunnerLabels: [' Ubuntu ', 'ubuntu'],
     });
 
@@ -1211,7 +1227,10 @@ describe('normalizeWorkflowDocument', () => {
     };
 
     try {
-      normalizeWorkflowDocumentBase(document, {defaultRunnerLabels: ['ubuntu-latest']});
+      normalizeWorkflowDocumentBase(document, {
+        agentValidationCatalog,
+        defaultRunnerLabels: ['ubuntu-latest'],
+      });
       expect.fail('Expected InvalidWorkflowModelError');
     } catch (error) {
       expect(error).toBeInstanceOf(InvalidWorkflowModelError);
@@ -1253,7 +1272,7 @@ describe('normalizeWorkflowDocument', () => {
     };
 
     try {
-      normalizeWorkflowDocumentBase(document);
+      normalizeWorkflowDocumentBase(document, {agentValidationCatalog});
       expect.fail('Expected InvalidWorkflowModelError');
     } catch (error) {
       expect(error).toBeInstanceOf(InvalidWorkflowModelError);
@@ -1279,7 +1298,7 @@ describe('normalizeWorkflowDocument', () => {
     };
 
     try {
-      normalizeWorkflowDocumentBase(document);
+      normalizeWorkflowDocumentBase(document, {agentValidationCatalog});
       expect.fail('Expected InvalidWorkflowModelError');
     } catch (error) {
       expect(error).toBeInstanceOf(InvalidWorkflowModelError);
@@ -1349,7 +1368,7 @@ describe('normalizeWorkflowDocument', () => {
     };
 
     try {
-      normalizeWorkflowDocumentBase(document);
+      normalizeWorkflowDocumentBase(document, {agentValidationCatalog});
       expect.fail('Expected InvalidWorkflowModelError');
     } catch (error) {
       expect(error).toBeInstanceOf(InvalidWorkflowModelError);
@@ -1378,7 +1397,7 @@ describe('normalizeWorkflowDocument', () => {
       },
     };
 
-    const model = normalizeWorkflowDocumentBase(document);
+    const model = normalizeWorkflowDocumentBase(document, {agentValidationCatalog});
 
     expect(model.jobs[0]?.runner).toHaveLength(20);
   });

package/src/core/workflow-model/normalize-workflow-document.ts

@@ -1,7 +1,4 @@
-import {
-  DEFAULT_HARNESS_TOOL_DEPLOYMENT_CONFIG,
-  type HarnessToolDeploymentConfig,
-} from '@shipfox/api-agent-dto';
+import type {AgentValidationCatalog} from '@shipfox/api-agent-dto/inter-module';
 import {canonicalizeLabels} from '@shipfox/runner-labels';
 import type {WorkflowDocument} from '@shipfox/workflow-document';
 import type {IntegrationValidationContext} from '../entities/integration-context.js';
@@ -20,18 +17,16 @@ export function normalizeWorkflowDocument(
   document: WorkflowDocument,
   options: {
     defaultRunnerLabels?: readonly string[] | undefined;
-    harnessToolDeploymentConfig?: HarnessToolDeploymentConfig | undefined;
+    agentValidationCatalog: AgentValidationCatalog;
     integrationValidationContext?: IntegrationValidationContext | undefined;
     stepSourceLocations?: WorkflowStepSourceLocationMap | undefined;
-  } = {},
+  },
 ): WorkflowModel {
   const issues: WorkflowModelValidationIssue[] = [];
   const defaultRunnerLabels = canonicalizeLabels(options.defaultRunnerLabels);
-  const harnessToolDeploymentConfig =
-    options.harnessToolDeploymentConfig ?? DEFAULT_HARNESS_TOOL_DEPLOYMENT_CONFIG;
   const context = {
     defaultRunnerLabels,
-    harnessToolDeploymentConfig,
+    agentValidationCatalog: options.agentValidationCatalog,
     integrationValidationContext: options.integrationValidationContext,
   };
   const jobIdBySourceName = mapJobIds(document, issues);

package/src/db/definitions.test.ts

@@ -18,6 +18,7 @@ import {
 import {sql} from 'drizzle-orm';
 import type {WorkflowDefinitionPayload} from '#core/entities/workflow-definition.js';
 import {normalizeWorkflowDocument} from '#core/workflow-model/index.js';
+import {agentValidationCatalog} from '#test/agent-validation-catalog.js';
 import {db} from './db.js';
 import {
   applyVcsDefinitionsBatch,
@@ -82,7 +83,7 @@ function definitionFields(name = 'Test Workflow'): WorkflowDefinitionPayload {
 function definitionFieldsForDocument(
   document: WorkflowDefinitionPayload['document'],
 ): WorkflowDefinitionPayload {
-  return {document, model: normalizeWorkflowDocument(document)};
+  return {document, model: normalizeWorkflowDocument(document, {agentValidationCatalog})};
 }
 
 async function listOutboxRowsForProject(projectId: string) {

package/src/db/schema/definitions.test.ts

@@ -1,4 +1,5 @@
 import {normalizeWorkflowDocument} from '#core/workflow-model/index.js';
+import {agentValidationCatalog} from '#test/agent-validation-catalog.js';
 import type {DefinitionDb} from './definitions.js';
 import {toDefinition} from './definitions.js';
 
@@ -21,7 +22,7 @@ describe('toDefinition', () => {
       sha: null,
       ref: null,
       name: 'Manual workflow',
-      definition: {document, model: normalizeWorkflowDocument(document)},
+      definition: {document, model: normalizeWorkflowDocument(document, {agentValidationCatalog})},
       contentHash: null,
       fetchedAt: new Date('2026-06-09T10:00:00.000Z'),
       createdAt: new Date('2026-06-09T10:00:01.000Z'),

package/src/index.ts

@@ -1,17 +1,18 @@
 import {dirname, resolve} from 'node:path';
 import {fileURLToPath} from 'node:url';
+import type {AgentInterModuleClient} from '@shipfox/api-agent-dto/inter-module';
 import {
   DEFINITION_RESOLVED,
   type DefinitionsEventMap,
   definitionsEventSchemas,
 } from '@shipfox/api-definitions-dto';
-import type {IntegrationsModuleClient} from '@shipfox/api-integration-core-dto';
-import type {ProjectsModuleClient} from '@shipfox/api-projects-dto';
+import type {IntegrationsModuleClient} from '@shipfox/api-integration-core-dto/inter-module';
 import {
   PROJECT_SOURCE_BOUND,
   PROJECT_SOURCE_COMMIT_OBSERVED,
   type ProjectsEventMap,
 } from '@shipfox/api-projects-dto';
+import type {ProjectsModuleClient} from '@shipfox/api-projects-dto/inter-module';
 import {type ShipfoxModule, subscriberFactory} from '@shipfox/node-module';
 import {logger} from '@shipfox/node-opentelemetry';
 import {createDefinitionsSourceControl} from '#core/integrations.js';
@@ -48,11 +49,13 @@ const subscriber = subscriberFactory<DefinitionsEventMap & ProjectsEventMap>();
 
 export interface CreateDefinitionsModuleOptions {
   projects: ProjectsModuleClient;
+  agent: AgentInterModuleClient;
   integrations: IntegrationsModuleClient;
 }
 
 export function createDefinitionsModule({
   projects,
+  agent,
   integrations,
 }: CreateDefinitionsModuleOptions): ShipfoxModule {
   const sourceControl = createDefinitionsSourceControl(integrations);
@@ -60,7 +63,7 @@ export function createDefinitionsModule({
   return {
     name: 'definitions',
     database: {db, migrationsPath},
-    routes: createDefinitionRoutes({projects, integrations}),
+    routes: createDefinitionRoutes({projects, agent, integrations}),
     publishers: [
       {name: 'definitions', table: definitionsOutbox, db, eventSchemas: definitionsEventSchemas},
     ],
@@ -76,7 +79,7 @@ export function createDefinitionsModule({
       {
         taskQueue: DEFINITIONS_TASK_QUEUE,
         workflowsPath,
-        activities: () => createDefinitionSyncActivities(sourceControl, integrations),
+        activities: () => createDefinitionSyncActivities(sourceControl, agent, integrations),
         workflows: [],
       },
     ],

package/src/presentation/dto/definition.test.ts

@@ -1,5 +1,6 @@
 import type {WorkflowDefinition} from '#core/entities/workflow-definition.js';
 import {normalizeWorkflowDocument} from '#core/workflow-model/index.js';
+import {agentValidationCatalog} from '#test/agent-validation-catalog.js';
 import {toDefinitionDto} from './definition.js';
 
 describe('toDefinitionDto', () => {
@@ -29,7 +30,7 @@ describe('toDefinitionDto', () => {
       name: document.name,
       definition: document,
       document,
-      model: normalizeWorkflowDocument(document),
+      model: normalizeWorkflowDocument(document, {agentValidationCatalog}),
       sourceSnapshot: null,
       contentHash: null,
       fetchedAt: new Date('2026-06-09T10:00:00.000Z'),