```diff
--- test_files/518-original.txt	2025-03-07 19:07:05
+++ test_files/518-modified.txt	2025-03-07 19:07:05
@@ -1,82 +1,144 @@
-import { CoreTool, GenerateTextResult, tool } from "ai";
+import { CoreTool, jsonSchema, tool } from "ai";
+import { z } from "zod";
 import { ComposioToolSet as BaseComposioToolSet } from "../sdk/base.toolset";
-import { jsonSchemaToModel } from "../utils/shared";
+import { TELEMETRY_LOGGER } from "../sdk/utils/telemetry";
+import { TELEMETRY_EVENTS } from "../sdk/utils/telemetry/events";
+import { RawActionData } from "../types/base_toolset";
 
 type Optional<T> = T | null;
-type Sequence<T> = Array<T>;
 
+const ZExecuteToolCallParams = z.object({
+  actions: z.array(z.string()).optional(),
+  apps: z.array(z.string()).optional(),
+  params: z.record(z.any()).optional(),
+  entityId: z.string().optional(),
+  useCase: z.string().optional(),
+  usecaseLimit: z.number().optional(),
+  connectedAccountId: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+
+  filterByAvailableApps: z.boolean().optional().default(false),
+});
+
 export class VercelAIToolSet extends BaseComposioToolSet {
-  constructor(config: {
-    apiKey?: Optional<string>;
-    baseUrl?: Optional<string>;
-    entityId?: string;
-  }) {
-    super(
-      config.apiKey || null,
-      config.baseUrl || null,
-      "vercel-ai",
-      config.entityId || "default"
-    );
+  fileName: string = "js/src/frameworks/vercel.ts";
+  constructor(
+    config: {
+      apiKey?: Optional<string>;
+      baseUrl?: Optional<string>;
+      entityId?: string;
+      connectedAccountIds?: Record<string, string>;
+      allowTracing?: boolean;
+    } = {}
+  ) {
+    super({
+      apiKey: config.apiKey || null,
+      baseUrl: config.baseUrl || null,
+      runtime: "vercel-ai",
+      entityId: config.entityId || "default",
+      connectedAccountIds: config.connectedAccountIds,
+      allowTracing: config.allowTracing || false,
+    });
   }
 
-  generateVercelTool(schema: any) {
-    const parameters = jsonSchemaToModel(schema.parameters);
+  private generateVercelTool(
+    schema: RawActionData,
+    entityId: Optional<string> = null
+  ) {
     return tool({
       description: schema.description,
-      parameters,
-      execute: async (params: Record<string, string>) => {
-        return await this.execute_tool_call({
-          name: schema.name,
-          arguments: JSON.stringify(params)
-        }, this.entityId);
+      // @ts-ignore the type are JSONSchemV7. Internally it's resolved
+      parameters: jsonSchema(schema.parameters as unknown),
+      execute: async (params) => {
+        return await this.executeToolCall(
+          {
+            name: schema.name,
+            arguments: JSON.stringify(params),
+          },
+          entityId || this.entityId
+        );
       },
     });
   }
 
-  async get_actions(filters: { actions: Sequence<string>; }): Promise<{ [key: string]: any }> {
-    const actionsList = await this.getActionsSchema(filters);
-    const tools = {};
-
-    actionsList.forEach(actionSchema => {
-      // @ts-ignore
-      tools[actionSchema.name!] = this.generateVercelTool(actionSchema);
+  // change this implementation
+  async getTools(
+    filters: {
+      actions?: Array<string>;
+      apps?: Array<string>;
+      tags?: Optional<Array<string>>;
+      useCase?: Optional<string>;
+      usecaseLimit?: Optional<number>;
+      filterByAvailableApps?: Optional<boolean>;
+      integrationId?: Optional<string>;
+    },
+    entityId: Optional<string> = null
+  ): Promise<{ [key: string]: CoreTool }> {
+    TELEMETRY_LOGGER.manualTelemetry(TELEMETRY_EVENTS.SDK_METHOD_INVOKED, {
+      method: "getTools",
+      file: this.fileName,
+      params: filters,
     });
 
-    return tools;
-  }
+    const {
+      apps,
+      tags,
+      useCase,
+      usecaseLimit,
+      filterByAvailableApps,
+      actions,
+    } = ZExecuteToolCallParams.parse(filters);
 
-  async get_tools(filters: {
-    apps: Sequence<string>;
-    tags: Optional<Array<string>>;
-    useCase: Optional<string>;
-  }): Promise<{ [key: string]: any }> {
-    const actionsList = await this.client.actions.list({
-      apps: filters.apps.join(","),
-      tags: filters.tags?.join(","),
-      filterImportantActions: !filters.tags && !filters.useCase,
-      useCase: filters.useCase || undefined,
-    });
+    const actionsList = await this.getToolsSchema(
+      {
+        apps,
+        actions,
+        tags,
+        useCase,
+        useCaseLimit: usecaseLimit,
+        filterByAvailableApps,
+      },
+      entityId,
+      filters.integrationId
+    );
 
-    const tools = {};
-    actionsList.items?.forEach(actionSchema => {
-      // @ts-ignore
-      tools[actionSchema.name!] = this.generateVercelTool(actionSchema);
+    const tools: { [key: string]: CoreTool } = {};
+    actionsList.forEach((actionSchema) => {
+      tools[actionSchema.name!] = this.generateVercelTool(
+        actionSchema,
+        entityId
+      );
     });
 
     return tools;
   }
 
-  async execute_tool_call(
-    tool: { name: string; arguments: unknown; },
+  async executeToolCall(
+    tool: { name: string; arguments: unknown },
     entityId: Optional<string> = null
   ): Promise<string> {
+    TELEMETRY_LOGGER.manualTelemetry(TELEMETRY_EVENTS.SDK_METHOD_INVOKED, {
+      method: "executeToolCall",
+      file: this.fileName,
+      params: { tool, entityId },
+    });
+
+    const toolSchema = await this.getToolsSchema({
+      actions: [tool.name],
+    });
+    const appName = toolSchema[0]?.appName?.toLowerCase();
+    const connectedAccountId = appName && this.connectedAccountIds?.[appName];
+
     return JSON.stringify(
-      await this.executeAction(
-        tool.name,
-        typeof tool.arguments === "string" ? JSON.parse(tool.arguments) : tool.arguments,
-        entityId || this.entityId
-      )
+      await this.executeAction({
+        action: tool.name,
+        params:
+          typeof tool.arguments === "string"
+            ? JSON.parse(tool.arguments)
+            : tool.arguments,
+        entityId: entityId || this.entityId,
+        connectedAccountId: connectedAccountId,
+      })
     );
   }
-
 }
```
