don't allow too function to be void

Author: svozza

packages/event-handler/src/bedrock-agent-function/BedrockAgentFunctionResolver.ts

@@ -97,9 +97,15 @@ export class BedrockAgentFunctionResolver {
     }
 
     // When used as a decorator
-    return (_target, _propertyKey, descriptor: PropertyDescriptor) => {
-      const toolFn = descriptor.value as ToolFunction;
-      this.#registerTool(toolFn, fnOrConfig);
+    return (target, propertyKey, descriptor: PropertyDescriptor) => {
+      const originalMethod = descriptor.value;
+
+      // Store a wrapper function that will call the original method with the correct 'this'
+      this.#registerTool(async (params, event, context) => {
+        // This wrapper will receive the instance through closure when called
+        return originalMethod.apply(target, [params, event, context]);
+      }, fnOrConfig);
+
       return descriptor;
     };
   }
@@ -207,8 +213,9 @@ export class BedrockAgentFunctionResolver {
 
     try {
       // TODO: use apply to ensure that `this` is bound properly when used as decorator
-      const res = await tool.handler(toolParams, event, context);
-      const body = res == null ? '' : JSON.stringify(res); //TODO just use JSON.stringify
+      const res = await tool.handler.apply(this, [toolParams, event, context]);
+      // const res = await tool.handler(toolParams, event, context);
+      const body = res == null ? '' : JSON.stringify(res);
       return this.#buildResponse({
         actionGroup,
         function: toolName,

packages/event-handler/src/types/bedrock-agent-function.ts

@@ -21,16 +21,13 @@ type ToolFunction<TParams = Record<string, ParameterValue>> = (
   params: TParams,
   event: BedrockAgentFunctionEvent,
   context: Context
-  // biome-ignore lint/suspicious/noConfusingVoidType: we need to support async functions that don't have an explicit return value
-) => Promise<JSONValue | void>;
+) => Promise<JSONValue>;
 
 type Tool<TParams = Record<string, ParameterValue>> = {
   handler: ToolFunction<TParams>;
   config: Configuration;
 };
 
-type Attributes = Record<string, string>;
-
 type FunctionIdentifier = {
   actionGroup: string;
   function: string;
@@ -50,8 +47,8 @@ type BedrockAgentFunctionEvent = FunctionInvocation & {
   };
   inputText: string;
   sessionId: string;
-  sessionAttributes: Attributes;
-  promptSessionAttributes: Attributes;
+  sessionAttributes: Record<string, string>;
+  promptSessionAttributes: Record<string, string>;
 };
 
 type ResponseState = 'ERROR' | 'REPROMPT';
@@ -63,8 +60,8 @@ type TextResponseBody = {
 };
 
 type SessionData = {
-  sessionAttributes?: Attributes;
-  promptSessionAttributes?: Attributes;
+  sessionAttributes?: Record<string, string>;
+  promptSessionAttributes?: Record<string, string>;
 };
 
 type BedrockAgentFunctionResponse = SessionData & {
@@ -100,7 +97,6 @@ export type {
   Tool,
   ToolFunction,
   Parameter,
-  Attributes,
   ParameterValue,
   FunctionIdentifier,
   FunctionInvocation,

packages/event-handler/src/types/index.ts

@@ -10,16 +10,8 @@ export type {
 } from './appsync-events.js';
 
 export type {
-  Configuration,
-  Tool,
-  ToolFunction,
-  Parameter,
-  Attributes,
-  FunctionIdentifier,
-  FunctionInvocation,
   BedrockAgentFunctionEvent,
   BedrockAgentFunctionResponse,
-  ResponseOptions,
   ResolverOptions,
 } from './bedrock-agent-function.js';
 

packages/event-handler/tests/unit/bedrock-agent/BedrockAgentFunctionResolver.test.ts

@@ -83,10 +83,15 @@ describe('Class: BedrockAgentFunctionResolver', () => {
     // Prepare
     const app = new BedrockAgentFunctionResolver();
 
-    app.tool(async (_params) => {}, {
-      name: 'noop',
-      description: 'Does nothing',
-    });
+    app.tool(
+      async (params: { arg: string }) => {
+        return params.arg;
+      },
+      {
+        name: 'identity',
+        description: 'Returns its arg',
+      }
+    );
 
     // Assess
     expect(console.debug).not.toHaveBeenCalled();
@@ -97,10 +102,15 @@ describe('Class: BedrockAgentFunctionResolver', () => {
     vi.stubEnv('AWS_LAMBDA_LOG_LEVEL', 'DEBUG');
     const app = new BedrockAgentFunctionResolver();
 
-    app.tool(async (_params) => {}, {
-      name: 'noop',
-      description: 'Does nothing',
-    });
+    app.tool(
+      async (params: { arg: string }) => {
+        return params.arg;
+      },
+      {
+        name: 'identity',
+        description: 'Returns its arg',
+      }
+    );
 
     // Assess
     expect(console.debug).toHaveBeenCalled();
@@ -111,10 +121,15 @@ describe('Class: BedrockAgentFunctionResolver', () => {
     const app = new BedrockAgentFunctionResolver();
 
     for (const num of [1, 2, 3, 4, 5]) {
-      app.tool(async (_params) => {}, {
-        name: `noop${num}`,
-        description: 'Does nothing',
-      });
+      app.tool(
+        async (params: { arg: string }) => {
+          return params.arg;
+        },
+        {
+          name: `identity${num}`,
+          description: 'Returns its arg',
+        }
+      );
     }
 
     app.tool(
@@ -214,15 +229,25 @@ describe('Class: BedrockAgentFunctionResolver', () => {
     };
     const app = new BedrockAgentFunctionResolver({ logger });
 
-    app.tool(async (_params) => {}, {
-      name: 'noop',
-      description: 'Does nothing',
-    });
+    app.tool(
+      async (params: { arg: string }) => {
+        return params.arg;
+      },
+      {
+        name: 'identity',
+        description: 'Returns its arg',
+      }
+    );
 
-    app.tool(async (_params) => {}, {
-      name: 'noop',
-      description: 'Does nothing',
-    });
+    app.tool(
+      async (params: { arg: string }) => {
+        return params.arg;
+      },
+      {
+        name: 'identity',
+        description: 'Returns its arg',
+      }
+    );
 
     app.tool(
       async (_params) => {