function yourFunctionName(event: ActionGroupInvocationInput, params: Record<string, any>) {
    // Your logic here
    return result;
}

import { ActionGroupInvocationInput } from '@aws-sdk/client-bedrock-agent-runtime';

function random(event: ActionGroupInvocationInput, params: Record<string, any>) {
    console.log('Random number generator tool called with params:', params);

    let min = params.min;
    let max = params.max;
    let range = max - min;
    let val = Math.random() * range + min;
    let factor = Math.pow(10, params.precision ?? 0);
    return Math.round(val * factor) / factor;
}

import { FunctionDefinition } from '@aws-sdk/client-bedrock-agent-runtime';

export const randomNumFunctions: FunctionDefinition[] = [
    {
        name: 'random-number',
        description: 'Creates a random number between min and max.',
        parameters: {
            max: {
                description: 'max value (exclusive)',
                required: true,
                type: 'number'
            },
            min: {
                description: 'min value (inclusive)',
                required: true,
                type: 'number'
            },
            precision: {
                description: 'number of decimal places to include (default 0)',
                required: false,
                type: 'number'
            }
        },
        requireConfirmation: 'DISABLED'
    }
];

private transpileInlineCodeToJavascript(filePath: string): string {
    // Resolve the file path relative to this stack file
    const absolutePath = path.resolve(__dirname, filePath);

    // Read the TypeScript file
    const tsCode = fs.readFileSync(absolutePath, 'utf8');

    // Use esbuild to transpile TypeScript to JavaScript synchronously
    const result = esbuild.transformSync(tsCode, {
        loader: 'ts',
        target: 'es2022',
        format: 'esm'
    });

    const jsCode = result.code;

    if (!jsCode.trim()) {
        throw new Error(`No function found in ${filePath}`);
    }

    // Validate that the code starts with a function declaration
    if (!jsCode.trim().startsWith('function ')) {
        throw new Error(`Code does not start with a function declaration in ${filePath}`);
    }

    return jsCode;
}

{
    "dependencies": {
        "esbuild": "^0.19.0"
    },
    "devDependencies": {
        "@types/node": "^18.0.0"
    }
}

const randomNumInlineCode = this.transpileInlineCodeToJavascript('../../src/random-num-inline/inline-code.ts');

const agentData: AgentDataRequest = {
    userId: `cloudformation/${this.stackName}`,
    agent: {
        agentId: `${props.projNameKebabCase}-agent-${this.stage}`,
        basePrompt: randomNumInlineAgentInstruction
    },
    tools: [
        {
            toolId: `${props.projNameKebabCase}-tool-${this.stage}`,
            executionType: 'inline',  // This marks it as an inline tool
            name: `${props.projNameKebabCase}-tool`,
            displayName: `${props.projNameTitleCase} Tool`,
            code: randomNumInlineCode,  // The transpiled JavaScript code
            description: `A tool that can be used to generate random numbers`,
            functionSchema: randomNumFunctions,
            supportedAgentFrameworks: ['bedrock']
        }
    ]
};

your-inline-tool/
├── src/
│   └── your-tool/
│       ├── inline-code.ts          # Your tool function
│       ├── tool-functions.ts       # Function schema definition
│       ├── tool-instructions.ts    # Agent instructions
│       └── tool-suggestions.ts     # Optional chat suggestions
├── lib/
│   └── stacks/
│       └── your-tool-stack.ts      # CDK stack with transpilation
├── bin/
│   └── your-tool.ts                # CDK app entry point
├── package.json
├── tsconfig.json
└── cdk.json

npm run deploy

function random(event: ActionGroupInvocationInput, params: Record<string, any>) {
    console.log('Random number generator tool called with params:', params);

    let min = params.min;
    let max = params.max;
    let range = max - min;
    let val = Math.random() * range + min;
    let factor = Math.pow(10, params.precision ?? 0);
    return Math.round(val * factor) / factor;
}

export const randomNumInlineAgentInstruction = `You are a random number generator. You will use the tool provided to generate a random number.

If the user doesn't provide a min or max value, then you should use a default of 1 and 100 respectively by default and let them know that you are using defaults and that they can provide a min and max value if they want to.

{{prompt-assistance}}
`;