run_scenario_11707

Trigger and interact with automation workflows by processing an array of text collections. Designed for integrating Make scenarios with AI systems to enhance task automation.

Instructions

Scenario Inputs: Array of Collections

Input Schema

TableJSON Schema

Name	Required	Description	Default
`array`	No

Implementation Reference

src/index.ts:59-87 (handler)

Dynamic handler for all 'run_scenario_<ID>' tools, including 'run_scenario_11707'. Extracts scenario ID from tool name and executes the scenario via make.scenarios.run, returning outputs as JSON or error.

server.setRequestHandler(CallToolRequestSchema, async request => {
    if (/^run_scenario_\d+$/.test(request.params.name)) {
        try {
            const output = (
                await make.scenarios.run(parseInt(request.params.name.substring(13)), request.params.arguments)
            ).outputs;

            return {
                content: [
                    {
                        type: 'text',
                        text: output ? JSON.stringify(output, null, 2) : 'Scenario executed successfully.',
                    },
                ],
            };
        } catch (err: unknown) {
            return {
                isError: true,
                content: [
                    {
                        type: 'text',
                        text: String(err),
                    },
                ],
            };
        }
    }
    throw new Error(`Unknown tool: ${request.params.name}`);
});

src/index.ts:37-57 (registration)

Dynamic registration of 'run_scenario_<ID>' tools via ListToolsRequestHandler. Filters on-demand scenarios, generates tool name 'run_scenario_11707' for ID 11707, description, and inputSchema.

server.setRequestHandler(ListToolsRequestSchema, async () => {
    const scenarios = await make.scenarios.list(teamId);
    return {
        tools: await Promise.all(
            scenarios
                .filter(scenario => scenario.scheduling.type === 'on-demand')
                .map(async scenario => {
                    const inputs = (await make.scenarios.interface(scenario.id)).input;
                    return {
                        name: `run_scenario_${scenario.id}`,
                        description: scenario.name + (scenario.description ? ` (${scenario.description})` : ''),
                        inputSchema: remap({
                            name: 'wrapper',
                            type: 'collection',
                            spec: inputs,
                        }),
                    };
                }),
        ),
    };
});

src/utils.ts:60-108 (schema)

remap utility converts Make's scenario input spec (Input type) to JSON Schema object used in tool inputSchema for 'run_scenario_11707'.

export function remap(field: Input): unknown {
    switch (field.type) {
        case 'collection':
            const required: string[] = [];
            const properties: unknown = (Array.isArray(field.spec) ? field.spec : []).reduce((object, subField) => {
                if (!subField.name) return object;
                if (subField.required) required.push(subField.name);

                return Object.defineProperty(object, subField.name, {
                    enumerable: true,
                    value: remap(subField),
                });
            }, {});

            return {
                type: 'object',
                description: noEmpty(field.help),
                properties,
                required,
            };
        case 'array':
            return {
                type: 'array',
                description: noEmpty(field.help),
                items:
                    field.spec &&
                    remap(
                        Array.isArray(field.spec)
                            ? {
                                  type: 'collection',
                                  spec: field.spec,
                              }
                            : field.spec,
                    ),
            };
        case 'select':
            return {
                type: 'string',
                description: noEmpty(field.help),
                enum: (field.options || []).map(option => option.value),
            };
        default:
            return {
                type: PRIMITIVE_TYPE_MAP[field.type as keyof typeof PRIMITIVE_TYPE_MAP],
                default: field.default != '' && field.default != null ? field.default : undefined,
                description: noEmpty(field.help),
            };
    }
}

src/make.ts:33-42 (helper)

Scenarios.run method: core API call to execute scenario 11707 with input arguments, returns execution outputs.

    async run(scenarioId: number, body: unknown): Promise<ScenarioRunServerResponse> {
        return await this.#fetch<ScenarioRunServerResponse>(`/scenarios/${scenarioId}/run`, {
            method: 'POST',
            body: JSON.stringify({ data: body, responsive: true }),
            headers: {
                'content-type': 'application/json',
            },
        });
    }
}

Make MCP Server