@copado/agentia-cli 0.56.0-alpha.0 → 0.58.0-alpha.0

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

@@ -2,6 +2,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type CicdRegion } from '../cicd-region.js';
 import { type CredentialType } from '../credential-store.js';
 import { type Environment, type EnvironmentListFilters } from '../environment-types.js';
+import { type FunctionCreateDefaultsPayload, type FunctionListType, type FunctionRunPayload, type FunctionRuntime, type FunctionUpsertInput } from '../function-types.js';
 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';
@@ -10,6 +11,7 @@ import { type PipelineConnection, type PipelineDescribe, type PipelineListFilter
 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 RepositoryValidateResult } from '../repository-types.js';
 import { type User } from '../user-types.js';
@@ -178,12 +180,26 @@ declare function environmentGet(args: {
     environment: Environment;
 }>;
 type PromotionListArgs = PromotionListFilters;
+type PromotionRunArgs = {
+    confirmRecreate?: boolean;
+    deploymentStepIds?: string[];
+    ignoredMetadata?: unknown[];
+    operation?: PromotionOperation;
+    promotionId: string;
+    recreatePromotionBranch?: boolean;
+    resumeJobExecutionId?: string;
+    wait?: boolean;
+    waitTimeout?: number;
+};
 declare function promotionList(args?: PromotionListArgs): Promise<Record<string, unknown>>;
 declare function promotionGet(args: {
     id: string;
 }): Promise<{
     promotion: PromotionDetail;
 }>;
+declare function promotionRun(args: PromotionRunArgs): Promise<{
+    result: import("../promotion-run.js").PromotionRunResult;
+}>;
 declare function environmentCreate(args: EnvironmentCreateArgs): Promise<{
     environment: Environment;
 }>;
@@ -252,6 +268,55 @@ declare function repositoryValidate(args: {
 }): Promise<{
     validation: RepositoryValidateResult;
 }>;
+declare function functionList(args?: {
+    type?: FunctionListType;
+}): Promise<{
+    functions: import("../function-types.js").CopadoFunction[];
+}>;
+declare function functionGet(args: {
+    apiName: string;
+}): Promise<{
+    function: import("../function-types.js").CopadoFunction;
+}>;
+declare function functionDefaults(args: FunctionCreateDefaultsPayload): Promise<{
+    function: import("../function-types.js").CopadoFunction;
+}>;
+declare function functionUpsert(args: FunctionUpsertInput & {
+    apiName: string;
+}): Promise<{
+    function: import("../function-types.js").CopadoFunction;
+}>;
+declare function functionDelete(args: {
+    apiName: string;
+}): Promise<{
+    apiName: string;
+}>;
+declare function functionRun(args: FunctionRunPayload & {
+    apiName: string;
+}): Promise<{
+    run: import("../function-types.js").FunctionRunResult;
+}>;
+declare function functionResultGet(args: {
+    resultId: string;
+}): Promise<{
+    result: import("../function-types.js").FunctionResultStatus;
+}>;
+declare function functionResultLogGet(args: {
+    resultId: string;
+    type?: string;
+}): Promise<{
+    type?: string | undefined;
+    log: string;
+    resultId: string;
+}>;
+declare function functionRunLocal(args: {
+    cwd?: string;
+    image?: string;
+    parameters?: Record<string, string>;
+    platform?: string;
+    runtime?: FunctionRuntime;
+    script: string;
+}): Promise<import("../function-local-run.js").LocalFunctionRunResult>;
 declare function userGet(args?: {
     id?: string;
 }): Promise<{
@@ -475,6 +540,33 @@ export declare const agentiaMcpToolHandlers: {
         assignedToMe?: boolean;
         ownedByMe?: boolean;
     }) => Promise<Record<string, unknown>>;
+    workPromote: (args?: {
+        cloud?: boolean;
+        confirmRecreate?: boolean;
+        deploy?: boolean;
+        deploymentStepIds?: string[];
+        id?: string;
+        ignoredMetadata?: unknown[];
+        promotionId?: string;
+        recreatePromotionBranch?: boolean;
+        wait?: boolean;
+        waitTimeout?: number;
+    }) => Promise<{
+        workItemId: string;
+        context: Record<string, unknown>;
+        deploymentSteps: import("../promotion-run.js").PromotionDeploymentStep[];
+        ignoredMetadata?: unknown[];
+        jobMonitors: import("../promotion-run.js").PromotionJobMonitor[];
+        mode: "resume" | "run";
+        operation?: PromotionOperation;
+        promotionAfter?: PromotionDetail;
+        promotionBefore: PromotionDetail;
+        promotionId: string;
+        request?: import("../promotion-run.js").PromotionRunRequest;
+        resultId: string;
+        run: import("../promotion-run.js").PromotionRunResponse;
+        wait: boolean;
+    }>;
     workPush: () => Promise<import("../work-types.js").WorkPushResult>;
     workSet: (args: {
         baseBranch?: string;
@@ -966,6 +1058,15 @@ export declare const agentiaMcpToolHandlers: {
     environmentGet: typeof environmentGet;
     environmentList: typeof environmentList;
     environmentUpdate: typeof environmentUpdate;
+    functionDefaults: typeof functionDefaults;
+    functionDelete: typeof functionDelete;
+    functionGet: typeof functionGet;
+    functionList: typeof functionList;
+    functionResultGet: typeof functionResultGet;
+    functionResultLogGet: typeof functionResultLogGet;
+    functionRun: typeof functionRun;
+    functionRunLocal: typeof functionRunLocal;
+    functionUpsert: typeof functionUpsert;
     jobGet: typeof jobGet;
     jobKill: typeof jobKill;
     jobList: typeof jobList;
@@ -996,6 +1097,7 @@ export declare const agentiaMcpToolHandlers: {
     promotionConflictUnresolve: typeof promotionConflictUnresolve;
     promotionGet: typeof promotionGet;
     promotionList: typeof promotionList;
+    promotionRun: typeof promotionRun;
     repositoryCreate: typeof repositoryCreate;
     repositoryDelete: typeof repositoryDelete;
     repositoryGet: typeof repositoryGet;
@@ -1005,6 +1107,135 @@ export declare const agentiaMcpToolHandlers: {
     repositoryValidate: typeof repositoryValidate;
     userGet: typeof userGet;
     workStatus: typeof workStatus;
+    dataCommitCreate: (args: import("../data-types.js").DataCommitApiRequest) => Promise<{
+        result: import("../data-types.js").DataCommitResponse;
+    }>;
+    dataCommitList: (args: {
+        userStoryId: string;
+    }) => Promise<{
+        result: import("../data-types.js").UserStoryDataCommitRecord[];
+    }>;
+    dataDatasetFileContent: (args: {
+        contentVersionId: string;
+    }) => Promise<{
+        result: import("../data-types.js").DatasetFileContentResult[];
+    }>;
+    dataDatasetFileList: (args: {
+        userStoryDataCommitId: string;
+    }) => Promise<{
+        result: import("../data-types.js").DatasetFileMetadata[];
+    }>;
+    dataFilterAdd: (args: {
+        body: import("../data-types.js").AdvancedFilterRequest;
+        dataTemplateId: string;
+    }) => Promise<{
+        result: string;
+    }>;
+    dataFilterDelete: (args: {
+        dataTemplateId: string;
+        uuid: string;
+    }) => Promise<{
+        result: string;
+    }>;
+    dataFilterList: (args: {
+        dataTemplateId: string;
+    }) => Promise<{
+        result: import("../data-types.js").AdvancedFilter[];
+    }>;
+    dataFilterUpdate: (args: {
+        body: import("../data-types.js").AdvancedFilterRequest;
+        dataTemplateId: string;
+        uuid: string;
+    }) => Promise<{
+        result: string;
+    }>;
+    dataFormulaCreate: (args: {
+        dataTemplateId: string;
+        fields: string[];
+        hashFormula?: boolean;
+        name: string;
+        objectApiName: string;
+    }) => Promise<{
+        result: import("../data-types.js").RecordMatchingFormulaVm;
+    }>;
+    dataFormulaList: (args: {
+        objectApiName: string;
+    }) => Promise<{
+        result: import("../data-types.js").RecordMatchingFormulaVm[];
+    }>;
+    dataFormulaUpdate: (args: {
+        body: import("../data-types.js").RecordMatchingFormulaRequest;
+        formulaId: string;
+    }) => Promise<{
+        result: import("../data-types.js").RecordMatchingFormulaVm;
+    }>;
+    dataRecordsMatch: (args: import("../data-types.js").MatchDataRecordRequest) => Promise<{
+        result: import("../data-types.js").DataRecord | null;
+    }>;
+    dataRecordsSearch: (args: import("../data-types.js").DataRecordRequest) => Promise<{
+        result: import("../data-types.js").DataRecordSearchResult;
+    }>;
+    dataSobjectFields: (args: {
+        credentialId: string;
+        sobjectApiName: string;
+    }) => Promise<{
+        result: import("../data-types.js").SObjectFields;
+    }>;
+    dataSobjectRelationships: (args: {
+        credentialId: string;
+        sobjectApiName: string;
+    }) => Promise<{
+        result: import("../data-types.js").SObjectRelationships;
+    }>;
+    dataSyncApply: (args: {
+        entries: import("../data-types.js").DataTemplateSyncEntryRequest[];
+    }) => Promise<{
+        result: import("../data-types.js").DataTemplateSyncResponseEntry[];
+    }>;
+    dataSyncPreviewUpdates: (args: import("../data-types.js").DataTemplateUpdatePreviewRequest) => Promise<{
+        result: import("../data-types.js").DataTemplateUpdatePreview[];
+    }>;
+    dataTemplateConvertOld: (args: {
+        id: string;
+    }) => Promise<{
+        result: string;
+    }>;
+    dataTemplateCreate: (args: {
+        apiName: string;
+        credentialId: string;
+        mainObjectApiName: string;
+        mainObjectLabel: string;
+        templateName: string;
+    }) => Promise<{
+        result: string;
+    }>;
+    dataTemplateDelete: (args: {
+        id: string;
+    }) => Promise<{
+        result: boolean;
+    }>;
+    dataTemplateGet: (args: {
+        id: string;
+    }) => Promise<{
+        result: Record<string, import("../data-types.js").V2TemplateDetail>;
+    }>;
+    dataTemplateGetDetail: (args: {
+        id: string;
+    }) => Promise<{
+        result: import("../data-types.js").V2Template;
+    }>;
+    dataTemplateList: (args?: {
+        active?: boolean;
+        fetchRelated?: boolean;
+    }) => Promise<{
+        result: import("../data-types.js").DataTemplate[];
+    }>;
+    dataTemplateSaveDetail: (args: {
+        body: import("../data-types.js").V2Template;
+        id: string;
+    }) => Promise<{
+        result: boolean;
+    }>;
     aiAsk: (args: {
         agent: import("../ai-types.js").AiAgent;
         component?: string;

package/dist/lib/mcp/tools.js

@@ -16,6 +16,8 @@ import { collectCredentialUpdateFlagKeys, validateCredentialName, } from '../env
 import { createEnvironmentCredential, resolveEnvironmentOrgType, updateEnvironmentCredential, } from '../environment-credential-operations.js';
 import { buildCreatePayload, buildMutationPayload, ENVIRONMENT_STRING_VALIDATION_KEYS, validateNonEmptyStringFields, } from '../environment-flags.js';
 import { DEFAULT_ENVIRONMENT_PLATFORM, DEFAULT_ENVIRONMENT_TYPE, ENVIRONMENT_TYPES, environmentEndpoint, environmentsListEndpoint, } from '../environment-types.js';
+import { executeLocalFunctionRun } from '../function-local-run.js';
+import { FUNCTION_LIST_TYPES, FUNCTION_RUNTIMES, functionEndpoint, functionResultEndpoint, functionResultLogEndpoint, functionRunEndpoint, functionsEndpoint, normalizeFunction, normalizeFunctionResultStatus, normalizeFunctionRunResult, normalizeFunctionsList, normalizeFunctionUpsertPayload, } from '../function-types.js';
 import { jobEndpoint, jobKillEndpoint, jobListEndpoint, jobPauseEndpoint, jobResultLogEndpoint, jobResumeEndpoint, jobRunEndpoint, normalizeJob, normalizeJobOperation, normalizeJobsListPage, resolveJobStepForLog, } from '../job-types.js';
 import { listPaginationZodFields, mcpPaginatedListPayload } from '../list-pagination.js';
 import { normalizeLocalGatewayBaseUrl, readLocalGatewayConfig } from '../local-gateway-config.js';
@@ -27,6 +29,7 @@ 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';
 import { buildPromotionConflictResolutionRequest, normalizePromotionConflicts, PROMOTION_CONFLICT_MODES, promotionConflictContentEndpoint, promotionConflictResolveEndpoint, promotionConflictsEndpoint, promotionConflictUndoEndpoint, withPromotionConflictErrorTranslation, } from '../promotion-conflicts.js';
+import { performPromotionResume, performPromotionRun, PROMOTION_OPERATIONS, PROMOTION_RUN_DEFAULT_TIMEOUT_SECONDS, } from '../promotion-run.js';
 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';
@@ -34,6 +37,7 @@ import { getUserContext } from '../user-context.js';
 import { DEFAULT_USER_ID, resolveUserId, userEndpoint } from '../user-types.js';
 import { workStatusEndpoint } from '../work-types.js';
 import { agentiaMcpAiToolHandlers, registerAgentiaMcpAiTools } from './ai-tools.js';
+import { agentiaMcpDataToolHandlers, registerAgentiaMcpDataTools } from './data-tools.js';
 import { safelyHandleTool } from './result.js';
 import { agentiaMcpTestingToolHandlers, registerAgentiaMcpTestingTools } from './testing-tools.js';
 import { agentiaMcpWorkToolHandlers, registerAgentiaMcpWorkTools } from './work-tools.js';
@@ -52,6 +56,10 @@ async function environmentGet(args) {
     });
     return { environment };
 }
+const silentPromotionRunHooks = {
+    log() { },
+    withSpinner: async (_message, action) => action(),
+};
 async function promotionList(args = {}) {
     const response = await CicdGateway.call({
         endpoint: promotionListEndpoint(args),
@@ -66,6 +74,45 @@ async function promotionGet(args) {
     });
     return { promotion: normalizePromotionDetail(response) };
 }
+async function promotionRun(args) {
+    const waitTimeout = args.waitTimeout ?? PROMOTION_RUN_DEFAULT_TIMEOUT_SECONDS;
+    if (!Number.isInteger(waitTimeout) || waitTimeout <= 0) {
+        throw new Error('waitTimeout must be a positive integer.');
+    }
+    if (args.recreatePromotionBranch === true && args.confirmRecreate !== true) {
+        throw new Error('recreatePromotionBranch requires confirmRecreate=true.');
+    }
+    if (args.resumeJobExecutionId !== undefined) {
+        if (args.operation !== undefined ||
+            args.deploymentStepIds !== undefined ||
+            args.ignoredMetadata !== undefined ||
+            args.recreatePromotionBranch !== undefined) {
+            throw new Error('resumeJobExecutionId cannot be combined with run request fields.');
+        }
+        const result = await performPromotionResume({
+            hooks: silentPromotionRunHooks,
+            jobExecutionId: args.resumeJobExecutionId,
+            promotionId: args.promotionId,
+            timeoutSeconds: waitTimeout,
+            wait: args.wait ?? true,
+        });
+        return { result };
+    }
+    if (args.operation === undefined) {
+        throw new Error('operation is required unless resumeJobExecutionId is provided.');
+    }
+    const result = await performPromotionRun({
+        deploymentStepIds: args.deploymentStepIds,
+        hooks: silentPromotionRunHooks,
+        ignoredMetadata: args.ignoredMetadata,
+        operation: args.operation,
+        promotionId: args.promotionId,
+        recreatePromotionBranch: args.recreatePromotionBranch,
+        timeoutSeconds: waitTimeout,
+        wait: args.wait ?? true,
+    });
+    return { result };
+}
 async function environmentCreate(args) {
     const payload = buildCreatePayload(args.name, {
         'apex-test-level': args.apexTestLevel,
@@ -350,6 +397,107 @@ async function repositoryValidate(args) {
     });
     return { validation: normalizeRepositoryValidateResult(response) };
 }
+async function functionList(args = {}) {
+    const response = await CicdGateway.call({
+        endpoint: functionsEndpoint({ type: args.type ?? 'custom' }),
+        method: 'GET',
+    });
+    return { functions: normalizeFunctionsList(response) };
+}
+async function functionGet(args) {
+    const response = await CicdGateway.call({
+        endpoint: functionEndpoint(assertRequired(args.apiName, 'apiName')),
+        method: 'GET',
+    });
+    return { function: normalizeFunction(response) };
+}
+async function functionDefaults(args) {
+    const response = await CicdGateway.call({
+        body: {
+            imageName: args.imageName ?? 'copado-function-core:v1',
+            name: assertRequired(args.name, 'name'),
+            runtime: args.runtime ?? 'bash',
+        },
+        endpoint: functionsEndpoint(),
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'POST',
+    });
+    return { function: normalizeFunction(response) };
+}
+async function functionUpsert(args) {
+    const apiName = assertRequired(args.apiName, 'apiName');
+    const payload = normalizeFunctionUpsertPayload(apiName, args);
+    const response = await CicdGateway.call({
+        body: payload,
+        endpoint: functionEndpoint(apiName),
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'PUT',
+    });
+    return { function: normalizeFunction(response) };
+}
+async function functionDelete(args) {
+    const apiName = assertRequired(args.apiName, 'apiName');
+    await CicdGateway.call({
+        endpoint: functionEndpoint(apiName),
+        method: 'DELETE',
+    });
+    return { apiName };
+}
+async function functionRun(args) {
+    const apiName = assertRequired(args.apiName, 'apiName');
+    const response = await CicdGateway.call({
+        body: {
+            deployFirst: args.deployFirst ?? false,
+            showValidationErrors: args.showValidationErrors ?? true,
+            ...(args.contextId === undefined || args.contextId === null ? {} : { contextId: args.contextId }),
+            ...(args.parameters === undefined || args.parameters === null ? {} : { parameters: args.parameters }),
+            ...(args.function === undefined || args.function === null ? {} : { function: args.function }),
+        },
+        endpoint: functionRunEndpoint(apiName),
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'POST',
+    });
+    return { run: normalizeFunctionRunResult(response) };
+}
+async function functionResultGet(args) {
+    const response = await CicdGateway.call({
+        endpoint: functionResultEndpoint(assertRequired(args.resultId, 'resultId')),
+        method: 'GET',
+    });
+    return { result: normalizeFunctionResultStatus(response) };
+}
+async function functionResultLogGet(args) {
+    const resultId = assertRequired(args.resultId, 'resultId');
+    const log = await CicdGateway.call({
+        endpoint: functionResultLogEndpoint(resultId, args.type),
+        method: 'GET',
+        responseType: 'text',
+    });
+    return {
+        log,
+        resultId,
+        ...(args.type === undefined ? {} : { type: args.type }),
+    };
+}
+async function functionRunLocal(args) {
+    const parameter = args.parameters === undefined
+        ? undefined
+        : Object.entries(args.parameters).map(([key, value]) => `${key}=${value}`);
+    return executeLocalFunctionRun({
+        cwd: args.cwd,
+        image: args.image,
+        parameter,
+        platform: args.platform,
+        runtime: args.runtime,
+        script: assertRequired(args.script, 'script'),
+    });
+}
 function buildRepositoryMcpPayload(args) {
     const payload = {};
     for (const [key, value] of Object.entries(args)) {
@@ -737,6 +885,7 @@ async function navigationResolve(args) {
 }
 export const agentiaMcpToolHandlers = {
     ...agentiaMcpAiToolHandlers,
+    ...agentiaMcpDataToolHandlers,
     authGet,
     authSet,
     credentialCreate,
@@ -746,6 +895,15 @@ export const agentiaMcpToolHandlers = {
     environmentGet,
     environmentList,
     environmentUpdate,
+    functionDefaults,
+    functionDelete,
+    functionGet,
+    functionList,
+    functionResultGet,
+    functionResultLogGet,
+    functionRun,
+    functionRunLocal,
+    functionUpsert,
     jobGet,
     jobKill,
     jobList,
@@ -776,6 +934,7 @@ export const agentiaMcpToolHandlers = {
     promotionConflictUnresolve,
     promotionGet,
     promotionList,
+    promotionRun,
     repositoryCreate,
     repositoryDelete,
     repositoryGet,
@@ -845,6 +1004,7 @@ const promotionListSchema = {
 };
 export function registerAgentiaMcpTools(server) {
     registerAgentiaMcpAiTools(server);
+    registerAgentiaMcpDataTools(server);
     registerAgentiaMcpTestingTools(server);
     server.registerTool('agentia_environment_list', {
         description: 'List Copado environments via the CICD gateway.',
@@ -912,6 +1072,34 @@ export function registerAgentiaMcpTools(server) {
         },
         title: 'Agentia Promotion Get',
     }, (args) => safelyHandleTool(() => promotionGet(args)));
+    server.registerTool('agentia_promotion_run', {
+        description: 'Preflight, start, and optionally wait for a Copado promotion. Can also resume an existing execution without starting a duplicate run.',
+        inputSchema: {
+            confirmRecreate: z
+                .boolean()
+                .optional()
+                .describe('Required true when recreatePromotionBranch is true because MCP cannot prompt.'),
+            deploymentStepIds: z
+                .array(z.string())
+                .optional()
+                .describe('Ordered deployment-step Salesforce IDs. The gateway order is used when omitted.'),
+            ignoredMetadata: z.array(z.unknown()).optional().describe('Ignored metadata persisted before starting the run.'),
+            operation: z
+                .enum(PROMOTION_OPERATIONS)
+                .optional()
+                .describe('Promotion operation. Required unless resumeJobExecutionId is supplied.'),
+            promotionId: z.string().describe('18-character Salesforce Promotion ID.'),
+            recreatePromotionBranch: z.boolean().optional().describe('Recreate the promotion branch before execution.'),
+            resumeJobExecutionId: z.string().optional().describe('Resume this existing promotion execution instead of /run.'),
+            wait: z.boolean().optional().describe('Poll all created executions to terminal status. Defaults to true.'),
+            waitTimeout: z
+                .number()
+                .int()
+                .optional()
+                .describe(`Maximum total wait in seconds. Defaults to ${PROMOTION_RUN_DEFAULT_TIMEOUT_SECONDS}.`),
+        },
+        title: 'Agentia Promotion Run',
+    }, (args) => safelyHandleTool(() => promotionRun(args)));
     server.registerTool('agentia_job_list', {
         description: 'List Copado job executions via the CICD gateway.',
         inputSchema: {
@@ -1202,6 +1390,106 @@ export function registerAgentiaMcpTools(server) {
         inputSchema: { id: z.string().describe('Copado Git repository ID.') },
         title: 'Agentia Repository Validate',
     }, (args) => safelyHandleTool(() => repositoryValidate(args)));
+    server.registerTool('agentia_function_list', {
+        description: 'List Copado Functions via the CICD gateway.',
+        inputSchema: {
+            type: z.enum(FUNCTION_LIST_TYPES).optional().describe('List Custom functions only, or all functions.'),
+        },
+        title: 'Agentia Function List',
+    }, (args) => safelyHandleTool(() => functionList(args)));
+    server.registerTool('agentia_function_get', {
+        description: 'Get a Copado Function by API name via the CICD gateway.',
+        inputSchema: { apiName: z.string().describe('Function API name.') },
+        title: 'Agentia Function Get',
+    }, (args) => safelyHandleTool(() => functionGet(args)));
+    server.registerTool('agentia_function_defaults', {
+        description: 'Scaffold default Copado Function metadata without writing to Salesforce.',
+        inputSchema: {
+            imageName: z.string().optional().describe('Function container image.'),
+            name: z.string().describe('Function display name.'),
+            runtime: z.enum(FUNCTION_RUNTIMES).optional().describe('Script runtime.'),
+        },
+        title: 'Agentia Function Defaults',
+    }, (args) => safelyHandleTool(() => functionDefaults(args)));
+    server.registerTool('agentia_function_upsert', {
+        description: 'Create or update a Copado Function by API name via the CICD gateway.',
+        inputSchema: {
+            apexClass: z.string().nullable().optional().describe('Apex callback class.'),
+            apiName: z.string().describe('Function API name.'),
+            callback: z.string().nullable().optional().describe('Function callback type.'),
+            description: z.string().nullable().optional().describe('Function description.'),
+            flowHandler: z.string().nullable().optional().describe('Flow handler name.'),
+            imageName: z.string().optional().describe('Function container image.'),
+            name: z.string().optional().describe('Function display name; defaults to apiName when omitted.'),
+            parameters: z
+                .array(z.object({
+                defaultValue: z.string().optional(),
+                name: z.string(),
+                required: z.boolean().optional(),
+            }))
+                .optional()
+                .describe('Function parameters.'),
+            script: z
+                .object({
+                content: z.string(),
+                extension: z.enum(['sh', 'js', 'py']).optional(),
+                runtime: z.enum(FUNCTION_RUNTIMES).optional(),
+            })
+                .describe('Function script body and runtime.'),
+            size: z.string().optional().describe('Function size.'),
+            timeout: z.number().int().nullable().optional().describe('Timeout in seconds.'),
+            type: z.string().optional().describe('Function type.'),
+            version: z.string().optional().describe('Function version.'),
+        },
+        title: 'Agentia Function Upsert',
+    }, (args) => safelyHandleTool(() => functionUpsert(args)));
+    server.registerTool('agentia_function_delete', {
+        description: 'Delete a Copado Function by API name via the CICD gateway.',
+        inputSchema: { apiName: z.string().describe('Function API name.') },
+        title: 'Agentia Function Delete',
+    }, (args) => safelyHandleTool(() => functionDelete(args)));
+    server.registerTool('agentia_function_run', {
+        description: 'Run a Copado Function and return the result Id.',
+        inputSchema: {
+            apiName: z.string().describe('Function API name.'),
+            contextId: z.string().nullable().optional().describe('Execution context Id.'),
+            deployFirst: z.boolean().optional().describe('Deploy related metadata before running.'),
+            parameters: z.record(z.string(), z.string()).optional().describe('Run parameters as key/value strings.'),
+            showValidationErrors: z.boolean().optional().describe('Surface validation errors from the gateway.'),
+        },
+        title: 'Agentia Function Run',
+    }, (args) => safelyHandleTool(() => functionRun(args)));
+    server.registerTool('agentia_function_run_local', {
+        description: 'Run a Copado Function script locally in Docker without calling the CICD gateway. Override image when the Copado registry is unavailable.',
+        inputSchema: {
+            cwd: z
+                .string()
+                .optional()
+                .describe('Host directory bind-mounted at /app inside the container (defaults to process cwd).'),
+            image: z
+                .string()
+                .optional()
+                .describe('Docker image (default copado-function-core:v1). Override for partner/local registries.'),
+            parameters: z.record(z.string(), z.string()).optional().describe('Environment variables as key/value strings.'),
+            platform: z.string().optional().describe('Docker --platform value (e.g. linux/amd64).'),
+            runtime: z.enum(FUNCTION_RUNTIMES).optional().describe('Override runtime detection from the script extension.'),
+            script: z.string().describe('Path to the local function script (.sh, .js, or .py).'),
+        },
+        title: 'Agentia Function Run Local',
+    }, (args) => safelyHandleTool(() => functionRunLocal(args)));
+    server.registerTool('agentia_function_result_get', {
+        description: 'Get Copado Function execution status by result Id.',
+        inputSchema: { resultId: z.string().describe('Function result Id.') },
+        title: 'Agentia Function Result Get',
+    }, (args) => safelyHandleTool(() => functionResultGet(args)));
+    server.registerTool('agentia_function_result_log_get', {
+        description: 'Get log output for a Copado Function result.',
+        inputSchema: {
+            resultId: z.string().describe('Function result Id.'),
+            type: z.string().optional().describe('Optional log file type filter.'),
+        },
+        title: 'Agentia Function Result Log Get',
+    }, (args) => safelyHandleTool(() => functionResultLogGet(args)));
     server.registerTool('agentia_promotion_conflict_list', {
         description: 'List merge conflicts for a Copado promotion.',
         inputSchema: { promotionId: z.string().describe('Copado promotion ID.') },