@frockbot/plugin-composio 0.3.2 → 0.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/plugin-composio",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "private": false,
   "type": "module",
   "exports": {
@@ -22,11 +22,11 @@
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
-    "@frockbot/configuration-core": "0.3.2",
-    "@frockbot/connection-core": "0.3.2",
-    "@frockbot/kernel-contracts": "0.3.2",
-    "@frockbot/plugin-settings": "0.3.2",
-    "@frockbot/plugin-tools": "0.3.2",
+    "@frockbot/configuration-core": "0.3.4",
+    "@frockbot/connection-core": "0.3.4",
+    "@frockbot/kernel-contracts": "0.3.4",
+    "@frockbot/plugin-settings": "0.3.4",
+    "@frockbot/plugin-tools": "0.3.4",
     "cordis": "4.0.0-rc.8"
   },
   "devDependencies": {

package/src/agent.test.ts

@@ -2,10 +2,32 @@ import { afterEach, describe, expect, test } from "bun:test";
 import { type SessionEvent, SessionStore } from "@frockbot/kernel-contracts";
 import { ToolRegistry } from "@frockbot/plugin-tools";
 import { Context } from "cordis";
-import { createComposioRouterPlugin } from "./agent.js";
+import {
+  composioNamespaceV1,
+  createComposioPlugin,
+  createComposioRouterPlugin,
+} from "./agent.js";
 import { ComposioClient } from "./composio-client.js";
 
 const roots: Context[] = [];
+const namespace = composioNamespaceV1("gmail", "ca_123");
+
+function dynamicCall(
+  id: string,
+  toolName: string,
+  arguments_: Record<string, unknown>,
+) {
+  return {
+    id,
+    name: "call_dynamic_tool",
+    input: {
+      namespace,
+      toolName,
+      arguments: arguments_,
+      mcpDetails: { description: `Use ${toolName} for this test.` },
+    },
+  };
+}
 
 afterEach(async () => {
   await Promise.all(roots.splice(0).map((root) => root.fiber.dispose()));
@@ -65,11 +87,10 @@ describe("Composio router Plugin", () => {
     };
 
     const invented = await root.tools.prepare(
-      {
-        id: "invented",
-        name: "composio_execute_tool",
-        input: { toolSlug: "GMAIL_FETCH_EMAILS", arguments: {} },
-      },
+      dynamicCall("invented", "composio_execute_tool", {
+        toolSlug: "GMAIL_FETCH_EMAILS",
+        arguments: {},
+      }),
       context,
     );
     if (invented.kind !== "ready") throw new Error("execute tool was denied");
@@ -79,11 +100,9 @@ describe("Composio router Plugin", () => {
     expect(calls).toEqual([]);
 
     const search = await root.tools.prepare(
-      {
-        id: "search",
-        name: "composio_search_tools",
-        input: { query: "fetch emails" },
-      },
+      dynamicCall("search", "composio_search_tools", {
+        query: "fetch emails",
+      }),
       context,
     );
     if (search.kind !== "ready") throw new Error("search tool was denied");
@@ -92,11 +111,10 @@ describe("Composio router Plugin", () => {
     });
 
     const exact = await root.tools.prepare(
-      {
-        id: "exact",
-        name: "composio_execute_tool",
-        input: { toolSlug: "GMAIL_FETCH_EMAILS", arguments: {} },
-      },
+      dynamicCall("exact", "composio_execute_tool", {
+        toolSlug: "GMAIL_FETCH_EMAILS",
+        arguments: {},
+      }),
       context,
     );
     if (exact.kind !== "ready") throw new Error("execute tool was denied");
@@ -104,7 +122,7 @@ describe("Composio router Plugin", () => {
       isError: false,
     });
     expect(calls).toHaveLength(2);
-    expect(authorizationCalls).toBe(2);
+    expect(authorizationCalls).toBe(3);
   });
 
   test("restores searched slug authorization from the durable session", async () => {
@@ -123,8 +141,12 @@ describe("Composio router Plugin", () => {
         toolCalls: [
           {
             id: "search-before-eviction",
-            name: "composio_search_tools",
-            input: {},
+            name: "call_dynamic_tool",
+            input: dynamicCall(
+              "search-before-eviction",
+              "composio_search_tools",
+              {},
+            ).input,
           },
         ],
       },
@@ -133,15 +155,19 @@ describe("Composio router Plugin", () => {
         turn: 1,
         step: 1,
         occurrenceId: "tool:1:1:0",
-        name: "composio_search_tools",
-        input: {},
+        name: "call_dynamic_tool",
+        input: dynamicCall(
+          "search-before-eviction",
+          "composio_search_tools",
+          {},
+        ).input,
       },
       {
         type: "tool/result",
         turn: 1,
         step: 1,
         occurrenceId: "tool:1:1:0",
-        name: "composio_search_tools",
+        name: "call_dynamic_tool",
         content: JSON.stringify([
           {
             slug: "GMAIL_FETCH_EMAILS",
@@ -190,11 +216,10 @@ describe("Composio router Plugin", () => {
       signal: new AbortController().signal,
     };
     const execution = await root.tools.prepare(
-      {
-        id: "execute-after-eviction",
-        name: "composio_execute_tool",
-        input: { toolSlug: "GMAIL_FETCH_EMAILS", arguments: {} },
-      },
+      dynamicCall("execute-after-eviction", "composio_execute_tool", {
+        toolSlug: "GMAIL_FETCH_EMAILS",
+        arguments: {},
+      }),
       context,
     );
     if (execution.kind !== "ready") throw new Error("execute tool was denied");
@@ -204,4 +229,60 @@ describe("Composio router Plugin", () => {
     ).resolves.toMatchObject({ isError: false });
     expect(calls).toHaveLength(1);
   });
+
+  test("derives a stable GrokBot-style namespace from toolkit and account", () => {
+    expect(composioNamespaceV1("github", "acct_acme-42")).toBe(
+      "user-Github--acct-acme-42",
+    );
+  });
+
+  test("registers static per-tool integrations under the account namespace", async () => {
+    const root = new Context();
+    roots.push(root);
+    await root.plugin(ToolRegistry);
+    await root.plugin(
+      createComposioPlugin({
+        client: new ComposioClient({ apiKey: "secret" }),
+        userId: "user-1",
+        toolkitSlug: "github",
+        connectedAccountId: "acct_acme-42",
+        tools: [
+          {
+            slug: "GITHUB_SEARCH_ISSUES",
+            name: "search_issues",
+            description: "Search issues.",
+            inputSchema: { type: "object" },
+          },
+        ],
+      }),
+    );
+
+    expect(root.tools.registeredNames?.()).toContain(
+      "user-Github--acct-acme-42/search_issues",
+    );
+    const call = {
+      id: "static",
+      name: "call_dynamic_tool",
+      input: {
+        namespace: "user-Github--acct-acme-42",
+        toolName: "search_issues",
+      },
+    };
+    const preparation = await root.tools.prepare(call, {
+      botId: "primary",
+      agentId: "primary",
+      compositionGenerationId: "bootstrap",
+      turnType: "chat",
+      sessionId: "user-1:primary",
+      effectId: "tool:1:1:0",
+      signal: new AbortController().signal,
+    });
+    expect(preparation).toMatchObject({
+      kind: "denied",
+      result: {
+        content:
+          'External namespace "user-Github--acct-acme-42" requires mcpDetails.description',
+      },
+    });
+  });
 });

package/src/agent.ts

@@ -14,6 +14,7 @@ export interface ComposioPluginConfig {
   client: ComposioClient;
   userId: string;
   connectedAccountId: string;
+  toolkitSlug: string;
   tools: ComposioToolDeclaration[];
 }
 
@@ -21,6 +22,28 @@ function isObject(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+function slugSegment(value: string): string {
+  return value
+    .trim()
+    .replace(/[^A-Za-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+/** The stable, account-specific namespace exposed to the model. */
+export function composioNamespaceV1(
+  toolkitSlug: string,
+  connectedAccountId: string,
+): string {
+  const toolkit = slugSegment(toolkitSlug);
+  const account = slugSegment(connectedAccountId);
+  if (!toolkit || !account) {
+    throw new Error("Composio toolkit and connected account must be slug-like");
+  }
+  const displayToolkit =
+    toolkit.charAt(0).toUpperCase() + toolkit.slice(1).toLowerCase();
+  return `user-${displayToolkit}--${account}`;
+}
+
 export interface ComposioRouterPluginConfig {
   client: ComposioClient;
   userId: string;
@@ -75,6 +98,7 @@ export function createComposioRouterPlugin(
 ): Plugin.Function {
   const allowedToolSlugs = new Set<string>();
   let runtimeContext: Context | undefined;
+  let runtimeNamespace: string | undefined;
   const search: ToolDefinition = {
     name: "composio_search_tools",
     // A general work tool: the full toolset an `executor` subagent gets, and
@@ -130,29 +154,37 @@ export function createComposioRouterPlugin(
       ) {
         return { content: "Invalid Composio tool input", isError: true };
       }
-      const wasDurablySearched = runtimeContext?.sessions
-        .get(context.sessionId)
-        ?.events.some((event) => {
-          if (
-            event.type !== "tool/result" ||
-            event.name !== "composio_search_tools" ||
-            event.isError
-          ) {
-            return false;
-          }
-          try {
-            const result: unknown = JSON.parse(event.content);
-            return (
-              Array.isArray(result) &&
-              result.some(
-                (candidate) =>
-                  isObject(candidate) && candidate.slug === input.toolSlug,
-              )
-            );
-          } catch {
-            return false;
-          }
-        });
+      const events = runtimeContext?.sessions.get(context.sessionId)?.events;
+      const wasDurablySearched = events?.some((event) => {
+        if (event.type !== "tool/result" || event.isError) {
+          return false;
+        }
+        const isSearchResult =
+          event.name === "composio_search_tools" ||
+          (event.name === "call_dynamic_tool" &&
+            events?.some(
+              (candidate) =>
+                candidate.type === "tool/call" &&
+                candidate.occurrenceId === event.occurrenceId &&
+                candidate.name === "call_dynamic_tool" &&
+                isObject(candidate.input) &&
+                candidate.input.namespace === runtimeNamespace &&
+                candidate.input.toolName === "composio_search_tools",
+            ));
+        if (!isSearchResult) return false;
+        try {
+          const result: unknown = JSON.parse(event.content);
+          return (
+            Array.isArray(result) &&
+            result.some(
+              (candidate) =>
+                isObject(candidate) && candidate.slug === input.toolSlug,
+            )
+          );
+        } catch {
+          return false;
+        }
+      });
       if (!allowedToolSlugs.has(input.toolSlug) && !wasDurablySearched) {
         return {
           content:
@@ -176,14 +208,35 @@ export function createComposioRouterPlugin(
       return { content: JSON.stringify(result), isError: false };
     },
   };
-  const plugin: Plugin.Function = (ctx: Context) => {
+  const plugin: Plugin.Function = async (ctx: Context) => {
+    const grant = await config.authorizeEffect();
+    if (grant.toolkitSlug !== config.toolkitSlug) {
+      throw new Error("Composio effect grant changed toolkit");
+    }
+    runtimeNamespace = composioNamespaceV1(
+      grant.toolkitSlug,
+      grant.connectedAccountId,
+    );
     runtimeContext = ctx;
-    const removeSearch = ctx.tools.register(search);
-    const removeExecute = ctx.tools.register(execute);
+    const removeNamespace = ctx.tools.registerNamespace({
+      name: runtimeNamespace,
+      external: true,
+      status: "ready",
+    });
+    const removeSearch = ctx.tools.register({
+      ...search,
+      namespace: runtimeNamespace,
+    });
+    const removeExecute = ctx.tools.register({
+      ...execute,
+      namespace: runtimeNamespace,
+    });
     return () => {
       runtimeContext = undefined;
+      runtimeNamespace = undefined;
       removeExecute();
       removeSearch();
+      removeNamespace();
     };
   };
   plugin.inject = ["tools", "sessions"];
@@ -194,9 +247,19 @@ export function createComposioPlugin(
   config: ComposioPluginConfig,
 ): Plugin.Function {
   const plugin: Plugin.Function = (ctx: Context) => {
+    const namespace = composioNamespaceV1(
+      config.toolkitSlug,
+      config.connectedAccountId,
+    );
+    const removeNamespace = ctx.tools.registerNamespace({
+      name: namespace,
+      external: true,
+      status: "ready",
+    });
     const disposers = config.tools.map((declaration) => {
       const tool: ToolDefinition = {
         name: declaration.name,
+        namespace,
         description: declaration.description,
         inputSchema: declaration.inputSchema,
         validate: isObject,
@@ -218,6 +281,7 @@ export function createComposioPlugin(
     });
     return () => {
       for (const dispose of disposers.toReversed()) dispose();
+      removeNamespace();
     };
   };
   plugin.inject = ["tools"];