@composio/experimental 0.1.0 → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Sampark Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,190 +1,20 @@
 # `@composio/experimental`
 
-Experimental Composio integrations and helpers.
+Experimental additions to the Composio TypeScript SDK. Features ship here before they are ready for [`@composio/core`](../core), so APIs can change or be removed between releases.
 
-This package currently includes a Pi provider for [`@earendil-works/pi-coding-agent`](https://www.npmjs.com/package/@earendil-works/pi-coding-agent). It lets Composio tools be passed to Pi SDK sessions as `customTools` and includes a dynamic Tool Router session toolset modeled after the Slack bot integration in `~/composio/slack-bot`.
-
-## Install
+## Installation
 
 ```bash
-pnpm add @composio/core @composio/experimental @earendil-works/pi-coding-agent
-```
-
-## Static tool wrapping
-
-Use this when you already know the exact Composio tools to expose to Pi.
-
-```ts
-import { Composio } from '@composio/core';
-import { PiProvider } from '@composio/experimental';
-import { createAgentSession, SessionManager } from '@earendil-works/pi-coding-agent';
-
-const provider = new PiProvider();
-const composio = new Composio({
-  apiKey: process.env.COMPOSIO_API_KEY,
-  provider,
-});
-
-const tools = await composio.tools.get('default', {
-  tools: ['GITHUB_CREATE_ISSUE'],
-});
-
-const { session } = await createAgentSession({
-  cwd: process.cwd(),
-  sessionManager: SessionManager.inMemory(process.cwd()),
-  customTools: tools,
-  tools: ['read', 'bash', ...tools.map(tool => tool.name)],
-});
-
-await session.prompt('Create a GitHub issue for the failing test.');
+npm install @composio/core @composio/experimental
 ```
 
-## Dynamic session helpers
-
-Use this when Pi should search and execute tools dynamically inside one Tool Router session. Prefer the capability form so your app owns connection management and uses one Pi-style `hooks` object for interception/result transforms.
-
-```ts
-import { Composio } from '@composio/core';
-import { PiProvider, createPiComposioSystemPrompt } from '@composio/experimental';
-import {
-  createAgentSession,
-  DefaultResourceLoader,
-  getAgentDir,
-  SessionManager,
-} from '@earendil-works/pi-coding-agent';
-
-const provider = new PiProvider();
-const composio = new Composio({ apiKey: process.env.COMPOSIO_API_KEY });
-
-const composioSession = await composio.sessions.create('slack:T123:U456', {
-  toolkits: ['github', 'gmail'],
-  manageConnections: true,
-  workbench: { enable: true },
-});
-
-const composioTools = provider.createSessionTools({
-  sessionId: composioSession.sessionId,
-  search: composioSession.search.bind(composioSession),
-  execute: composioSession.execute.bind(composioSession),
-  callbackUrl: 'https://your-app.example.com/auth/callback',
-  includeWorkbenchTools: true,
-  connections: {
-    getToolkitStates: toolkits => composioSession.toolkits({ toolkits }),
-    authorizeToolkit: (toolkit, options) => composioSession.authorize(toolkit, options),
-    isConnected: state => state.connection?.isActive === true,
-  },
-  hooks: {
-    search: (ctx, next) => {
-      ctx.request.toolkits = ctx.request.toolkits?.map(toolkit =>
-        toolkit === 'slack' ? 'slackbot' : toolkit
-      );
-      return next();
-    },
-    execute: (ctx, next) => {
-      if (ctx.request.toolSlug === 'COMPOSIO_MANAGE_CONNECTIONS') {
-        return ctx.deny('Meta tools are blocked.');
-      }
-      return next();
-    },
-    remoteWorkbench: async (ctx, next) => {
-      const result = await next();
-      await auditWorkbenchRun({ code: ctx.request.code_to_execute, result });
-      return result;
-    },
-    remoteBash: async (ctx, next) => {
-      if (ctx.request.command.includes('rm -rf')) {
-        return ctx.deny('Destructive bash commands are blocked.');
-      }
-      return next();
-    },
-    onAuthLink: async (ctx, next) => {
-      // DM the user, store the continuation, or redact public output.
-      await sendConnectionLinkToUser({ url: ctx.url, toolkit: ctx.toolkit });
-      return { message: 'Connection link sent out-of-band.' };
-      // To also send the original result/link to the model, use: return next();
-    },
-  },
-  transformResult: async ({ value }) => value,
-});
-
-const loader = new DefaultResourceLoader({
-  cwd: process.cwd(),
-  agentDir: getAgentDir(),
-  systemPromptOverride: () =>
-    createPiComposioSystemPrompt(composioSession.sessionId, { includeWorkbenchTools: true }),
-});
-await loader.reload();
-
-const { session } = await createAgentSession({
-  cwd: process.cwd(),
-  resourceLoader: loader,
-  sessionManager: SessionManager.inMemory(process.cwd()),
-  customTools: composioTools,
-  tools: [
-    'read',
-    'bash',
-    'composio_search_tools',
-    'composio_manage_connections',
-    'composio_execute_tool',
-    'composio_remote_workbench',
-    'composio_remote_bash',
-  ],
-});
+## What's inside
 
-await session.prompt('Find my recent GitHub issues and summarize the blockers.');
-```
-
-`composio_manage_connections` uses your `connections.getToolkitStates()` and `connections.authorizeToolkit()` handlers. It does **not** call `session.execute('COMPOSIO_MANAGE_CONNECTIONS', ...)` internally.
-
-The dynamic helpers are:
-
-- `composio_search_tools` — search Tool Router for exact tool slugs and schemas.
-- `composio_manage_connections` — check/initiate user app connections.
-- `composio_execute_tool` — execute exact Composio tool slugs in the session.
-- `composio_remote_workbench` — execute Python in the Composio remote workbench for large outputs, remote files, and session-authenticated scripting.
-- `composio_remote_bash` — run short bash commands in the Composio remote workbench filesystem.
-
-Workbench helpers are opt-in because the Tool Router session must be created with workbench enabled.
-
-## Hooks
-
-`hooks` follows Pi's extension-event style with middleware semantics. Each hook receives a mutable `ctx.request`, `ctx.deny('reason')`, and a typed `next()` function. Calling `await next()` runs the default Composio behavior and returns the result before anything is sent back to the model. Return that result to pass it through, return a replacement value to control what the model sees, or skip `next()` entirely to divert/deny the operation.
-
-Available hooks:
-
-- `search(ctx, next)` — rewrite query/toolkit filters, log search results, or return custom search output.
-- `manageConnections(ctx, next)` — rewrite requested toolkits, force reauth, log connection state, or return custom connection output.
-- `execute(ctx, next)` — block/rewrite tools, route to another session/execute handler, call `ctx.manageConnections(...)`, log outputs, or return a file/workbench reference instead of inline data.
-- `remoteWorkbench(ctx, next)` — rewrite Python code/session metadata, audit workbench runs, or replace large outputs with file/workbench references. Calls through the generic `execute` hook when `next()` is used.
-- `remoteBash(ctx, next)` — rewrite/block shell commands, enforce safety policy, audit filesystem access, or replace output. Calls through the generic `execute` hook when `next()` is used.
-- `onAuthLink(ctx, next)` — send/redact/resume auth links out-of-band. `return next()` keeps the original model-visible result; returning another value replaces it.
-
-## Auth link handling
-
-Embedded agents often need to keep Composio connection URLs out of the public transcript. Use `hooks.onAuthLink()` to choose whether the model sees the original result or a redacted replacement:
-
-```ts
-const tools = provider.createSessionTools({
-  search: composioSession.search.bind(composioSession),
-  execute: composioSession.execute.bind(composioSession),
-  connections: {
-    getToolkitStates: toolkits => composioSession.toolkits({ toolkits }),
-    authorizeToolkit: (toolkit, options) => composioSession.authorize(toolkit, options),
-  },
-  hooks: {
-    onAuthLink: async (ctx, next) => {
-      await sendConnectionLinkToUser({ url: ctx.url, toolkit: ctx.toolkit });
-
-      if (shouldAlsoShowLinkToModel(ctx)) {
-        return next();
-      }
-
-      return { message: 'Connection link sent out-of-band.' };
-    },
-  },
-});
-```
+- `PiProvider` (root export): adapts Composio tools for [`@earendil-works/pi-coding-agent`](https://www.npmjs.com/package/@earendil-works/pi-coding-agent), including dynamic session helpers that let Pi search, connect, and execute tools at runtime. See the [Pi provider docs](https://docs.composio.dev/docs/providers/pi) for the full guide.
+- `EveProvider` (from `@composio/experimental/eve`): adapts Composio tools for the [eve](https://github.com/vercel/eve) agent framework, with hook-based interception and per-tool approval helpers.
+- `experimental_createLocalWorkbenchSession` (from `@composio/experimental/workbench`): run a session's sandbox on your local machine instead of the hosted workbench.
 
-## Status
+## Links
 
-Experimental. The dynamic helper names and session helper API may change.
+- Pi provider docs: https://docs.composio.dev/docs/providers/pi
+- Composio docs: https://docs.composio.dev

package/dist/auth-links-BsKdD1dc.mjs

@@ -0,0 +1,67 @@
+import { configure } from "safe-stable-stringify";
+
+//#region src/auth-links.ts
+const HTTPS_PREFIX = "https://";
+const CONNECT_LINK_PREFIX = "https://connect.composio.dev/";
+const COMPOSIO_MARKER = "composio";
+const LINK_PATH_MARKER = "/link/";
+const URL_BOUNDARIES = /* @__PURE__ */ new Set([
+	"<",
+	">",
+	")",
+	"\"",
+	"'"
+]);
+const TRAILING_PUNCTUATION = /* @__PURE__ */ new Set([
+	".",
+	",",
+	";",
+	":",
+	"!",
+	"?"
+]);
+const stringify = configure({ deterministic: false });
+const stringifyUnknown = (value) => {
+	if (typeof value === "string") return value;
+	try {
+		const serialized = stringify(value);
+		if (serialized === void 0) return "";
+		return serialized;
+	} catch {
+		return "";
+	}
+};
+const isUrlBoundary = (character) => URL_BOUNDARIES.has(character) || character.trim().length === 0;
+const trimTrailingPunctuation = (url) => {
+	let end = url.length;
+	while (end > 0 && TRAILING_PUNCTUATION.has(url[end - 1])) end -= 1;
+	return url.slice(0, end);
+};
+const classifyToken = (token, connectLinks, genericLinks) => {
+	const normalizedToken = token.toLowerCase();
+	const httpsStart = normalizedToken.indexOf(HTTPS_PREFIX);
+	if (httpsStart === -1) return;
+	const connectStart = normalizedToken.indexOf(CONNECT_LINK_PREFIX, httpsStart);
+	if (connectStart !== -1 && connectStart + 29 < token.length) connectLinks.add(trimTrailingPunctuation(token.slice(connectStart)));
+	const composioStart = normalizedToken.indexOf(COMPOSIO_MARKER, httpsStart + 8);
+	if (composioStart === -1) return;
+	const linkPathStart = normalizedToken.indexOf(LINK_PATH_MARKER, composioStart + 8);
+	if (linkPathStart === -1 || linkPathStart + 6 >= token.length) return;
+	genericLinks.add(trimTrailingPunctuation(token.slice(httpsStart)));
+};
+const extractComposioConnectLinks = (value) => {
+	const text = stringifyUnknown(value);
+	const connectLinks = /* @__PURE__ */ new Set();
+	const genericLinks = /* @__PURE__ */ new Set();
+	let tokenStart = 0;
+	for (let index = 0; index <= text.length; index += 1) {
+		const character = text[index];
+		if (character !== void 0 && !isUrlBoundary(character)) continue;
+		if (index > tokenStart) classifyToken(text.slice(tokenStart, index), connectLinks, genericLinks);
+		tokenStart = index + 1;
+	}
+	return Array.from(/* @__PURE__ */ new Set([...connectLinks, ...genericLinks]));
+};
+
+//#endregion
+export { extractComposioConnectLinks as t };

package/dist/eve/index.d.mts

@@ -0,0 +1,67 @@
+import { BaseAgenticProvider, ExecuteToolFn, McpServerGetResponse, McpUrlResponse, Tool, ToolExecuteResponse } from "@composio/core";
+import { DynamicResolveContext, NeedsApprovalContext, ToolContext, ToolDefinition } from "eve/tools";
+
+//#region src/eve/hooks.d.ts
+type MaybePromise<T> = T | Promise<T>;
+type Next = () => Promise<ToolExecuteResponse>;
+interface EveHookControls {
+  deny(reason: string): ToolExecuteResponse;
+}
+interface EveHookContext extends EveHookControls {
+  request: {
+    slug: string;
+    args: Record<string, unknown>;
+  };
+  readonly context: {
+    readonly slug: string;
+    readonly eve: ToolContext;
+  };
+}
+interface EveAuthLinkContext extends EveHookControls {
+  readonly url: string;
+  readonly result: ToolExecuteResponse;
+  readonly context: {
+    readonly slug: string;
+    readonly eve: ToolContext;
+  };
+}
+type EveHook = (ctx: EveHookContext, next: Next) => MaybePromise<ToolExecuteResponse | void>;
+type EveAuthLinkHook = (ctx: EveAuthLinkContext, next: Next) => MaybePromise<ToolExecuteResponse | void>;
+interface EveProviderHooks {
+  search?: EveHook;
+  manageConnections?: EveHook;
+  execute?: EveHook;
+  remoteWorkbench?: EveHook;
+  remoteBash?: EveHook;
+  onAuthLink?: EveAuthLinkHook;
+}
+declare const denyEveToolCall: (reason: string) => ToolExecuteResponse;
+//#endregion
+//#region src/eve/provider.d.ts
+type EveTool = ToolDefinition<Record<string, unknown>, ToolExecuteResponse>;
+type EveToolCollection = Record<string, EveTool>;
+type EveNeedsApproval = (tool: Tool, context: NeedsApprovalContext<Record<string, unknown>>) => boolean;
+/** Require approval for direct calls and matching entries inside a multi-execute call. */
+declare const requireApprovalForTools: (...toolSlugs: string[]) => EveNeedsApproval;
+interface EveProviderOptions {
+  strict?: boolean;
+  hooks?: EveProviderHooks;
+  needsApproval?: EveNeedsApproval;
+}
+declare class EveProvider extends BaseAgenticProvider<EveToolCollection, EveTool, McpServerGetResponse> {
+  private readonly options;
+  readonly name = "eve";
+  constructor(options?: EveProviderOptions);
+  wrapTool(tool: Tool, executeTool: ExecuteToolFn): EveTool;
+  wrapTools(tools: Tool[], executeTool: ExecuteToolFn): EveToolCollection;
+  wrapMcpServerResponse(data: McpUrlResponse): McpServerGetResponse;
+}
+//#endregion
+//#region src/eve/resolver.d.ts
+type EveSession = {
+  tools: () => Promise<EveToolCollection>;
+};
+type EveSessionSource<S extends EveSession> = S | Promise<S> | ((context: DynamicResolveContext) => S | Promise<S>);
+declare function defineComposioTools<S extends EveSession>(source: EveSessionSource<S>): import("eve/tools").DynamicSentinel;
+//#endregion
+export { type EveAuthLinkContext, type EveAuthLinkHook, type EveHook, type EveHookContext, type EveHookControls, type EveNeedsApproval, EveProvider, type EveProviderHooks, type EveProviderOptions, type EveTool, type EveToolCollection, defineComposioTools, denyEveToolCall, requireApprovalForTools };

package/dist/eve/index.mjs

@@ -0,0 +1,157 @@
+import { t as extractComposioConnectLinks } from "../auth-links-BsKdD1dc.mjs";
+import { BaseAgenticProvider, normalizeToolArguments, removeNonRequiredProperties } from "@composio/core";
+import { defineDynamic, defineTool } from "eve/tools";
+
+//#region src/eve/hooks.ts
+const denyEveToolCall = (reason) => ({
+	data: {},
+	error: reason,
+	successful: false
+});
+const HOOK_BY_SLUG = {
+	COMPOSIO_SEARCH_TOOLS: "search",
+	COMPOSIO_MANAGE_CONNECTIONS: "manageConnections",
+	COMPOSIO_MULTI_EXECUTE_TOOL: "execute",
+	COMPOSIO_EXECUTE_TOOL: "execute",
+	COMPOSIO_REMOTE_WORKBENCH: "remoteWorkbench",
+	COMPOSIO_REMOTE_BASH_TOOL: "remoteBash"
+};
+const hookForSlug = (hooks, slug) => {
+	const hookName = HOOK_BY_SLUG[slug];
+	if (!hookName) return void 0;
+	return hooks[hookName];
+};
+const extractAuthLinks = (result) => {
+	const links = new Set(extractComposioConnectLinks(result.data));
+	for (const link of extractComposioConnectLinks(result.error)) links.add(link);
+	return Array.from(links);
+};
+const runHook = async (hook, ctx, getDefault) => {
+	if (!hook) return getDefault();
+	let pending;
+	const next = () => {
+		if (!pending) pending = getDefault();
+		return pending;
+	};
+	const hookResult = await hook(ctx, next);
+	if (hookResult !== void 0 && hookResult !== null) return hookResult;
+	if (pending) return pending;
+	return next();
+};
+async function applyHooks(hooks, slug, args, executeTool, eveContext) {
+	const context = {
+		slug,
+		eve: eveContext
+	};
+	const ctx = {
+		request: {
+			slug,
+			args
+		},
+		context,
+		deny: denyEveToolCall
+	};
+	const hook = hookForSlug(hooks, slug);
+	const result = await runHook(hook, ctx, () => executeTool(ctx.request.slug, ctx.request.args));
+	const { onAuthLink } = hooks;
+	if (!onAuthLink) return result;
+	let current = result;
+	for (const url of extractAuthLinks(result)) {
+		const previous = current;
+		current = await runHook(onAuthLink, {
+			url,
+			result: previous,
+			context,
+			deny: denyEveToolCall
+		}, async () => previous);
+	}
+	return current;
+}
+
+//#endregion
+//#region src/eve/provider.ts
+const MULTI_EXECUTE_TOOL_SLUG = "COMPOSIO_MULTI_EXECUTE_TOOL";
+const toEveInputSchema = (tool, strict) => {
+	const params = tool.inputParameters;
+	if (!params) return {
+		type: "object",
+		properties: {}
+	};
+	if (!strict || params.type !== "object") return params;
+	return removeNonRequiredProperties({
+		...params,
+		properties: { ...params.properties }
+	});
+};
+const toEveApprovalPolicy = (tool, approvalPolicy) => {
+	if (!approvalPolicy) return void 0;
+	return (context) => approvalPolicy(tool, context);
+};
+const isProtectedToolItem = (item, protectedSlugs) => {
+	if (typeof item !== "object" || item === null) return false;
+	const toolSlug = item.tool_slug;
+	if (typeof toolSlug !== "string") return false;
+	return protectedSlugs.has(toolSlug.toUpperCase());
+};
+/** Require approval for direct calls and matching entries inside a multi-execute call. */
+const requireApprovalForTools = (...toolSlugs) => {
+	const protectedSlugs = new Set(toolSlugs.map((slug) => slug.toUpperCase()));
+	return (tool, context) => {
+		const normalizedToolSlug = tool.slug.toUpperCase();
+		if (protectedSlugs.has(normalizedToolSlug)) return true;
+		if (normalizedToolSlug !== MULTI_EXECUTE_TOOL_SLUG) return false;
+		const requestedTools = context.toolInput?.tools;
+		if (!Array.isArray(requestedTools)) return false;
+		return requestedTools.some((item) => isProtectedToolItem(item, protectedSlugs));
+	};
+};
+var EveProvider = class extends BaseAgenticProvider {
+	options;
+	name = "eve";
+	constructor(options = {}) {
+		super();
+		this.options = options;
+	}
+	wrapTool(tool, executeTool) {
+		const inputSchema = toEveInputSchema(tool, this.options.strict);
+		const needsApproval = toEveApprovalPolicy(tool, this.options.needsApproval);
+		return defineTool({
+			description: tool.description ?? tool.name,
+			inputSchema,
+			needsApproval,
+			execute: (input, context) => applyHooks(this.options.hooks ?? {}, tool.slug, normalizeToolArguments(input, tool.slug), executeTool, context)
+		});
+	}
+	wrapTools(tools, executeTool) {
+		return Object.fromEntries(tools.map((tool) => [tool.slug, this.wrapTool(tool, executeTool)]));
+	}
+	wrapMcpServerResponse(data) {
+		return data.map((item) => ({
+			url: new URL(item.url),
+			name: item.name
+		}));
+	}
+};
+
+//#endregion
+//#region src/eve/resolver.ts
+function defineComposioTools(source) {
+	const cache = /* @__PURE__ */ new WeakMap();
+	const resolveTools = async (context) => {
+		const session = await (typeof source === "function" ? source(context) : source);
+		const cached = cache.get(session);
+		if (cached) return cached;
+		const pending = session.tools();
+		cache.set(session, pending);
+		try {
+			return await pending;
+		} catch (error) {
+			if (cache.get(session) === pending) cache.delete(session);
+			throw error;
+		}
+	};
+	return defineDynamic({ events: { "step.started": (_event, context) => resolveTools(context) } });
+}
+
+//#endregion
+export { EveProvider, defineComposioTools, denyEveToolCall, requireApprovalForTools };

package/dist/index.d.mts

@@ -228,7 +228,7 @@ type PiConnectionManagementResult<TState = unknown, TAuthorizeResult = unknown>
   error: null;
 };
 //#endregion
-//#region src/pi/auth-links.d.ts
+//#region src/auth-links.d.ts
 declare const extractComposioConnectLinks: (value: unknown) => string[];
 //#endregion
 //#region src/pi/provider.d.ts

package/dist/index.mjs

@@ -1,3 +1,4 @@
+import { t as extractComposioConnectLinks } from "./auth-links-BsKdD1dc.mjs";
 import { BaseAgenticProvider, normalizeToolArguments } from "@composio/core";
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
@@ -60,20 +61,6 @@ const toPiErrorResult = (error, formatter, details = {}) => {
 
 //#endregion
 //#region src/pi/auth-links.ts
-const extractComposioConnectLinks = (value) => {
-	const text = stringifyUnknown(value);
-	const connectLinks = text.match(/https:\/\/connect\.composio\.dev\/[^\s<>)"']+/gi) ?? [];
-	const genericLinks = text.match(/https:\/\/[^\s<>)"']*composio[^\s<>)"']*\/link\/[^\s<>)"']+/gi) ?? [];
-	return [...new Set([...connectLinks, ...genericLinks].map((url) => url.replace(/[.,;:!?]+$/g, "")))];
-};
-const stringifyUnknown = (value) => {
-	if (typeof value === "string") return value;
-	try {
-		return JSON.stringify(value);
-	} catch {
-		return String(value);
-	}
-};
 const applyAuthLinkHandlers = async (capabilities, value, context) => {
 	const links = extractComposioConnectLinks(value);
 	const run = async (index, currentValue) => {
@@ -535,15 +522,16 @@ const createPiSessionTools = (input, providerOptions, options = {}) => {
 					};
 					const authLinks = [];
 					const details = {};
+					const value = await runHook(capabilities.hooks?.remoteWorkbench, hookContext, async () => {
+						const executed = await executeWithPolicy(toolCallId, names.remoteWorkbench, params, "COMPOSIO_REMOTE_WORKBENCH", hookContext.request);
+						authLinks.push(...executed.authLinks);
+						details.denied = executed.denied;
+						hookContext.context = executed.context;
+						return executed.value;
+					});
 					return toPiResult(await maybeTransform(capabilities, {
 						tool: "remoteWorkbench",
-						value: await runHook(capabilities.hooks?.remoteWorkbench, hookContext, async () => {
-							const executed = await executeWithPolicy(toolCallId, names.remoteWorkbench, params, "COMPOSIO_REMOTE_WORKBENCH", hookContext.request);
-							authLinks.push(...executed.authLinks);
-							details.denied = executed.denied;
-							hookContext.context = executed.context;
-							return executed.value;
-						}),
+						value,
 						context: hookContext.context
 					}), formatter, {
 						slug: hookContext.context.toolSlug,
@@ -584,15 +572,16 @@ const createPiSessionTools = (input, providerOptions, options = {}) => {
 					};
 					const authLinks = [];
 					const details = {};
+					const value = await runHook(capabilities.hooks?.remoteBash, hookContext, async () => {
+						const executed = await executeWithPolicy(toolCallId, names.remoteBash, params, "COMPOSIO_REMOTE_BASH_TOOL", hookContext.request);
+						authLinks.push(...executed.authLinks);
+						details.denied = executed.denied;
+						hookContext.context = executed.context;
+						return executed.value;
+					});
 					return toPiResult(await maybeTransform(capabilities, {
 						tool: "remoteBash",
-						value: await runHook(capabilities.hooks?.remoteBash, hookContext, async () => {
-							const executed = await executeWithPolicy(toolCallId, names.remoteBash, params, "COMPOSIO_REMOTE_BASH_TOOL", hookContext.request);
-							authLinks.push(...executed.authLinks);
-							details.denied = executed.denied;
-							hookContext.context = executed.context;
-							return executed.value;
-						}),
+						value,
 						context: hookContext.context
 					}), formatter, {
 						slug: hookContext.context.toolSlug,

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@composio/experimental",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Experimental Composio integrations and helpers",
-  "main": "src/index.ts",
+  "main": "dist/index.mjs",
   "type": "module",
   "repository": {
     "type": "git",
@@ -12,11 +12,9 @@
   "bugs": {
     "url": "https://github.com/ComposioHQ/composio/issues"
   },
-  "homepage": "https://github.com/ComposioHQ/composio/tree/main/ts/packages/experimental#readme",
+  "homepage": "https://github.com/ComposioHQ/composio/tree/next/ts/packages/experimental#readme",
   "publishConfig": {
-    "access": "public",
-    "main": "dist/index.mjs",
-    "types": "dist/index.d.mts"
+    "access": "public"
   },
   "exports": {
     ".": {
@@ -30,43 +28,60 @@
     "./workbench": {
       "types": "./dist/workbench/index.d.mts",
       "default": "./dist/workbench/index.mjs"
+    },
+    "./eve": {
+      "types": "./dist/eve/index.d.mts",
+      "default": "./dist/eve/index.mjs"
     }
   },
   "files": [
     "README.md",
     "dist"
   ],
-  "scripts": {
-    "clean": "git clean -xdf node_modules",
-    "build:python-helpers": "tsx scripts/build-python-helpers.ts",
-    "check:python-helpers": "tsx scripts/build-python-helpers.ts && git diff --exit-code -- src/workbench/python-helpers.generated.ts",
-    "build": "pnpm run build:python-helpers && pnpm exec tsdown",
-    "test": "vitest run",
-    "typecheck": "tsc --noEmit -p tsconfig.json"
-  },
   "keywords": [
     "composio",
     "experimental",
     "pi",
     "coding-agent",
+    "eve",
     "tools",
     "agent"
   ],
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "typebox": "1.1.38"
+    "safe-stable-stringify": "^2.5.0",
+    "typebox": "1.3.3"
   },
   "peerDependencies": {
     "@composio/core": ">=0.10.0 <1.0.0",
-    "@earendil-works/pi-coding-agent": ">=0.79.0 <1.0.0"
+    "@earendil-works/pi-coding-agent": ">=0.79.0 <1.0.0",
+    "eve": ">=0.12.0 <1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-coding-agent": {
+      "optional": true
+    },
+    "eve": {
+      "optional": true
+    }
   },
   "devDependencies": {
-    "@composio/core": "workspace:*",
-    "@earendil-works/pi-coding-agent": "0.79.8",
-    "tsdown": "catalog:",
-    "tsx": "catalog:",
-    "typescript": "catalog:",
-    "vitest": "catalog:"
-  }
-}
+    "@earendil-works/pi-coding-agent": "^0.80.3",
+    "eve": "^0.12.0",
+    "tsdown": "^0.22.3",
+    "tsx": "^4.23.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.10",
+    "@composio/core": "0.14.0"
+  },
+  "scripts": {
+    "clean": "git clean -xdf node_modules",
+    "build:python-helpers": "tsx scripts/build-python-helpers.ts",
+    "check:python-helpers": "tsx scripts/build-python-helpers.ts && git diff --exit-code -- src/workbench/python-helpers.generated.ts",
+    "build": "pnpm run build:python-helpers && pnpm exec tsdown",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "types": "dist/index.d.mts"
+}

package/src/index.ts

@@ -1,10 +0,0 @@
-/**
- * Experimental Composio integrations and helpers.
- *
- * Currently includes the experimental Pi provider for
- * @earendil-works/pi-coding-agent.
- *
- * @packageDocumentation
- * @module experimental
- */
-export * from './pi/index';