```diff
--- test_files/511-original.txt	2025-03-07 19:07:05
+++ test_files/511-modified.txt	2025-03-07 19:07:05
@@ -1,130 +1,91 @@
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { z } from "zod";
 import { ComposioToolSet as BaseComposioToolSet } from "../sdk/base.toolset";
+import { COMPOSIO_BASE_URL } from "../sdk/client/core/OpenAPI";
+import { TELEMETRY_LOGGER } from "../sdk/utils/telemetry";
+import { TELEMETRY_EVENTS } from "../sdk/utils/telemetry/events";
+import { RawActionData, ZToolSchemaFilter } from "../types/base_toolset";
+import type { Optional, Sequence } from "../types/util";
 import { jsonSchemaToModel } from "../utils/shared";
-import { DynamicStructuredTool } from "@langchain/core/tools";
 
-type Optional<T> = T | null;
-type Dict<T> = { [key: string]: T };
-type Sequence<T> = Array<T>;
-
 export class LangchainToolSet extends BaseComposioToolSet {
-    /**
-     * Composio toolset for Langchain framework.
-     *
-     * Example:
-     * ```typescript
-     * import * as dotenv from "dotenv";
-     * import { App, ComposioToolSet } from "composio_langchain";
-     * import { AgentExecutor, create_openai_functions_agent } from "langchain/agents";
-     * import { ChatOpenAI } from "langchain_openai";
-     * import { hub } from "langchain";
-     *
-     * // Load environment variables from .env
-     * dotenv.config();
-     *
-     * // Pull relevant agent model.
-     * const prompt = hub.pull("hwchase17/openai-functions-agent");
-     *
-     * // Initialize tools.
-     * const openai_client = new ChatOpenAI({ apiKey: process.env.OPENAI_API_KEY });
-     * const composio_toolset = new ComposioToolSet();
-     *
-     * // Get All the tools
-     * const tools = composio_toolset.get_tools({ apps: [App.GITHUB] });
-     *
-     * // Define task
-     * const task = "Star a repo composiohq/composio on GitHub";
-     *
-     * // Define agent
-     * const agent = create_openai_functions_agent(openai_client, tools, prompt);
-     * const agent_executor = new AgentExecutor({ agent, tools, verbose: true });
-     *
-     * // Execute using agent_executor
-     * agent_executor.invoke({ input: task });
-     * ```
-     */
-    constructor(
-        config: {
-            apiKey?: Optional<string>,
-            baseUrl?: Optional<string>,
-            entityId?: string
-        }
-    ) {
-        super(
-            config.apiKey || null,
-            config.baseUrl || null,
-            "langchain",
-            config.entityId || "default"
-        );
-    }
+  /**
+   * Composio toolset for Langchain framework.
+   *
+   */
+  static FRAMEWORK_NAME = "langchain";
+  static DEFAULT_ENTITY_ID = "default";
+  fileName: string = "js/src/frameworks/langchain.ts";
 
-    private _wrap_tool(
-        schema: Dict<any>,
-        entityId: Optional<string> = null
-    ): DynamicStructuredTool {
-        const app = schema["appName"];
-        const action = schema["name"];
-        const description = schema["description"];
+  constructor(
+    config: {
+      apiKey?: Optional<string>;
+      baseUrl?: Optional<string>;
+      entityId?: string;
+      runtime?: string;
+      connectedAccountIds?: Record<string, string>;
+      allowTracing?: boolean;
+    } = {}
+  ) {
+    super({
+      apiKey: config.apiKey || null,
+      baseUrl: config.baseUrl || COMPOSIO_BASE_URL,
+      runtime: config?.runtime || LangchainToolSet.FRAMEWORK_NAME,
+      entityId: config.entityId || LangchainToolSet.DEFAULT_ENTITY_ID,
+      connectedAccountIds: config.connectedAccountIds,
+      allowTracing: config.allowTracing || false,
+    });
+  }
 
-        const func = async (...kwargs: any[]): Promise<any> => {
-            return JSON.stringify(await this.execute_action(
-                action,
-                kwargs[0],
-                entityId || this.entityId
-            ));
-        };
+  private _wrapTool(
+    schema: RawActionData,
+    entityId: Optional<string> = null
+  ): DynamicStructuredTool {
+    const action = schema["name"];
+    const description = schema["description"];
+    const appName = schema["appName"]?.toLowerCase();
 
-        const parameters = jsonSchemaToModel(schema["parameters"]);
-        // @TODO: Add escriiption an othjer stuff here
+    const func = async (...kwargs: unknown[]): Promise<unknown> => {
+      const connectedAccountId = appName && this.connectedAccountIds?.[appName];
+      return JSON.stringify(
+        await this.executeAction({
+          action,
+          params: kwargs[0] as Record<string, unknown>,
+          entityId: entityId || this.entityId,
+          connectedAccountId: connectedAccountId,
+        })
+      );
+    };
 
-        return new DynamicStructuredTool({
-            name: action,
-            description,
-            schema: parameters,
-            func: func
-        });
-    }
+    const parameters = jsonSchemaToModel(schema["parameters"]);
 
-    async get_actions(
-        filters: {
-            actions?: Optional<Sequence<string>>
-        } = {},
-        entityId?: Optional<string>
-    ): Promise<Sequence<DynamicStructuredTool>> {
-        const actions =  (await this.client.actions.list({
-            actions: filters.actions?.join(","),
-            showAll: true
-        })).items?.filter((a) => {
-            return filters.actions
-        });
-         
-         return actions!.map(tool =>
-            this._wrap_tool(
-                tool,
-                entityId || this.entityId
-            )
-        );
-    }
+    // @TODO: Add escriiption an other stuff here
 
-    async get_tools(
-        filters: {
-            apps: Sequence<string>;
-            tags: Optional<Array<string>>;
-            useCase: Optional<string>;
-        },
-        entityId: Optional<string> = null
-    ): Promise<Sequence<DynamicStructuredTool>> {
-        const apps =  await this.client.actions.list({
-            apps: filters.apps.join(","),
-            tags: filters.tags?.join(","),
-            showAll: true,
-            filterImportantActions: !filters.tags && !filters.useCase,
-            useCase: filters.useCase || undefined
-         });
-        return apps.items!.map(tool =>
-            this._wrap_tool(
-                tool,
-                entityId || this.entityId
-            )
-        );
-    }
+    return new DynamicStructuredTool({
+      name: action,
+      description,
+      schema: parameters,
+      func: func,
+    });
+  }
+
+  async getTools(
+    filters: z.infer<typeof ZToolSchemaFilter> = {},
+    entityId: Optional<string> = null
+  ): Promise<Sequence<DynamicStructuredTool>> {
+    TELEMETRY_LOGGER.manualTelemetry(TELEMETRY_EVENTS.SDK_METHOD_INVOKED, {
+      method: "getTools",
+      file: this.fileName,
+      params: { filters, entityId },
+    });
+
+    const tools = await this.getToolsSchema(
+      filters,
+      entityId,
+      filters.integrationId
+    );
+    return tools.map((tool) =>
+      this._wrapTool(tool as RawActionData, entityId || this.entityId)
+    );
+  }
 }
```
