@customclaw/composio 0.0.6 → 0.0.8

package/dist/config.d.ts

@@ -9,6 +9,15 @@ export declare const ComposioConfigSchema: z.ZodObject<{
     defaultUserId: z.ZodOptional<z.ZodString>;
     allowedToolkits: z.ZodOptional<z.ZodArray<z.ZodString>>;
     blockedToolkits: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    readOnlyMode: z.ZodDefault<z.ZodBoolean>;
+    sessionTags: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        readOnlyHint: "readOnlyHint";
+        destructiveHint: "destructiveHint";
+        idempotentHint: "idempotentHint";
+        openWorldHint: "openWorldHint";
+    }>>>;
+    allowedToolSlugs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    blockedToolSlugs: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 /**
  * Parse and validate plugin config with environment fallbacks
@@ -41,6 +50,26 @@ export declare const composioConfigUiHints: {
         help: string;
         advanced: boolean;
     };
+    readOnlyMode: {
+        label: string;
+        help: string;
+        advanced: boolean;
+    };
+    sessionTags: {
+        label: string;
+        help: string;
+        advanced: boolean;
+    };
+    allowedToolSlugs: {
+        label: string;
+        help: string;
+        advanced: boolean;
+    };
+    blockedToolSlugs: {
+        label: string;
+        help: string;
+        advanced: boolean;
+    };
 };
 /**
  * Plugin config schema object for openclaw
@@ -71,5 +100,25 @@ export declare const composioPluginConfigSchema: {
             help: string;
             advanced: boolean;
         };
+        readOnlyMode: {
+            label: string;
+            help: string;
+            advanced: boolean;
+        };
+        sessionTags: {
+            label: string;
+            help: string;
+            advanced: boolean;
+        };
+        allowedToolSlugs: {
+            label: string;
+            help: string;
+            advanced: boolean;
+        };
+        blockedToolSlugs: {
+            label: string;
+            help: string;
+            advanced: boolean;
+        };
     };
 };

package/dist/config.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { LEGACY_ENTRY_FLAT_CONFIG_KEYS, LEGACY_SHAPE_ERROR, SESSION_TAGS, isRecord, normalizeSessionTags, normalizeToolkitList, normalizeToolSlugList, } from "./utils.js";
 /**
  * Zod schema for Composio plugin configuration
  */
@@ -8,23 +9,39 @@ export const ComposioConfigSchema = z.object({
     defaultUserId: z.string().optional(),
     allowedToolkits: z.array(z.string()).optional(),
     blockedToolkits: z.array(z.string()).optional(),
+    readOnlyMode: z.boolean().default(false),
+    sessionTags: z.array(z.enum(SESSION_TAGS)).optional(),
+    allowedToolSlugs: z.array(z.string()).optional(),
+    blockedToolSlugs: z.array(z.string()).optional(),
 });
 /**
  * Parse and validate plugin config with environment fallbacks
  */
 export function parseComposioConfig(value) {
-    const raw = value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : {};
-    // Allow API key from config.apiKey, top-level apiKey, or environment
-    const configObj = raw.config;
-    const apiKey = (typeof configObj?.apiKey === "string" && configObj.apiKey.trim()) ||
-        (typeof raw.apiKey === "string" && raw.apiKey.trim()) ||
+    const raw = isRecord(value) ? value : {};
+    const configObj = isRecord(raw.config) ? raw.config : undefined;
+    if (configObj) {
+        const hasLegacyFlatKeys = LEGACY_ENTRY_FLAT_CONFIG_KEYS.some((key) => key in raw);
+        if (hasLegacyFlatKeys) {
+            throw new Error(LEGACY_SHAPE_ERROR);
+        }
+    }
+    const source = configObj ?? raw;
+    const enabled = typeof raw.enabled === "boolean" ? raw.enabled : true;
+    const readOnlyMode = typeof source.readOnlyMode === "boolean" ? source.readOnlyMode : false;
+    const apiKey = (typeof source.apiKey === "string" && source.apiKey.trim()) ||
         process.env.COMPOSIO_API_KEY ||
         "";
     return ComposioConfigSchema.parse({
-        ...raw,
+        enabled,
         apiKey,
+        defaultUserId: typeof source.defaultUserId === "string" ? source.defaultUserId : undefined,
+        allowedToolkits: normalizeToolkitList(Array.isArray(source.allowedToolkits) ? source.allowedToolkits : undefined),
+        blockedToolkits: normalizeToolkitList(Array.isArray(source.blockedToolkits) ? source.blockedToolkits : undefined),
+        readOnlyMode,
+        sessionTags: normalizeSessionTags(Array.isArray(source.sessionTags) ? source.sessionTags : undefined),
+        allowedToolSlugs: normalizeToolSlugList(Array.isArray(source.allowedToolSlugs) ? source.allowedToolSlugs : undefined),
+        blockedToolSlugs: normalizeToolSlugList(Array.isArray(source.blockedToolSlugs) ? source.blockedToolSlugs : undefined),
     });
 }
 /**
@@ -54,6 +71,26 @@ export const composioConfigUiHints = {
         help: "Block specific toolkits from being used",
         advanced: true,
     },
+    readOnlyMode: {
+        label: "Read-Only Mode",
+        help: "Block likely-destructive tool actions by token matching; allow specific slugs with allowedToolSlugs if needed",
+        advanced: true,
+    },
+    sessionTags: {
+        label: "Session Tags",
+        help: "Composio Tool Router behavior tags (e.g., readOnlyHint, destructiveHint)",
+        advanced: true,
+    },
+    allowedToolSlugs: {
+        label: "Allowed Tool Slugs",
+        help: "Optional explicit allowlist for tool slugs (UPPERCASE)",
+        advanced: true,
+    },
+    blockedToolSlugs: {
+        label: "Blocked Tool Slugs",
+        help: "Explicit denylist for tool slugs (UPPERCASE)",
+        advanced: true,
+    },
 };
 /**
  * Plugin config schema object for openclaw

package/dist/index.d.ts

@@ -49,6 +49,26 @@ declare const composioPlugin: {
                 help: string;
                 advanced: boolean;
             };
+            readOnlyMode: {
+                label: string;
+                help: string;
+                advanced: boolean;
+            };
+            sessionTags: {
+                label: string;
+                help: string;
+                advanced: boolean;
+            };
+            allowedToolSlugs: {
+                label: string;
+                help: string;
+                advanced: boolean;
+            };
+            blockedToolSlugs: {
+                label: string;
+                help: string;
+                advanced: boolean;
+            };
         };
     };
     register(api: any): void;

package/dist/index.js

@@ -4,6 +4,7 @@ import { createComposioSearchTool } from "./tools/search.js";
 import { createComposioExecuteTool } from "./tools/execute.js";
 import { createComposioConnectionsTool } from "./tools/connections.js";
 import { registerComposioCli } from "./cli.js";
+import { LEGACY_SHAPE_ERROR, hasLegacyFlatEntryConfig } from "./utils.js";
 /**
  * Composio Tool Router Plugin for OpenClaw
  *
@@ -31,7 +32,27 @@ const composioPlugin = {
         "Search, authenticate, and execute tools for Gmail, Slack, GitHub, Notion, and more.",
     configSchema: composioPluginConfigSchema,
     register(api) {
+        if (hasLegacyFlatEntryConfig(api?.config)) {
+            throw new Error(LEGACY_SHAPE_ERROR);
+        }
         const config = parseComposioConfig(api.pluginConfig);
+        let client = null;
+        const ensureClient = () => {
+            if (!config.apiKey) {
+                throw new Error("Composio API key required. Run 'openclaw composio setup' or set COMPOSIO_API_KEY.");
+            }
+            if (!client) {
+                client = createComposioClient(config);
+            }
+            return client;
+        };
+        // Register CLI commands even without API key so setup/status tooling remains available.
+        api.registerCli(({ program }) => registerComposioCli({
+            program,
+            getClient: config.apiKey ? ensureClient : undefined,
+            config,
+            logger: api.logger,
+        }), { commands: ["composio"] });
         if (!config.enabled) {
             api.logger.debug("[composio] Plugin disabled in config");
             return;
@@ -40,13 +61,6 @@ const composioPlugin = {
             api.logger.warn("[composio] No API key configured. Set COMPOSIO_API_KEY env var or plugins.composio.apiKey in config.");
             return;
         }
-        let client = null;
-        const ensureClient = () => {
-            if (!client) {
-                client = createComposioClient(config);
-            }
-            return client;
-        };
         // Register tools (lazily create client on first use)
         api.registerTool({
             ...createComposioSearchTool(ensureClient(), config),
@@ -66,13 +80,6 @@ const composioPlugin = {
                 return createComposioConnectionsTool(ensureClient(), config).execute(toolCallId, params);
             },
         });
-        // Register CLI commands
-        api.registerCli(({ program }) => registerComposioCli({
-            program,
-            client: ensureClient(),
-            config,
-            logger: api.logger,
-        }), { commands: ["composio"] });
         api.logger.info("[composio] Plugin registered with 3 tools and CLI commands");
     },
 };

package/dist/tools/connections.d.ts

@@ -4,10 +4,11 @@ import type { ComposioConfig } from "../types.js";
  * Tool parameters for composio_manage_connections
  */
 export declare const ComposioManageConnectionsToolSchema: import("@sinclair/typebox").TObject<{
-    action: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"status">, import("@sinclair/typebox").TLiteral<"create">, import("@sinclair/typebox").TLiteral<"list">]>;
+    action: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"status">, import("@sinclair/typebox").TLiteral<"create">, import("@sinclair/typebox").TLiteral<"list">, import("@sinclair/typebox").TLiteral<"accounts">]>;
     toolkit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     toolkits: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
     user_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    statuses: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
 }>;
 /**
  * Create the composio_manage_connections tool
@@ -17,10 +18,11 @@ export declare function createComposioConnectionsTool(client: ComposioClient, _c
     label: string;
     description: string;
     parameters: import("@sinclair/typebox").TObject<{
-        action: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"status">, import("@sinclair/typebox").TLiteral<"create">, import("@sinclair/typebox").TLiteral<"list">]>;
+        action: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"status">, import("@sinclair/typebox").TLiteral<"create">, import("@sinclair/typebox").TLiteral<"list">, import("@sinclair/typebox").TLiteral<"accounts">]>;
         toolkit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
         toolkits: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
         user_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        statuses: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
     }>;
     execute(_toolCallId: string, params: Record<string, unknown>): Promise<{
         content: {
@@ -32,6 +34,22 @@ export declare function createComposioConnectionsTool(client: ComposioClient, _c
             count: number;
             toolkits: string[];
         };
+    } | {
+        content: {
+            type: string;
+            text: string;
+        }[];
+        details: {
+            action: string;
+            count: number;
+            accounts: {
+                id: string;
+                toolkit: string;
+                user_id: string | undefined;
+                status: string | undefined;
+                auth_config_id: string | undefined;
+            }[];
+        };
     } | {
         content: {
             type: string;

package/dist/tools/connections.js

@@ -1,16 +1,10 @@
 import { Type } from "@sinclair/typebox";
-const CONNECTION_PROBES = {
-    affinity: {
-        toolSlug: "AFFINITY_GET_METADATA_ON_ALL_LISTS",
-        args: { limit: 1 },
-    },
-};
 /**
  * Tool parameters for composio_manage_connections
  */
 export const ComposioManageConnectionsToolSchema = Type.Object({
-    action: Type.Union([Type.Literal("status"), Type.Literal("create"), Type.Literal("list")], {
-        description: "Action to perform: 'status' to check connections, 'create' to initiate auth, 'list' to list toolkits",
+    action: Type.Union([Type.Literal("status"), Type.Literal("create"), Type.Literal("list"), Type.Literal("accounts")], {
+        description: "Action to perform: 'status' to check connections, 'create' to initiate auth, 'list' to list toolkits, 'accounts' to inspect connected accounts",
     }),
     toolkit: Type.Optional(Type.String({
         description: "Toolkit name for 'status' or 'create' actions (e.g., 'github', 'gmail')",
@@ -21,6 +15,9 @@ export const ComposioManageConnectionsToolSchema = Type.Object({
     user_id: Type.Optional(Type.String({
         description: "User ID for session scoping (uses default if not provided)",
     })),
+    statuses: Type.Optional(Type.Array(Type.String(), {
+        description: "Optional connection statuses filter for 'accounts' (e.g., ['ACTIVE'])",
+    })),
 });
 /**
  * Create the composio_manage_connections tool
@@ -30,7 +27,8 @@ export function createComposioConnectionsTool(client, _config) {
         name: "composio_manage_connections",
         label: "Composio Manage Connections",
         description: "Manage Composio toolkit connections. Use action='status' to check if a toolkit is connected, " +
-            "action='create' to generate an auth URL when disconnected, or action='list' to see available toolkits. " +
+            "action='create' to generate an auth URL when disconnected, action='list' to see available toolkits, " +
+            "or action='accounts' to inspect connected accounts across user IDs. " +
             "Check connection status before executing tools with composio_execute_tool.",
         parameters: ComposioManageConnectionsToolSchema,
         async execute(_toolCallId, params) {
@@ -50,6 +48,38 @@ export function createComposioConnectionsTool(client, _config) {
                             details: response,
                         };
                     }
+                    case "accounts": {
+                        let toolkits;
+                        if (typeof params.toolkit === "string" && params.toolkit.trim()) {
+                            toolkits = [params.toolkit.trim()];
+                        }
+                        else if (Array.isArray(params.toolkits)) {
+                            toolkits = params.toolkits.filter((t) => typeof t === "string" && t.trim() !== "");
+                        }
+                        const statuses = Array.isArray(params.statuses)
+                            ? params.statuses.filter((s) => typeof s === "string" && s.trim() !== "")
+                            : ["ACTIVE"];
+                        const accounts = await client.listConnectedAccounts({
+                            toolkits,
+                            userIds: userId ? [userId] : undefined,
+                            statuses,
+                        });
+                        const response = {
+                            action: "accounts",
+                            count: accounts.length,
+                            accounts: accounts.map((a) => ({
+                                id: a.id,
+                                toolkit: a.toolkit,
+                                user_id: a.userId,
+                                status: a.status,
+                                auth_config_id: a.authConfigId,
+                            })),
+                        };
+                        return {
+                            content: [{ type: "text", text: JSON.stringify(response, null, 2) }],
+                            details: response,
+                        };
+                    }
                     case "create": {
                         const toolkit = String(params.toolkit || "").trim();
                         if (!toolkit) {
@@ -89,25 +119,6 @@ export function createComposioConnectionsTool(client, _config) {
                             toolkitsToCheck = params.toolkits.filter((t) => typeof t === "string" && t.trim() !== "");
                         }
                         const statuses = await client.getConnectionStatus(toolkitsToCheck, userId);
-                        // Fallback probe for API-key style integrations where
-                        // connection.isActive can be false despite successful tool execution
-                        if (toolkitsToCheck && toolkitsToCheck.length > 0) {
-                            for (const status of statuses) {
-                                if (status.connected)
-                                    continue;
-                                const probe = CONNECTION_PROBES[String(status.toolkit || "").toLowerCase()];
-                                if (!probe)
-                                    continue;
-                                try {
-                                    const probeResult = await client.executeTool(probe.toolSlug, probe.args, userId);
-                                    if (probeResult?.success)
-                                        status.connected = true;
-                                }
-                                catch {
-                                    // keep false if probe fails
-                                }
-                            }
-                        }
                         const response = {
                             action: "status",
                             count: statuses.length,

package/dist/tools/execute.d.ts

@@ -7,6 +7,7 @@ export declare const ComposioExecuteToolSchema: import("@sinclair/typebox").TObj
     tool_slug: import("@sinclair/typebox").TString;
     arguments: import("@sinclair/typebox").TUnknown;
     user_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    connected_account_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
 }>;
 /**
  * Create the composio_execute_tool tool
@@ -19,6 +20,7 @@ export declare function createComposioExecuteTool(client: ComposioClient, _confi
         tool_slug: import("@sinclair/typebox").TString;
         arguments: import("@sinclair/typebox").TUnknown;
         user_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        connected_account_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     }>;
     execute(_toolCallId: string, params: Record<string, unknown>): Promise<{
         content: {

package/dist/tools/execute.js

@@ -12,6 +12,9 @@ export const ComposioExecuteToolSchema = Type.Object({
     user_id: Type.Optional(Type.String({
         description: "User ID for session scoping (uses default if not provided)",
     })),
+    connected_account_id: Type.Optional(Type.String({
+        description: "Optional connected account ID to pin execution to a specific account when multiple are connected",
+    })),
 });
 /**
  * Create the composio_execute_tool tool
@@ -43,8 +46,9 @@ export function createComposioExecuteTool(client, _config) {
                 ? rawArgs
                 : {};
             const userId = typeof params.user_id === "string" ? params.user_id : undefined;
+            const connectedAccountId = typeof params.connected_account_id === "string" ? params.connected_account_id : undefined;
             try {
-                const result = await client.executeTool(toolSlug, args, userId);
+                const result = await client.executeTool(toolSlug, args, userId, connectedAccountId);
                 const response = {
                     tool_slug: toolSlug,
                     success: result.success,

package/dist/types.d.ts

@@ -1,12 +1,17 @@
 /**
  * Composio Tool Router types for OpenClaw integration
  */
+export type ComposioSessionTag = "readOnlyHint" | "destructiveHint" | "idempotentHint" | "openWorldHint";
 export interface ComposioConfig {
     enabled: boolean;
     apiKey?: string;
     defaultUserId?: string;
     allowedToolkits?: string[];
     blockedToolkits?: string[];
+    readOnlyMode?: boolean;
+    sessionTags?: ComposioSessionTag[];
+    allowedToolSlugs?: string[];
+    blockedToolSlugs?: string[];
 }
 export interface ToolSearchResult {
     name: string;
@@ -26,3 +31,13 @@ export interface ConnectionStatus {
     userId?: string;
     authUrl?: string;
 }
+export interface ConnectedAccountSummary {
+    id: string;
+    toolkit: string;
+    userId?: string;
+    status?: string;
+    authConfigId?: string;
+    isDisabled?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+}

package/dist/utils.d.ts

@@ -0,0 +1,12 @@
+import type { ComposioSessionTag } from "./types.js";
+export declare const SESSION_TAGS: readonly ["readOnlyHint", "destructiveHint", "idempotentHint", "openWorldHint"];
+export declare const LEGACY_ENTRY_FLAT_CONFIG_KEYS: readonly ["apiKey", "defaultUserId", "allowedToolkits", "blockedToolkits", "readOnlyMode", "sessionTags", "allowedToolSlugs", "blockedToolSlugs"];
+export declare const LEGACY_SHAPE_ERROR = "Legacy Composio config shape detected. Run 'openclaw composio setup'.";
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function normalizeToolkitSlug(value: unknown): string;
+export declare function normalizeToolSlug(value: unknown): string;
+export declare function normalizeToolkitList(values?: readonly unknown[]): string[] | undefined;
+export declare function normalizeToolSlugList(values?: readonly unknown[]): string[] | undefined;
+export declare function normalizeSessionTags(values?: readonly unknown[]): ComposioSessionTag[] | undefined;
+export declare function hasLegacyFlatEntryConfig(config: unknown): boolean;
+export declare function stripLegacyFlatConfigKeys(entry: Record<string, unknown>): Record<string, unknown>;

package/dist/utils.js

@@ -0,0 +1,76 @@
+export const SESSION_TAGS = [
+    "readOnlyHint",
+    "destructiveHint",
+    "idempotentHint",
+    "openWorldHint",
+];
+export const LEGACY_ENTRY_FLAT_CONFIG_KEYS = [
+    "apiKey",
+    "defaultUserId",
+    "allowedToolkits",
+    "blockedToolkits",
+    "readOnlyMode",
+    "sessionTags",
+    "allowedToolSlugs",
+    "blockedToolSlugs",
+];
+export const LEGACY_SHAPE_ERROR = "Legacy Composio config shape detected. Run 'openclaw composio setup'.";
+const SESSION_TAG_SET = new Set(SESSION_TAGS);
+export function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+export function normalizeToolkitSlug(value) {
+    return String(value ?? "").trim().toLowerCase();
+}
+export function normalizeToolSlug(value) {
+    return String(value ?? "").trim().toUpperCase();
+}
+export function normalizeToolkitList(values) {
+    if (!values || values.length === 0)
+        return undefined;
+    const normalized = values
+        .filter((item) => typeof item === "string")
+        .map((item) => normalizeToolkitSlug(item))
+        .filter(Boolean);
+    if (normalized.length === 0)
+        return undefined;
+    return Array.from(new Set(normalized));
+}
+export function normalizeToolSlugList(values) {
+    if (!values || values.length === 0)
+        return undefined;
+    const normalized = values
+        .filter((item) => typeof item === "string")
+        .map((item) => normalizeToolSlug(item))
+        .filter(Boolean);
+    if (normalized.length === 0)
+        return undefined;
+    return Array.from(new Set(normalized));
+}
+export function normalizeSessionTags(values) {
+    if (!values || values.length === 0)
+        return undefined;
+    const normalized = values
+        .filter((item) => typeof item === "string")
+        .map((item) => item.trim())
+        .filter((item) => SESSION_TAG_SET.has(item));
+    if (normalized.length === 0)
+        return undefined;
+    return Array.from(new Set(normalized));
+}
+export function hasLegacyFlatEntryConfig(config) {
+    const root = isRecord(config) ? config : undefined;
+    const plugins = isRecord(root?.plugins) ? root.plugins : undefined;
+    const entries = isRecord(plugins?.entries) ? plugins.entries : undefined;
+    const composioEntry = isRecord(entries?.composio) ? entries.composio : undefined;
+    if (!composioEntry)
+        return false;
+    return LEGACY_ENTRY_FLAT_CONFIG_KEYS.some((key) => key in composioEntry);
+}
+export function stripLegacyFlatConfigKeys(entry) {
+    const sanitized = { ...entry };
+    for (const key of LEGACY_ENTRY_FLAT_CONFIG_KEYS) {
+        delete sanitized[key];
+    }
+    return sanitized;
+}

package/openclaw.plugin.json

@@ -27,6 +27,25 @@
         "type": "array",
         "items": { "type": "string" },
         "description": "Block specific toolkits"
+      },
+      "readOnlyMode": {
+        "type": "boolean",
+        "description": "Block likely destructive tool actions by default"
+      },
+      "sessionTags": {
+        "type": "array",
+        "items": { "type": "string", "enum": ["readOnlyHint", "destructiveHint", "idempotentHint", "openWorldHint"] },
+        "description": "Optional Tool Router behavior tags"
+      },
+      "allowedToolSlugs": {
+        "type": "array",
+        "items": { "type": "string" },
+        "description": "Optional explicit allowlist for tool slugs (UPPERCASE)"
+      },
+      "blockedToolSlugs": {
+        "type": "array",
+        "items": { "type": "string" },
+        "description": "Explicit denylist for tool slugs (UPPERCASE)"
       }
     }
   },
@@ -53,6 +72,26 @@
       "label": "Blocked Toolkits",
       "help": "Block specific toolkits from being used",
       "advanced": true
+    },
+    "readOnlyMode": {
+      "label": "Read-Only Mode",
+      "help": "Block likely-destructive tool actions by default",
+      "advanced": true
+    },
+    "sessionTags": {
+      "label": "Session Tags",
+      "help": "Tool Router behavior tags (e.g., readOnlyHint, destructiveHint)",
+      "advanced": true
+    },
+    "allowedToolSlugs": {
+      "label": "Allowed Tool Slugs",
+      "help": "Optional explicit allowlist for tool slugs (UPPERCASE)",
+      "advanced": true
+    },
+    "blockedToolSlugs": {
+      "label": "Blocked Tool Slugs",
+      "help": "Explicit denylist for tool slugs (UPPERCASE)",
+      "advanced": true
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@customclaw/composio",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "type": "module",
   "description": "Composio Tool Router plugin for OpenClaw — access 1000+ third-party integrations",
   "main": "dist/index.js",
@@ -11,8 +11,9 @@
     ]
   },
   "scripts": {
-    "build": "tsc",
+    "build": "rm -rf dist && tsc",
     "test": "vitest run",
+    "test:live": "vitest run src/live.integration.test.ts",
     "prepublishOnly": "npm run build"
   },
   "files": [

package/dist/client.test.d.ts

@@ -1 +0,0 @@
-export {};