@copado/agentia-cli 0.84.0-alpha.0 → 0.86.0-alpha.0

package/dist/lib/mcp/tools.d.ts

@@ -7,13 +7,14 @@ import { type JobListFilters } from '../job-types.js';
 import { type ComparisonMode, type ContentSource, type DependencyResult, type IndexSearchResult, type IndexSource, type MetadataContentResult, type ModuleType, type OrderDirection, type PlatformExperience, type RetrieveMode } from '../metadata-common.js';
 import { type IndexRefreshResult, type RefreshDeletedMetadataIndexResult } from '../metadata-refresh.js';
 import { NAVIGATION_RESOURCE_TYPES } from '../navigation.js';
-import { type PipelineConnection, type PipelineDescribe, type PipelineListFilters } from '../pipeline-types.js';
+import { type Pipeline, type PipelineConnection, type PipelineListFilters } from '../pipeline-types.js';
 import { type ProjectDefaultScope } from '../project-defaults.js';
 import { type Project, type ProjectListFilters } from '../project-types.js';
 import { type PromotionConflict, type PromotionConflictMode, type PromotionConflictResolutionResult, type PromotionConflictUndoResult } from '../promotion-conflicts.js';
 import { type PromotionOperation } from '../promotion-run.js';
 import { type PromotionDetail, type PromotionListFilters } from '../promotion-types.js';
 import { type GitRepository, type RepositoryListFilters, type RepositoryValidateResult } from '../repository-types.js';
+import { type PipelineStageConnection, type Stage } from '../stage-types.js';
 import { type User } from '../user-types.js';
 import { type HeadlessWorkStatusResult } from '../work-types.js';
 type EnvironmentCreateArgs = {
@@ -111,6 +112,76 @@ type RepositoryCreateArgs = RepositoryMutationArgs & {
 type RepositoryUpdateArgs = RepositoryMutationArgs & {
     id: string;
 };
+type PipelineMutationArgs = {
+    active?: boolean;
+    blockCommits?: boolean;
+    calculateBasedOn?: string;
+    enableSmartConflictResolution?: boolean;
+    gitRepositoryId?: string;
+    id?: string;
+    mainBranch?: string;
+    name?: string;
+    platform?: string;
+};
+type PipelineCreateArgs = PipelineMutationArgs & {
+    name: string;
+};
+type PipelineUpdateArgs = PipelineMutationArgs & {
+    id: string;
+};
+type StageMutationArgs = {
+    metaStage?: string;
+    name?: string;
+};
+type StageCreateArgs = StageMutationArgs & {
+    name: string;
+};
+type StageUpdateArgs = StageMutationArgs & {
+    id: string;
+};
+type StageDeleteArgs = {
+    id: string;
+};
+type PipelineStageConnectionCreateArgs = {
+    nextPipelineStageConnectionId?: string;
+    pipelineId: string;
+    stageId: string;
+};
+type PipelineStageConnectionListArgs = {
+    pipelineId: string;
+};
+type PipelineStageConnectionUpdateArgs = {
+    connectionId: string;
+    nextPipelineStageConnectionId?: string;
+    pipelineId: string;
+    stageId?: string;
+};
+type PipelineStageConnectionDeleteArgs = {
+    connectionId: string;
+    pipelineId: string;
+};
+type PipelineConnectionMutationArgs = {
+    branch?: string;
+    destinationBranch?: string;
+    destinationEnvironmentId?: string;
+    id?: string;
+    sourceEnvironmentId?: string;
+    stageConnectionId?: string;
+    syncMergeState?: string;
+    syncPullState?: string;
+};
+type PipelineConnectionCreateArgs = PipelineConnectionMutationArgs & {
+    connections?: PipelineConnectionMutationArgs[];
+    pipelineId: string;
+};
+type PipelineConnectionUpdateArgs = {
+    connections: PipelineConnectionMutationArgs[];
+    pipelineId: string;
+};
+type PipelineConnectionDeleteArgs = {
+    connectionIds: string[];
+    pipelineId: string;
+};
 type MetadataListArgs = {
     avoidSourceTracking?: boolean;
     changeDateFrom?: string;
@@ -234,13 +305,60 @@ declare function pipelineList(args?: PipelineListFilters): Promise<Record<string
 declare function pipelineGet(args: {
     id: string;
 }): Promise<{
-    pipeline: PipelineDescribe;
+    pipeline: import("../pipeline-types.js").PipelineDescribe;
 }>;
 declare function pipelineConnectionList(args: {
     pipelineId?: string;
 }): Promise<{
     connections: PipelineConnection[];
 }>;
+declare function pipelineCreate(args: PipelineCreateArgs): Promise<{
+    pipeline: Pipeline;
+}>;
+declare function pipelineUpdate(args: PipelineUpdateArgs): Promise<{
+    pipeline: Pipeline;
+}>;
+declare function pipelineConnectionCreate(args: PipelineConnectionCreateArgs): Promise<{
+    connections: PipelineConnection[];
+}>;
+declare function pipelineConnectionUpdate(args: PipelineConnectionUpdateArgs): Promise<{
+    connections: PipelineConnection[];
+}>;
+declare function pipelineConnectionDelete(args: PipelineConnectionDeleteArgs): Promise<{
+    connectionIds: string[];
+    pipelineId: string;
+}>;
+declare function stageList(args?: {
+    cursor?: string;
+    pageSize?: number;
+}): Promise<Record<string, unknown>>;
+declare function stageGet(args: {
+    id: string;
+}): Promise<{
+    stage: Stage;
+}>;
+declare function stageCreate(args: StageCreateArgs): Promise<{
+    stage: Stage;
+}>;
+declare function stageUpdate(args: StageUpdateArgs): Promise<{
+    stage: Stage;
+}>;
+declare function stageDelete(args: StageDeleteArgs): Promise<{
+    id: string;
+}>;
+declare function pipelineStageConnectionCreate(args: PipelineStageConnectionCreateArgs): Promise<{
+    connection: PipelineStageConnection;
+}>;
+declare function pipelineStageConnectionList(args: PipelineStageConnectionListArgs): Promise<{
+    connections: PipelineStageConnection[];
+}>;
+declare function pipelineStageConnectionUpdate(args: PipelineStageConnectionUpdateArgs): Promise<{
+    connection: PipelineStageConnection;
+}>;
+declare function pipelineStageConnectionDelete(args: PipelineStageConnectionDeleteArgs): Promise<{
+    connectionId: string;
+    pipelineId: string;
+}>;
 declare function projectList(args?: ProjectListFilters): Promise<Record<string, unknown>>;
 declare function repositoryList(args?: RepositoryListFilters): Promise<Record<string, unknown>>;
 declare function repositoryGet(args: {
@@ -1085,9 +1203,18 @@ export declare const agentiaMcpToolHandlers: {
     metadataRefreshRun: typeof metadataRefreshRun;
     metadataRefreshStatus: typeof metadataRefreshStatus;
     navigationResolve: typeof navigationResolve;
+    pipelineConnectionCreate: typeof pipelineConnectionCreate;
+    pipelineConnectionDelete: typeof pipelineConnectionDelete;
     pipelineConnectionList: typeof pipelineConnectionList;
+    pipelineConnectionUpdate: typeof pipelineConnectionUpdate;
+    pipelineCreate: typeof pipelineCreate;
     pipelineGet: typeof pipelineGet;
     pipelineList: typeof pipelineList;
+    pipelineStageConnectionCreate: typeof pipelineStageConnectionCreate;
+    pipelineStageConnectionDelete: typeof pipelineStageConnectionDelete;
+    pipelineStageConnectionList: typeof pipelineStageConnectionList;
+    pipelineStageConnectionUpdate: typeof pipelineStageConnectionUpdate;
+    pipelineUpdate: typeof pipelineUpdate;
     projectDefaultGet: typeof projectDefaultGet;
     projectDefaultSet: typeof projectDefaultSet;
     projectDefaultUnset: typeof projectDefaultUnset;
@@ -1107,6 +1234,11 @@ export declare const agentiaMcpToolHandlers: {
     repositoryReset: typeof repositoryReset;
     repositoryUpdate: typeof repositoryUpdate;
     repositoryValidate: typeof repositoryValidate;
+    stageCreate: typeof stageCreate;
+    stageDelete: typeof stageDelete;
+    stageGet: typeof stageGet;
+    stageList: typeof stageList;
+    stageUpdate: typeof stageUpdate;
     userGet: typeof userGet;
     workStatus: typeof workStatus;
     deploymentStepCreate: (args: {

package/dist/lib/mcp/tools.js

@@ -24,7 +24,10 @@ import { normalizeLocalGatewayBaseUrl, readLocalGatewayConfig } from '../local-g
 import { COMPARISON_MODES, CONTENT_SOURCES, contentResultToCompareSide, createUnifiedDiff, INDEX_SOURCES, MODULE_TYPES, ORDER_DIRECTIONS, PLATFORM_EXPERIENCES, RETRIEVE_MODES, sourceSideLabel, } from '../metadata-common.js';
 import { buildRefreshDeletedRequest, buildRefreshIndexRequest, refreshStatusEndpoint, resolveRefreshSourceFromEnv, } from '../metadata-refresh.js';
 import { NAVIGATION_RESOURCE_TYPES, resolveNavigationTarget } from '../navigation.js';
-import { normalizePipelineDescribe, normalizePipelines, normalizePipelinesListPage, pipelineConnectionsFromPipelines, pipelineDescribeEndpoint, pipelineListEndpoint, } from '../pipeline-types.js';
+import { parsePipelineConnectionMutationObject, parsePipelineConnectionUpdateObject, validatePipelineConnectionCreatePayload, validatePipelineConnectionUpdatePayload, } from '../pipeline-connection-flags.js';
+import { validatePipelineMutationPayload, } from '../pipeline-flags.js';
+import { buildPipelineStageConnectionCreatePayload, buildPipelineStageConnectionUpdatePayload, } from '../pipeline-stage-connection-flags.js';
+import { normalizePipeline, normalizePipelineConnections, normalizePipelineDescribe, normalizePipelines, normalizePipelinesListPage, PIPELINE_CALCULATE_BASED_ON_VALUES, PIPELINE_CONNECTION_SYNC_STATE_NEEDS_RECALCULATING, PIPELINE_PLATFORMS, pipelineConnectionsEndpoint, pipelineConnectionsFromPipelines, pipelineDescribeEndpoint, pipelineEndpoint, pipelineListEndpoint, } from '../pipeline-types.js';
 import { buildSetValues, collectSelectedKeys } from '../project-default-flags.js';
 import { PROJECT_DEFAULT_KEYS } from '../project-defaults.js';
 import { normalizeProject, normalizeProjectsListPage, projectEndpoint, projectsListEndpoint, } from '../project-types.js';
@@ -33,6 +36,8 @@ import { performPromotionResume, performPromotionRun, PROMOTION_OPERATIONS, PROM
 import { normalizePromotionDetail, normalizePromotionsListPage, promotionEndpoint, promotionListEndpoint, } from '../promotion-types.js';
 import { REPOSITORY_STRING_VALIDATION_KEYS, validateNonEmptyStringFields as validateRepositoryNonEmptyStringFields, } from '../repository-flags.js';
 import { normalizeRepositoriesListPage, normalizeRepository, normalizeRepositoryValidateResult, repositoriesEndpoint, REPOSITORY_AUTH_TYPES, REPOSITORY_PROVIDERS, REPOSITORY_SOURCE_FORMATS, repositoryEndpoint, repositoryResetEndpoint, repositoryValidateEndpoint, withRequiredRepositoryFields, } from '../repository-types.js';
+import { buildStageMutationPayload, validateStagePayload } from '../stage-flags.js';
+import { normalizePipelineStageConnection, normalizeStage, normalizeStagesListPage, pipelineStageConnectionEndpoint, pipelineStageConnectionsEndpoint, STAGE_META_STAGE_SUGGESTIONS, stageEndpoint, stagesEndpoint, } from '../stage-types.js';
 import { getUserContext } from '../user-context.js';
 import { DEFAULT_USER_ID, resolveUserId, userEndpoint } from '../user-types.js';
 import { workStatusEndpoint } from '../work-types.js';
@@ -301,8 +306,7 @@ async function pipelineConnectionList(args) {
             endpoint: pipelineDescribeEndpoint(args.pipelineId),
             method: 'GET',
         });
-        const pipeline = normalizePipelineDescribe(response);
-        connections = pipeline.connections ?? [];
+        connections = normalizePipelineDescribe(response).connections ?? [];
     }
     else {
         const response = await CicdGateway.call({
@@ -313,6 +317,196 @@ async function pipelineConnectionList(args) {
     }
     return { connections };
 }
+async function pipelineCreate(args) {
+    const payload = {
+        name: assertRequired(args.name, 'name'),
+        ...buildPipelineMcpPayload(args),
+    };
+    const validationError = validatePipelineMutationPayload(payload);
+    if (validationError !== undefined) {
+        throw new Error(validationError);
+    }
+    const response = await CicdGateway.call({
+        body: payload,
+        endpoint: pipelineListEndpoint(),
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'POST',
+    });
+    return { pipeline: normalizePipeline(response) };
+}
+async function pipelineUpdate(args) {
+    const id = assertRequired(args.id, 'id');
+    const payload = buildPipelineMcpPayload(args);
+    if (Object.keys(payload).length === 0) {
+        throw new Error('Must provide at least one field to update.');
+    }
+    const validationError = validatePipelineMutationPayload(payload);
+    if (validationError !== undefined) {
+        throw new Error(validationError);
+    }
+    const response = await CicdGateway.call({
+        body: payload,
+        endpoint: pipelineEndpoint(id),
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'PATCH',
+    });
+    return { pipeline: normalizePipeline(response) };
+}
+async function pipelineConnectionCreate(args) {
+    const pipelineId = assertRequired(args.pipelineId, 'pipelineId');
+    const connections = buildPipelineConnectionMcpCreatePayloads(args);
+    for (const [index, connection] of connections.entries()) {
+        const validationError = validatePipelineConnectionCreatePayload(connection);
+        if (validationError !== undefined) {
+            throw new Error(`connections[${index}]: ${validationError}`);
+        }
+    }
+    const response = await CicdGateway.call({
+        body: connections,
+        endpoint: pipelineConnectionsEndpoint(pipelineId),
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'POST',
+    });
+    return { connections: normalizePipelineConnections(response) };
+}
+async function pipelineConnectionUpdate(args) {
+    const pipelineId = assertRequired(args.pipelineId, 'pipelineId');
+    const connections = buildPipelineConnectionMcpUpdatePayloads(args);
+    for (const [index, connection] of connections.entries()) {
+        const validationError = validatePipelineConnectionUpdatePayload(connection);
+        if (validationError !== undefined) {
+            throw new Error(`connections[${index}]: ${validationError}`);
+        }
+    }
+    const response = await CicdGateway.call({
+        body: { connections },
+        endpoint: pipelineConnectionsEndpoint(pipelineId),
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'PATCH',
+    });
+    return { connections: normalizePipelineConnections(response) };
+}
+async function pipelineConnectionDelete(args) {
+    const pipelineId = assertRequired(args.pipelineId, 'pipelineId');
+    const { connectionIds } = args;
+    if (!Array.isArray(connectionIds) || connectionIds.length === 0) {
+        throw new Error('connectionIds must be a non-empty array.');
+    }
+    await CicdGateway.call({
+        body: { connectionIds },
+        endpoint: pipelineConnectionsEndpoint(pipelineId),
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'DELETE',
+    });
+    return { connectionIds, pipelineId };
+}
+async function stageList(args = {}) {
+    const response = await CicdGateway.call({
+        endpoint: stagesEndpoint(args),
+        method: 'GET',
+    });
+    return mcpPaginatedListPayload('stages', normalizeStagesListPage(response));
+}
+async function stageGet(args) {
+    const response = await CicdGateway.call({
+        endpoint: stageEndpoint(assertRequired(args.id, 'id')),
+        method: 'GET',
+    });
+    return { stage: normalizeStage(response) };
+}
+async function stageCreate(args) {
+    const payload = {
+        ...buildStageMutationPayload(args),
+        name: assertRequired(args.name, 'name'),
+    };
+    const validationError = validateStagePayload(payload, true);
+    if (validationError !== undefined)
+        throw new Error(validationError);
+    const response = await CicdGateway.call({
+        body: payload,
+        endpoint: stagesEndpoint(),
+        headers: { 'Content-Type': 'application/json' },
+        method: 'POST',
+    });
+    return { stage: normalizeStage(response) };
+}
+async function stageUpdate(args) {
+    const id = assertRequired(args.id, 'id');
+    const payload = buildStageMutationPayload(args);
+    if (Object.keys(payload).length === 0)
+        throw new Error('Must provide at least one field to update.');
+    const validationError = validateStagePayload(payload);
+    if (validationError !== undefined)
+        throw new Error(validationError);
+    const response = await CicdGateway.call({
+        body: payload,
+        endpoint: stageEndpoint(id),
+        headers: { 'Content-Type': 'application/json' },
+        method: 'PATCH',
+    });
+    return { stage: normalizeStage(response) };
+}
+async function stageDelete(args) {
+    const id = assertRequired(args.id, 'id');
+    await CicdGateway.call({ endpoint: stageEndpoint(id), method: 'DELETE' });
+    return { id };
+}
+async function pipelineStageConnectionCreate(args) {
+    const pipelineId = assertRequired(args.pipelineId, 'pipelineId');
+    const payload = buildPipelineStageConnectionCreatePayload({
+        'next-pipeline-stage-connection-id': args.nextPipelineStageConnectionId,
+        'stage-id': args.stageId,
+    });
+    const response = await CicdGateway.call({
+        body: payload,
+        endpoint: pipelineStageConnectionsEndpoint(pipelineId),
+        headers: { 'Content-Type': 'application/json' },
+        method: 'POST',
+    });
+    return { connection: normalizePipelineStageConnection(response) };
+}
+async function pipelineStageConnectionList(args) {
+    const pipelineId = assertRequired(args.pipelineId, 'pipelineId');
+    const response = await CicdGateway.call({
+        endpoint: pipelineDescribeEndpoint(pipelineId),
+        method: 'GET',
+    });
+    return { connections: normalizePipelineDescribe(response).stageConnections ?? [] };
+}
+async function pipelineStageConnectionUpdate(args) {
+    const pipelineId = assertRequired(args.pipelineId, 'pipelineId');
+    const connectionId = assertRequired(args.connectionId, 'connectionId');
+    const payload = buildPipelineStageConnectionUpdatePayload({
+        'next-pipeline-stage-connection-id': args.nextPipelineStageConnectionId,
+        'stage-id': args.stageId,
+    }, connectionId);
+    const response = await CicdGateway.call({
+        body: payload,
+        endpoint: pipelineStageConnectionEndpoint(pipelineId, connectionId),
+        headers: { 'Content-Type': 'application/json' },
+        method: 'PATCH',
+    });
+    return { connection: normalizePipelineStageConnection(response) };
+}
+async function pipelineStageConnectionDelete(args) {
+    const pipelineId = assertRequired(args.pipelineId, 'pipelineId');
+    const connectionId = assertRequired(args.connectionId, 'connectionId');
+    await CicdGateway.call({
+        endpoint: pipelineStageConnectionEndpoint(pipelineId, connectionId),
+        method: 'DELETE',
+    });
+    return { connectionId, pipelineId };
+}
 async function projectList(args = {}) {
     const response = await CicdGateway.call({
         endpoint: projectsListEndpoint(args),
@@ -507,6 +701,41 @@ function buildRepositoryMcpPayload(args) {
     }
     return payload;
 }
+function buildPipelineMcpPayload(args) {
+    const payload = {};
+    for (const [key, value] of Object.entries(args)) {
+        if (key === 'id' || value === undefined) {
+            continue;
+        }
+        Object.assign(payload, { [key]: value });
+    }
+    return payload;
+}
+function buildPipelineConnectionMcpCreatePayloads(args) {
+    if ('connections' in args && Array.isArray(args.connections)) {
+        return args.connections.map((connection, index) => {
+            const payload = parsePipelineConnectionMutationObject(connection, index);
+            if (payload.syncMergeState === undefined) {
+                payload.syncMergeState = PIPELINE_CONNECTION_SYNC_STATE_NEEDS_RECALCULATING;
+            }
+            if (payload.syncPullState === undefined) {
+                payload.syncPullState = PIPELINE_CONNECTION_SYNC_STATE_NEEDS_RECALCULATING;
+            }
+            return payload;
+        });
+    }
+    const single = parsePipelineConnectionMutationObject(args);
+    if (single.syncMergeState === undefined) {
+        single.syncMergeState = PIPELINE_CONNECTION_SYNC_STATE_NEEDS_RECALCULATING;
+    }
+    if (single.syncPullState === undefined) {
+        single.syncPullState = PIPELINE_CONNECTION_SYNC_STATE_NEEDS_RECALCULATING;
+    }
+    return [single];
+}
+function buildPipelineConnectionMcpUpdatePayloads(args) {
+    return args.connections.map((connection, index) => parsePipelineConnectionUpdateObject(connection, index));
+}
 function validateRepositoryPayload(payload) {
     const validationError = validateRepositoryNonEmptyStringFields(payload, REPOSITORY_STRING_VALIDATION_KEYS);
     if (validationError !== undefined) {
@@ -922,9 +1151,18 @@ export const agentiaMcpToolHandlers = wrapMcpToolHandlers({
     metadataRefreshRun,
     metadataRefreshStatus,
     navigationResolve,
+    pipelineConnectionCreate,
+    pipelineConnectionDelete,
     pipelineConnectionList,
+    pipelineConnectionUpdate,
+    pipelineCreate,
     pipelineGet,
     pipelineList,
+    pipelineStageConnectionCreate,
+    pipelineStageConnectionDelete,
+    pipelineStageConnectionList,
+    pipelineStageConnectionUpdate,
+    pipelineUpdate,
     projectDefaultGet,
     projectDefaultSet,
     projectDefaultUnset,
@@ -944,6 +1182,11 @@ export const agentiaMcpToolHandlers = wrapMcpToolHandlers({
     repositoryReset,
     repositoryUpdate,
     repositoryValidate,
+    stageCreate,
+    stageDelete,
+    stageGet,
+    stageList,
+    stageUpdate,
     userGet,
     workStatus,
     ...agentiaMcpTestingToolHandlers,
@@ -972,6 +1215,25 @@ const projectSelectorSchema = {
     sprint: z.boolean().optional().describe('Select the sprint default.'),
     team: z.boolean().optional().describe('Select the team default.'),
 };
+const pipelineMutationSchema = {
+    active: z.boolean().optional().describe('Whether the pipeline is active.'),
+    blockCommits: z.boolean().optional().describe('Block commits on the pipeline.'),
+    calculateBasedOn: z.enum(PIPELINE_CALCULATE_BASED_ON_VALUES).optional().describe('Promotion calculation basis.'),
+    enableSmartConflictResolution: z.boolean().optional().describe('Enable smart conflict resolution.'),
+    gitRepositoryId: z.string().optional().describe('Git repository ID.'),
+    mainBranch: z.string().optional().describe('Main branch name.'),
+    platform: z.enum(PIPELINE_PLATFORMS).optional().describe('Pipeline platform.'),
+};
+const pipelineConnectionMutationSchema = {
+    branch: z.string().optional().describe('Source branch for the connection.'),
+    destinationBranch: z.string().optional().describe('Destination branch for the connection.'),
+    destinationEnvironmentId: z.string().optional().describe('Destination environment ID.'),
+    id: z.string().optional().describe('Pipeline connection ID.'),
+    sourceEnvironmentId: z.string().optional().describe('Source environment ID.'),
+    stageConnectionId: z.string().optional().describe('Stage connection ID.'),
+    syncMergeState: z.string().optional().describe('Sync merge state.'),
+    syncPullState: z.string().optional().describe('Sync pull state.'),
+};
 const repositoryMutationSchema = {
     allowFunctionsGitCache: z.boolean().optional().describe('Allow Functions Git cache for this repository.'),
     authType: z.enum(REPOSITORY_AUTH_TYPES).optional().describe('Repository authentication type.'),
@@ -1161,7 +1423,12 @@ export function registerAgentiaMcpTools(server) {
     }, (args) => safelyHandleTool(() => jobPause(args)));
     server.registerTool('agentia_pipeline_list', {
         description: 'List Copado pipelines via the CICD gateway.',
-        inputSchema: listPaginationZodFields,
+        inputSchema: {
+            active: z.boolean().optional().describe('Filter by active status.'),
+            name: z.string().optional().describe('Filter by pipeline name.'),
+            platform: z.enum(PIPELINE_PLATFORMS).optional().describe('Filter by pipeline platform.'),
+            ...listPaginationZodFields,
+        },
         title: 'Agentia Pipeline List',
     }, (args) => safelyHandleTool(() => pipelineList(args || {})));
     server.registerTool('agentia_pipeline_get', {
@@ -1171,13 +1438,124 @@ export function registerAgentiaMcpTools(server) {
         },
         title: 'Agentia Pipeline Get',
     }, (args) => safelyHandleTool(() => pipelineGet(args)));
+    server.registerTool('agentia_pipeline_create', {
+        description: 'Create a Copado pipeline via the CICD gateway.',
+        inputSchema: {
+            ...pipelineMutationSchema,
+            name: z.string().describe('Pipeline name.'),
+        },
+        title: 'Agentia Pipeline Create',
+    }, (args) => safelyHandleTool(() => pipelineCreate(args)));
+    server.registerTool('agentia_pipeline_update', {
+        description: 'Update a Copado pipeline via the CICD gateway.',
+        inputSchema: {
+            ...pipelineMutationSchema,
+            id: z.string().describe('Pipeline Id.'),
+            name: z.string().optional().describe('Pipeline name.'),
+        },
+        title: 'Agentia Pipeline Update',
+    }, (args) => safelyHandleTool(() => pipelineUpdate(args)));
     server.registerTool('agentia_pipeline_connection_list', {
-        description: 'List Copado pipeline connections via list or describe endpoints.',
+        description: 'List Copado pipeline connections via describe or pipeline list.',
         inputSchema: {
             pipelineId: z.string().optional().describe('Optional pipeline Id. When set, uses the describe endpoint.'),
         },
         title: 'Agentia Pipeline Connection List',
     }, (args) => safelyHandleTool(() => pipelineConnectionList(args)));
+    server.registerTool('agentia_pipeline_connection_create', {
+        description: 'Create one or more Copado pipeline connections via the CICD gateway.',
+        inputSchema: {
+            ...pipelineConnectionMutationSchema,
+            connections: z
+                .array(z.object(pipelineConnectionMutationSchema))
+                .optional()
+                .describe('Optional array of connections to create in bulk.'),
+            pipelineId: z.string().describe('Pipeline Id.'),
+        },
+        title: 'Agentia Pipeline Connection Create',
+    }, (args) => safelyHandleTool(() => pipelineConnectionCreate(args)));
+    server.registerTool('agentia_pipeline_connection_update', {
+        description: 'Update one or more Copado pipeline connections via the CICD gateway.',
+        inputSchema: {
+            connections: z.array(z.object(pipelineConnectionMutationSchema)).describe('Connections to update.'),
+            pipelineId: z.string().describe('Pipeline Id.'),
+        },
+        title: 'Agentia Pipeline Connection Update',
+    }, (args) => safelyHandleTool(() => pipelineConnectionUpdate(args)));
+    server.registerTool('agentia_pipeline_connection_delete', {
+        description: 'Delete one or more Copado pipeline connections via the CICD gateway.',
+        inputSchema: {
+            connectionIds: z.array(z.string()).describe('Pipeline connection IDs to delete.'),
+            pipelineId: z.string().describe('Pipeline Id.'),
+        },
+        title: 'Agentia Pipeline Connection Delete',
+    }, (args) => safelyHandleTool(() => pipelineConnectionDelete(args)));
+    server.registerTool('agentia_stage_list', {
+        description: 'List Copado stages via the CICD gateway.',
+        inputSchema: listPaginationZodFields,
+        title: 'Agentia Stage List',
+    }, (args) => safelyHandleTool(() => stageList(args || {})));
+    server.registerTool('agentia_stage_get', {
+        description: 'Get a Copado stage via the CICD gateway.',
+        inputSchema: { id: z.string().describe('Stage ID.') },
+        title: 'Agentia Stage Get',
+    }, (args) => safelyHandleTool(() => stageGet(args)));
+    server.registerTool('agentia_stage_create', {
+        description: `Create a Copado stage. Common metaStage values include ${STAGE_META_STAGE_SUGGESTIONS.join(', ')}; custom values are allowed.`,
+        inputSchema: {
+            metaStage: z.string().optional().describe('Stage category; custom values are allowed.'),
+            name: z.string().describe('Stage name.'),
+        },
+        title: 'Agentia Stage Create',
+    }, (args) => safelyHandleTool(() => stageCreate(args)));
+    server.registerTool('agentia_stage_update', {
+        description: 'Update a Copado stage via the CICD gateway.',
+        inputSchema: {
+            id: z.string().describe('Stage ID.'),
+            metaStage: z.string().optional().describe('Stage category; custom values are allowed.'),
+            name: z.string().optional().describe('Stage name.'),
+        },
+        title: 'Agentia Stage Update',
+    }, (args) => safelyHandleTool(() => stageUpdate(args)));
+    server.registerTool('agentia_stage_delete', {
+        description: 'Delete a Copado stage via the CICD gateway.',
+        inputSchema: { id: z.string().describe('Stage ID.') },
+        title: 'Agentia Stage Delete',
+    }, (args) => safelyHandleTool(() => stageDelete(args)));
+    server.registerTool('agentia_pipeline_stage_connection_create', {
+        description: 'Create a pipeline stage connection via the CICD gateway.',
+        inputSchema: {
+            nextPipelineStageConnectionId: z.string().optional().describe('Next pipeline stage connection ID.'),
+            pipelineId: z.string().describe('Pipeline ID.'),
+            stageId: z.string().describe('Stage ID.'),
+        },
+        title: 'Agentia Pipeline Stage Connection Create',
+    }, (args) => safelyHandleTool(() => pipelineStageConnectionCreate(args)));
+    server.registerTool('agentia_pipeline_stage_connection_list', {
+        description: 'List pipeline stage connections from the pipeline describe response.',
+        inputSchema: {
+            pipelineId: z.string().describe('Pipeline ID.'),
+        },
+        title: 'Agentia Pipeline Stage Connection List',
+    }, (args) => safelyHandleTool(() => pipelineStageConnectionList(args)));
+    server.registerTool('agentia_pipeline_stage_connection_update', {
+        description: 'Update a pipeline stage connection via the CICD gateway.',
+        inputSchema: {
+            connectionId: z.string().describe('Pipeline stage connection ID.'),
+            nextPipelineStageConnectionId: z.string().optional().describe('Next pipeline stage connection ID.'),
+            pipelineId: z.string().describe('Pipeline ID.'),
+            stageId: z.string().optional().describe('Stage ID.'),
+        },
+        title: 'Agentia Pipeline Stage Connection Update',
+    }, (args) => safelyHandleTool(() => pipelineStageConnectionUpdate(args)));
+    server.registerTool('agentia_pipeline_stage_connection_delete', {
+        description: 'Delete a pipeline stage connection via the CICD gateway.',
+        inputSchema: {
+            connectionId: z.string().describe('Pipeline stage connection ID.'),
+            pipelineId: z.string().describe('Pipeline ID.'),
+        },
+        title: 'Agentia Pipeline Stage Connection Delete',
+    }, (args) => safelyHandleTool(() => pipelineStageConnectionDelete(args)));
     server.registerTool('agentia_project_list', {
         description: 'List Copado projects via the CICD gateway.',
         inputSchema: {