feat: add LlamaIndex TS support to JS SDK

js/package.json

@@ -40,6 +40,7 @@
     "@langchain/openai": "^0.2.5",
     "ai": "^3.2.22",
     "langchain": "^0.2.11",
+    "llamaindex": "^0.8.31",
     "openai": "^4.50.0"
   },
   "dependencies": {

js/src/frameworks/llamaindex.spec.ts

@@ -0,0 +1,75 @@
+import { beforeAll, describe, expect, it } from "@jest/globals";
+import { z } from "zod";
+import { getTestConfig } from "../../config/getTestConfig";
+import { ActionExecuteResponse } from "../sdk/models/actions";
+import { LlamaIndexToolSet } from "./llamaindex";
+
+describe("Apps class tests", () => {
+  let llamaindexToolSet: LlamaIndexToolSet;
+  beforeAll(() => {
+    llamaindexToolSet = new LlamaIndexToolSet({
+      apiKey: getTestConfig().COMPOSIO_API_KEY,
+      baseUrl: getTestConfig().BACKEND_HERMES_URL,
+    });
+  });
+
+  it("getools", async () => {
+    const tools = await llamaindexToolSet.getTools({
+      apps: ["github"],
+    });
+    expect(tools).toBeInstanceOf(Array);
+  });
+  it("check if tools are coming", async () => {
+    const tools = await llamaindexToolSet.getTools({
+      actions: ["GITHUB_GITHUB_API_ROOT"],
+    });
+    expect(tools.length).toBe(1);
+  });
+  it("check if getTools, actions are coming", async () => {
+    const tools = await llamaindexToolSet.getTools({
+      actions: ["GITHUB_GITHUB_API_ROOT"],
+    });
+
+    expect(tools.length).toBe(1);
+  });
+  it("Should create custom action to star a repository", async () => {
+    await llamaindexToolSet.createAction({
+      actionName: "starRepositoryCustomAction",
+      toolName: "github",
+      description: "This action stars a repository",
+      inputParams: z.object({
+        owner: z.string(),
+        repo: z.string(),
+      }),
+      callback: async (
+        inputParams,
+        _authCredentials,
+        executeRequest
+      ): Promise<ActionExecuteResponse> => {
+        const res = await executeRequest({
+          endpoint: `/user/starred/${inputParams.owner}/${inputParams.repo}`,
+          method: "PUT",
+          parameters: [],
+        });
+        return res;
+      },
+    });
+
+    const tools = await llamaindexToolSet.getTools({
+      actions: ["starRepositoryCustomAction"],
+    });
+
+    await expect(tools.length).toBe(1);
+    const actionOuput = await llamaindexToolSet.executeAction({
+      action: "starRepositoryCustomAction",
+      params: {
+        owner: "composioHQ",
+        repo: "composio",
+      },
+      entityId: "default",
+      connectedAccountId: "9442cab3-d54f-4903-976c-ee67ef506c9b",
+    });
+
+    expect(actionOuput).toHaveProperty("successful", true);
+  });
+});

js/src/frameworks/llamaindex.ts

@@ -0,0 +1,91 @@
+import { FunctionTool, type JSONValue } from "llamaindex";
+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 { ZToolSchemaFilter } from "../types/base_toolset";
+import { Optional, Sequence } from "../types/util";
+
+type ToolSchema = {
+  name: string;
+  description: string;
+  parameters: Record<string, unknown>;
+};
+
+export class LlamaIndexToolSet extends BaseComposioToolSet {
+  /**
+   * Composio toolset for LlamaIndex framework.
+   *
+   */
+  static FRAMEWORK_NAME = "llamaindex";
+  static DEFAULT_ENTITY_ID = "default";
+  fileName: string = "js/src/frameworks/llamaindex.ts";
+
+  constructor(
+    config: {
+      apiKey?: Optional<string>;
+      baseUrl?: Optional<string>;
+      entityId?: string;
+      runtime?: string;
+    } = {}
+  ) {
+    super({
+      apiKey: config.apiKey || null,
+      baseUrl: config.baseUrl || COMPOSIO_BASE_URL,
+      runtime: config?.runtime || null,
+      entityId: config.entityId || LlamaIndexToolSet.DEFAULT_ENTITY_ID,
+    });
+  }
+
+  private _wrapTool(
+    schema: ToolSchema,
+    entityId: Optional<string> = null
+  ): FunctionTool<Record<string, unknown>, JSONValue | Promise<JSONValue>> {
+    return FunctionTool.from(
+      async (params: Record<string, unknown>) => {
+        const result = await this.executeAction({
+          action: schema.name,
+          params,
+          entityId: entityId || this.entityId,
+        });
+        return JSON.parse(JSON.stringify(result)) as JSONValue;
+      },
+      {
+        name: schema.name,
+        description: schema.description,
+        parameters: {
+          type: "object",
+          properties: schema.parameters.properties || {},
+          required: schema.parameters.required || [],
+        },
+      }
+    );
+  }
+
+  async getTools(
+    filters: z.infer<typeof ZToolSchemaFilter> = {},
+    entityId: Optional<string> = null
+  ): Promise<
+    Sequence<
+      FunctionTool<Record<string, unknown>, JSONValue | Promise<JSONValue>>
+    >
+  > {
+    TELEMETRY_LOGGER.manualTelemetry(TELEMETRY_EVENTS.SDK_METHOD_INVOKED, {
+      method: "getTools",
+      file: this.fileName,
+      params: { filters, entityId },
+    });
+
+    const tools = await this.getToolsSchema(filters, entityId);
+    return tools.map((tool) => {
+      const wrappedTool = this._wrapTool(tool, entityId || this.entityId);
+      Object.assign(wrappedTool, {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters,
+      });
+      return wrappedTool;
+    });
+  }
+}

js/src/index.ts

@@ -1,6 +1,7 @@
 import { CloudflareToolSet } from "./frameworks/cloudflare";
 import { LangchainToolSet } from "./frameworks/langchain";
 import { LangGraphToolSet } from "./frameworks/langgraph";
+import { LlamaIndexToolSet } from "./frameworks/llamaindex";
 import { OpenAIToolSet } from "./frameworks/openai";
 import { VercelAIToolSet } from "./frameworks/vercel";
 import { ComposioToolSet } from "./sdk/base.toolset";
@@ -26,6 +27,7 @@ export {
   ConnectionRequest,
   LangGraphToolSet,
   LangchainToolSet,
+  LlamaIndexToolSet,
   OpenAIToolSet,
   VercelAIToolSet,
 };