Fix tool function parameter handling in examples and documentation

- Updated all example agents to use correct FunctionTool pattern
- Tool functions now properly receive params as Record<string, any>
- Added explicit function declarations for all tools
- Fixed examples: quickstart, default_agent, callbacks, fields_planner
- Updated README.md with correct usage pattern
- Standardized CHANGELOG.md formatting for consistency

This fixes the issue where tool parameters were not being passed
correctly, causing errors like "cannot read properties of undefined"
when LLMs called tools with parameters.

Author: njraladdin

CHANGELOG.md

@@ -1,7 +1,29 @@
 # Changelog
 
+## [current_version]
+* Fixed tool function parameter handling in all examples and documentation
+* Updated README.md with correct FunctionTool usage pattern showing explicit function declarations
+* Fixed examples (quickstart, default_agent, callbacks, fields_planner) to use correct tool function signatures with `params: Record<string, any>`
 
-## [current_version] 
+## [v1.0.4]
+* Migrated to @google/genai: Ported the codebase to use the official @google/genai package for improved Google AI integration
+* Added runAgent functionality: New capability to run agents directly by executing files, making the package more versatile when installed
+* Improved Environment Configuration: Moved project constants to .env file for better configuration management
+* Fixed automatic function declarations generation
+* Improved logic for checking whether to use Google AI or Vertex AI
+* Added bash script for quick build and package linking during development
+* Fixed VERSION object shorthand syntax error
+* Fixed ES module import issue in CLI tests on Node.js 18.x
+* Fixed undefined errors in LlmRequest.ts for strict TypeScript compilation
+* Fixed TypeScript isolatedModules errors for CI
+* Comprehensive test suite fixes across multiple components (FunctionTool, LlmAgentFields, sessionService, cliTools, BaseAgent, connectionsClient, enterpriseWebSearchTool, AgentTool, applicationIntegrationToolset, googleLlm, cli, asyncToolCallbacks, basetool, cliCreate)
+* Added automated testing with GitHub Actions: Continuous integration now runs automatically
+* Configured CI to run only unit tests
+* Updated GitHub Actions to run tests only for Node.js version 20.x
+* Fixed slow startup time on CLI run command
+* Removed spammy console logs for cleaner output
+* Cleaned up README
+* Added example agent to README for better onboarding
 
 ## [1.0.3] 
 * Removed JSDoc-based function description extraction, since JSDoc is not available at runtime for functions in TypeScript (unlike Python).

README.md

@@ -83,28 +83,50 @@ Here's a simple weather agent to get you started:
 ```typescript
 // agent.ts
 import { LlmAgent } from 'adk-typescript/agents';
-import { ToolContext } from 'adk-typescript/tools';
+import { ToolContext, FunctionTool } from 'adk-typescript/tools';
 import { runAgent } from 'adk-typescript';
 
-// Define a tool function with explicit parameters
+// Define a tool function - receives params as an object
 async function getWeather(
-  city: string,
+  params: Record<string, any>,
   context: ToolContext
 ): Promise<{ temperature: string; condition: string }> {
+  const city = params.city; // Extract city from params
   // Your weather API logic here
   return {
     temperature: '72°F',
     condition: 'Sunny'
   };
 }
 
+// Create a tool with explicit function declaration
+const getWeatherTool = new FunctionTool({
+  name: 'getWeather',
+  description: 'Get current weather for a city',
+  fn: getWeather,
+  functionDeclaration: {
+    name: 'getWeather',
+    description: 'Get current weather for a city',
+    parameters: {
+      type: 'object',
+      properties: {
+        city: {
+          type: 'string',
+          description: 'Name of the city'
+        }
+      },
+      required: ['city']
+    }
+  }
+});
+
 // Create your agent
 export const rootAgent = new LlmAgent({
   name: 'weather_agent',
   model: 'gemini-2.0-flash',
   description: 'A helpful weather assistant',
   instruction: 'You help users get weather information. Use the getWeather tool when asked about weather.',
-  tools: [getWeather], // Pass functions directly!
+  tools: [getWeatherTool],
 });
 
 // Run programmatically (optional)

examples/callbacks/agent.ts

@@ -1,8 +1,7 @@
 import { LlmAgent } from 'adk-typescript/agents';
-import { ToolContext } from 'adk-typescript/tools';
+import { ToolContext, FunctionTool, BaseTool } from 'adk-typescript/tools';
 import { CallbackContext } from 'adk-typescript/agents';
 import { LlmRequest, LlmResponse } from 'adk-typescript/models';
-import { BaseTool } from 'adk-typescript/tools';
 import { Content, Part } from 'adk-typescript/models';
 import { runAgent } from 'adk-typescript';
 
@@ -11,14 +10,15 @@ import { runAgent } from 'adk-typescript';
 /**
  * Roll a die and return the rolled result.
  *
- * @param sides The integer number of sides the die has
+ * @param params Tool parameters containing sides
  * @param toolContext The tool context
  * @returns The result of rolling the die
  */
 function rollDie(
-  sides: number,
+  params: Record<string, any>,
   toolContext: ToolContext
 ): number {
+  const sides = params.sides;
   const result = Math.floor(Math.random() * sides) + 1;
 
   if (!toolContext.state.get('rolls')) {
@@ -34,14 +34,15 @@ function rollDie(
 /**
  * Check if a given list of numbers are prime.
  *
- * @param nums The list of numbers to check
+ * @param params Tool parameters containing nums
  * @param toolContext The tool context
  * @returns A string indicating which numbers are prime
  */
 async function checkPrime(
-  nums: number[],
+  params: Record<string, any>,
   toolContext: ToolContext
 ): Promise<string> {
+  const nums = params.nums;
   const primes = new Set<number>();
 
   for (const number of nums) {
@@ -198,6 +199,48 @@ function afterToolCb3(
 
 // --- Agent Definition ---
 
+// Create tools with explicit function declarations
+const rollDieTool = new FunctionTool({
+  name: 'rollDie',
+  description: 'Roll a die and return the rolled result',
+  fn: rollDie,
+  functionDeclaration: {
+    name: 'rollDie',
+    description: 'Roll a die and return the rolled result',
+    parameters: {
+      type: 'object',
+      properties: {
+        sides: {
+          type: 'number',
+          description: 'The integer number of sides the die has'
+        }
+      },
+      required: ['sides']
+    }
+  }
+});
+
+const checkPrimeTool = new FunctionTool({
+  name: 'checkPrime',
+  description: 'Check if a given list of numbers are prime',
+  fn: checkPrime,
+  functionDeclaration: {
+    name: 'checkPrime',
+    description: 'Check if a given list of numbers are prime',
+    parameters: {
+      type: 'object',
+      properties: {
+        nums: {
+          type: 'array',
+          description: 'The list of numbers to check',
+          items: { type: 'number' }
+        }
+      },
+      required: ['nums']
+    }
+  }
+});
+
 export const rootAgent = new LlmAgent({
   name: 'data_processing_agent',
   model: 'gemini-2.0-flash',
@@ -219,7 +262,7 @@ export const rootAgent = new LlmAgent({
     You should always perform the previous 3 steps when asking for a roll and checking prime numbers.
     You should not rely on the previous history on prime results.
   `,
-  tools: [rollDie, checkPrime],
+  tools: [rollDieTool, checkPrimeTool],
   safetySettings: [
     {
       category: 'HARM_CATEGORY_DANGEROUS_CONTENT',

examples/default_agent/agent.ts

@@ -1,20 +1,21 @@
 import { LlmAgent as Agent } from 'adk-typescript/agents';
 import { LlmRegistry } from 'adk-typescript/models';
-import { ToolContext } from 'adk-typescript/tools';
+import { ToolContext, FunctionTool } from 'adk-typescript/tools';
 import { runAgent } from 'adk-typescript';
 
 // --- Tool Functions ---
 
 /**
  * Returns current weather information for a specified city
- * @param city Name of the city to get weather for
+ * @param params Tool parameters object containing city
  * @param context Optional ToolContext
  * @returns Promise resolving to weather information or error
  */
 async function getWeather(
-  city: string,
+  params: Record<string, any>,
   context: ToolContext
 ): Promise<{ status: string; report?: string; error_message?: string }> {
+  const city = params.city;
   console.log(`--- Tool: getWeather called for city: ${city} ---`);
   const cityNormalized = city.toLowerCase().trim();
   const mockWeatherDb: Record<string, { status: string; report: string }> = {
@@ -28,10 +29,12 @@ async function getWeather(
 
 /**
  * Gets the current local time and timezone.
+ * @param params Tool parameters object (no parameters needed)
  * @param context Optional ToolContext
  * @returns Promise resolving to time information
  */
 async function getCurrentTime(
+  params: Record<string, any>,
   context: ToolContext
 ): Promise<{ currentTime: string; timezone: string; }> {
     console.log(`--- Tool: getCurrentTime called ---`);
@@ -44,19 +47,51 @@ async function getCurrentTime(
 
 // --- Agent Definition ---
 
-// Use LlmRegistry to get a model instance
-const agentLlm = LlmRegistry.newLlm("gemini-2.0-flash"); // Or another compatible model
+// Create tools with explicit function declarations
+const getWeatherTool = new FunctionTool({
+  name: 'getWeather',
+  description: 'Returns current weather information for a specified city',
+  fn: getWeather,
+  functionDeclaration: {
+    name: 'getWeather',
+    description: 'Returns current weather information for a specified city',
+    parameters: {
+      type: 'object',
+      properties: {
+        city: {
+          type: 'string',
+          description: 'Name of the city to get weather for'
+        }
+      },
+      required: ['city']
+    }
+  }
+});
+
+const getCurrentTimeTool = new FunctionTool({
+  name: 'getCurrentTime',
+  description: 'Gets the current local time and timezone',
+  fn: getCurrentTime,
+  functionDeclaration: {
+    name: 'getCurrentTime',
+    description: 'Gets the current local time and timezone',
+    parameters: {
+      type: 'object',
+      properties: {},
+      required: []
+    }
+  }
+});
 
 // Export the root agent for ADK tools to find
-// Now we can pass functions directly to the tools array!
 export const rootAgent = new Agent({
   name: "default_agent", // Unique agent name
-  model: agentLlm,       // LLM instance
+  model: "gemini-2.0-flash",
   description: "Provides current weather and time information for cities.",
   instruction: "You are a helpful assistant. Use the 'getWeather' tool for weather queries " +
                "and the 'getCurrentTime' tool for time queries. Provide clear answers based on tool results. " +
                "If asked for weather AND time, use both tools.",
-  tools: [getWeather, getCurrentTime], // Functions can now be passed directly!
+  tools: [getWeatherTool, getCurrentTimeTool],
 });
 
 // Run agent directly when this file is executed

examples/fields_planner/agent.ts

@@ -1,23 +1,22 @@
-
-
 import { LlmAgent as Agent } from 'adk-typescript/agents';
 import { BuiltInPlanner } from 'adk-typescript/planners';
-import { ToolContext } from 'adk-typescript/tools';
+import { ToolContext, FunctionTool } from 'adk-typescript/tools';
 import { runAgent } from 'adk-typescript';
 
 // --- Tool Functions ---
 
 /**
  * Roll a die and return the rolled result.
  *
- * @param sides The integer number of sides the die has.
+ * @param params Tool parameters containing sides
  * @param toolContext The tool context for state management.
  * @returns An integer of the result of rolling the die.
  */
 function rollDie(
-  sides: number,
+  params: Record<string, any>,
   toolContext: ToolContext
 ): number {
+  const sides = params.sides;
   const result = Math.floor(Math.random() * sides) + 1;
 
   if (!toolContext.state.get('rolls')) {
@@ -33,12 +32,15 @@ function rollDie(
 /**
  * Check if a given list of numbers are prime.
  *
- * @param nums The list of numbers to check.
+ * @param params Tool parameters containing nums
+ * @param toolContext The tool context (optional)
  * @returns A string indicating which number is prime.
  */
 async function checkPrime(
-  nums: number[]
+  params: Record<string, any>,
+  toolContext?: ToolContext
 ): Promise<string> {
+  const nums = params.nums;
   const primes = new Set<number>();
 
   for (const number of nums) {
@@ -67,6 +69,48 @@ async function checkPrime(
 
 // --- Agent Definition ---
 
+// Create tools with explicit function declarations
+const rollDieTool = new FunctionTool({
+  name: 'rollDie',
+  description: 'Roll a die and return the rolled result',
+  fn: rollDie,
+  functionDeclaration: {
+    name: 'rollDie',
+    description: 'Roll a die and return the rolled result',
+    parameters: {
+      type: 'object',
+      properties: {
+        sides: {
+          type: 'number',
+          description: 'The integer number of sides the die has'
+        }
+      },
+      required: ['sides']
+    }
+  }
+});
+
+const checkPrimeTool = new FunctionTool({
+  name: 'checkPrime',
+  description: 'Check if a given list of numbers are prime',
+  fn: checkPrime,
+  functionDeclaration: {
+    name: 'checkPrime',
+    description: 'Check if a given list of numbers are prime',
+    parameters: {
+      type: 'object',
+      properties: {
+        nums: {
+          type: 'array',
+          description: 'The list of numbers to check',
+          items: { type: 'number' }
+        }
+      },
+      required: ['nums']
+    }
+  }
+});
+
 export const rootAgent = new Agent({
   model: 'gemini-2.0-flash',
   name: 'data_processing_agent',
@@ -88,7 +132,7 @@ export const rootAgent = new Agent({
     You should always perform the previous 3 steps when asking for a roll and checking prime numbers.
     You should not rely on the previous history on prime results.
   `,
-  tools: [rollDie, checkPrime],
+  tools: [rollDieTool, checkPrimeTool],
   planner: new BuiltInPlanner({
     includeThoughts: true,
   }),