@composio/experimental 0.2.3-beta.0 → 0.2.3-beta.1

package/dist/eve/index.d.mts

@@ -1,5 +1,6 @@
 import { BaseAgenticProvider, ExecuteToolFn, McpServerGetResponse, McpUrlResponse, Tool, ToolExecuteResponse } from "@composio/core";
-import { ApprovalContext, DynamicResolveContext, ToolContext, ToolDefinition } from "eve/tools";
+import { DynamicResolveContext, ToolContext, ToolDefinition } from "eve/tools";
+import { ApprovalContext } from "eve/tools/approval";
 //#region src/eve/hooks.d.ts
 type MaybePromise<T> = T | Promise<T>;
 type Next = () => Promise<ToolExecuteResponse>;
@@ -34,26 +35,27 @@ interface EveProviderHooks {
   remoteBash?: EveHook;
   onAuthLink?: EveAuthLinkHook;
 }
-declare const denyEveToolCall: (reason: string) => ToolExecuteResponse;
+export 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: ApprovalContext<Record<string, unknown>>) => boolean;
 /** Require approval for direct calls and matching entries inside a multi-execute call. */
-declare const requireApprovalForTools: (...toolSlugs: string[]) => EveNeedsApproval;
+export declare const requireApprovalForTools: (...toolSlugs: string[]) => EveNeedsApproval;
 interface EveProviderOptions {
   strict?: boolean;
   hooks?: EveProviderHooks;
   needsApproval?: EveNeedsApproval;
 }
-declare class EveProvider extends BaseAgenticProvider<EveToolCollection, EveTool, McpServerGetResponse> {
+export 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;
+  private defineBoundTool;
 }
 //#endregion
 //#region src/eve/resolver.d.ts
@@ -61,6 +63,6 @@ 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<EveToolCollection>;
+export declare function defineComposioTools<S extends EveSession>(source: EveSessionSource<S>): import("eve/connections").DynamicSentinel<EveToolCollection>;
 //#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 };
+export type { EveAuthLinkContext, EveAuthLinkHook, EveHook, EveHookContext, EveHookControls, EveNeedsApproval, EveProviderHooks, EveProviderOptions, EveTool, EveToolCollection };

package/dist/eve/index.mjs

@@ -2,6 +2,39 @@ 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/durable.ts
+/**
+* eve rejects a dynamic tool whose callbacks carry no durable descriptor: each
+* callback must be a JSON-serializable closure plus a function that takes that
+* closure as its first argument, so a parked or replayed call can be rebuilt
+* after the process that resolved it is gone. eve's build transform stamps the
+* descriptor onto `defineTool` calls it finds in the agent's own source, and it
+* never runs on this package inside `node_modules` — so the provider stamps its
+* own descriptors here.
+*
+* The descriptor key is a global-registry symbol, the same identity eve's
+* runtime reads, so no eve internal has to be imported.
+*/
+const DURABLE_CALLBACK = Symbol.for("eve:durable-dynamic-callback");
+/**
+* Binds `callback` to `closure` and stamps eve's durable descriptor on the
+* result. eve registers the callback under the tool's name at resolve time,
+* persists only `closure`, and calls `callback(closure, ...args)` on replay;
+* direct callers get the ordinary `(...args)` signature.
+*/
+function withDurableClosure(closure, callback) {
+	const live = (...args) => callback(closure, ...args);
+	Object.defineProperty(live, DURABLE_CALLBACK, {
+		configurable: true,
+		value: {
+			callback,
+			closure
+		}
+	});
+	return live;
+}
+
+//#endregion
 //#region src/eve/hooks.ts
 const denyEveToolCall = (reason) => ({
 	data: {},
@@ -83,10 +116,6 @@ const toEveInputSchema = (tool, strict) => {
 		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;
@@ -105,6 +134,43 @@ const requireApprovalForTools = (...toolSlugs) => {
 		return requestedTools.some((item) => isProtectedToolItem(item, protectedSlugs));
 	};
 };
+/**
+* Bindings for every resolve in this process, keyed by the id stamped into the
+* closure. `executeTool` is bound to one Composio session, so a closure must
+* name the resolve that produced it rather than just the slug: sessions for
+* different users share one provider and would otherwise cross-execute. The
+* map is module-level because eve's callback registry is keyed by tool name
+* only, so a second `EveProvider` in the process replays through the same
+* callbacks. Entries live as long as the process; eve can resume a parked
+* call at any time. Ids carry a per-process token so a closure persisted by
+* an earlier process fails the lookup instead of matching whichever resolve
+* reused its counter value.
+*/
+const bindings = /* @__PURE__ */ new Map();
+const processToken = globalThis.crypto.randomUUID();
+let nextBindingId = 0;
+const bind = (binding) => {
+	const id = `${processToken}:${++nextBindingId}`;
+	bindings.set(id, binding);
+	return id;
+};
+const requireBinding = ({ slug, binding }) => {
+	const bound = bindings.get(binding);
+	const tool = bound?.tools.get(slug);
+	if (!bound || !tool) throw new Error(`Composio tool "${slug}" has no executor in this process. Resolve the session's tools again before calling it.`);
+	return {
+		...bound,
+		tool
+	};
+};
+const execute = async (closure, input, context) => {
+	const { executeTool, options } = requireBinding(closure);
+	return applyHooks(options.hooks ?? {}, closure.slug, normalizeToolArguments(input, closure.slug), executeTool, context);
+};
+const approve = (closure, context) => {
+	const { tool, options } = requireBinding(closure);
+	return options.needsApproval(tool, context);
+};
 var EveProvider = class extends BaseAgenticProvider {
 	options;
 	name = "eve";
@@ -113,17 +179,15 @@ var EveProvider = class extends BaseAgenticProvider {
 		this.options = options;
 	}
 	wrapTool(tool, executeTool) {
-		const inputSchema = toEveInputSchema(tool, this.options.strict);
-		const approval = toEveApprovalPolicy(tool, this.options.needsApproval);
-		return defineTool({
-			description: tool.description ?? tool.name,
-			inputSchema,
-			approval,
-			execute: (input, context) => applyHooks(this.options.hooks ?? {}, tool.slug, normalizeToolArguments(input, tool.slug), executeTool, context)
-		});
+		return this.wrapTools([tool], executeTool)[tool.slug];
 	}
 	wrapTools(tools, executeTool) {
-		return Object.fromEntries(tools.map((tool) => [tool.slug, this.wrapTool(tool, executeTool)]));
+		const binding = bind({
+			tools: new Map(tools.map((tool) => [tool.slug, tool])),
+			executeTool,
+			options: this.options
+		});
+		return Object.fromEntries(tools.map((tool) => [tool.slug, this.defineBoundTool(tool, binding)]));
 	}
 	wrapMcpServerResponse(data) {
 		return data.map((item) => ({
@@ -131,6 +195,18 @@ var EveProvider = class extends BaseAgenticProvider {
 			name: item.name
 		}));
 	}
+	defineBoundTool(tool, binding) {
+		const closure = {
+			slug: tool.slug,
+			binding
+		};
+		return defineTool({
+			description: tool.description ?? tool.name,
+			inputSchema: toEveInputSchema(tool, this.options.strict),
+			approval: this.options.needsApproval ? withDurableClosure(closure, approve) : void 0,
+			execute: withDurableClosure(closure, execute)
+		});
+	}
 };
 
 //#endregion

package/dist/index.d.mts

@@ -228,13 +228,13 @@ type PiConnectionManagementResult<TState = unknown, TAuthorizeResult = unknown>
 };
 //#endregion
 //#region src/auth-links.d.ts
-declare const extractComposioConnectLinks: (value: unknown) => string[];
+export declare const extractComposioConnectLinks: (value: unknown) => string[];
 //#endregion
 //#region src/pi/provider.d.ts
 /**
  * Provider for integrating Composio tools with Pi SDK custom tools.
  */
-declare class PiProvider extends BaseAgenticProvider<PiToolCollection, PiTool, McpServerGetResponse> {
+export declare class PiProvider extends BaseAgenticProvider<PiToolCollection, PiTool, McpServerGetResponse> {
   private readonly options;
   readonly name = "pi";
   constructor(options?: PiProviderOptions);
@@ -255,11 +255,11 @@ declare class PiProvider extends BaseAgenticProvider<PiToolCollection, PiTool, M
 }
 //#endregion
 //#region src/pi/prompt.d.ts
-declare const createPiComposioSystemPrompt: (sessionId?: string, options?: {
+export declare const createPiComposioSystemPrompt: (sessionId?: string, options?: {
   includeWorkbenchTools?: boolean;
 }) => string;
 //#endregion
 //#region src/pi/results.d.ts
-declare const denyPiToolCall: (error: string) => PiDeniedResult;
+export declare const denyPiToolCall: (error: string) => PiDeniedResult;
 //#endregion
-export { type MaybePromise, DEFAULT_SESSION_TOOL_NAMES as PI_COMPOSIO_SESSION_TOOL_NAMES, type PiAuthLinkContext, type PiAuthorizeToolkitOptions, type PiBaseToolContext, type PiComposioSessionLike, type PiConnectionHandlers, type PiConnectionManagementContext, type PiConnectionManagementResult, type PiConnectionToolkitResult, type PiDeniedResult, type PiExecutableSessionLike, type PiExecuteContext, type PiExecuteHandler, type PiExecuteHookContext, type PiHookControls, type PiHookNext, type PiManageConnectionsHookContext, PiProvider, type PiProviderOptions, type PiRemoteBashHookContext, type PiRemoteBashRequest, type PiRemoteWorkbenchHookContext, type PiRemoteWorkbenchRequest, type PiSearchContext, type PiSearchHandler, type PiSearchHookContext, type PiSessionHooks, type PiSessionToolCapabilities, type PiSessionToolName, type PiSessionToolOptions, type PiTool, type PiToolCollection, type PiToolDetails, type PiToolResultFormatter, createPiComposioSystemPrompt, denyPiToolCall, extractComposioConnectLinks };
+export { type MaybePromise, DEFAULT_SESSION_TOOL_NAMES as PI_COMPOSIO_SESSION_TOOL_NAMES, type PiAuthLinkContext, type PiAuthorizeToolkitOptions, type PiBaseToolContext, type PiComposioSessionLike, type PiConnectionHandlers, type PiConnectionManagementContext, type PiConnectionManagementResult, type PiConnectionToolkitResult, type PiDeniedResult, type PiExecutableSessionLike, type PiExecuteContext, type PiExecuteHandler, type PiExecuteHookContext, type PiHookControls, type PiHookNext, type PiManageConnectionsHookContext, type PiProviderOptions, type PiRemoteBashHookContext, type PiRemoteBashRequest, type PiRemoteWorkbenchHookContext, type PiRemoteWorkbenchRequest, type PiSearchContext, type PiSearchHandler, type PiSearchHookContext, type PiSessionHooks, type PiSessionToolCapabilities, type PiSessionToolName, type PiSessionToolOptions, type PiTool, type PiToolCollection, type PiToolDetails, type PiToolResultFormatter };

package/dist/index.mjs

@@ -255,7 +255,8 @@ const createPiSessionTools = (input, providerOptions, options = {}) => {
 				const shouldReinitiateAll = hookContext.request.reinitiateAll;
 				connectionContext.requestedToolkits = requestedToolkits;
 				connectionContext.reinitiateAll = shouldReinitiateAll;
-				const states = normalizeToolkitStateMap(await capabilities.connections?.getToolkitStates?.(requestedToolkits, connectionContext), requestedToolkits);
+				const statesRaw = await capabilities.connections?.getToolkitStates?.(requestedToolkits, connectionContext);
+				const states = normalizeToolkitStateMap(statesRaw, requestedToolkits);
 				const results = {};
 				for (const toolkit of requestedToolkits) {
 					const state = states.get(toolkit.toLowerCase());
@@ -397,12 +398,13 @@ const createPiSessionTools = (input, providerOptions, options = {}) => {
 					authLinks.push(...handledResult.authLinks);
 					return handledResult.value;
 				});
-				return toPiResult(await maybeTransform(capabilities, {
+				const transformed = await maybeTransform(capabilities, {
 					tool: "search",
 					requestedToolkits: hookContext.context.requestedToolkits,
 					value,
 					context: hookContext.context
-				}), formatter, {
+				});
+				return toPiResult(transformed, formatter, {
 					slug: names.search,
 					authLinks
 				});
@@ -427,12 +429,13 @@ const createPiSessionTools = (input, providerOptions, options = {}) => {
 			const toolkits = normalizeToolkits(params.toolkits) ?? [];
 			try {
 				const managed = await manageConnectionsForToolkits(toolCallId, params, toolkits, params.reinitiate_all ?? false);
-				return toPiResult(await maybeTransform(capabilities, {
+				const transformed = await maybeTransform(capabilities, {
 					tool: "manageConnections",
 					requestedToolkits: toolkits,
 					value: managed.value,
 					context: managed.context
-				}), formatter, {
+				});
+				return toPiResult(transformed, formatter, {
 					slug: names.manageConnections,
 					authLinks: managed.authLinks,
 					denied: managed.denied
@@ -461,12 +464,13 @@ const createPiSessionTools = (input, providerOptions, options = {}) => {
 			const args = params.arguments ?? {};
 			try {
 				const executed = await executeWithPolicy(toolCallId, names.execute, params, toolSlug, args, params.account);
-				return toPiResult(await maybeTransform(capabilities, {
+				const transformed = await maybeTransform(capabilities, {
 					tool: "execute",
 					requestedToolkits: toolkitFromToolSlug(executed.context.toolSlug) ? [toolkitFromToolSlug(executed.context.toolSlug)] : void 0,
 					value: executed.value,
 					context: executed.context
-				}), formatter, {
+				});
+				return toPiResult(transformed, formatter, {
 					slug: executed.context.toolSlug || names.execute,
 					authLinks: executed.authLinks,
 					denied: executed.denied
@@ -529,11 +533,12 @@ const createPiSessionTools = (input, providerOptions, options = {}) => {
 						hookContext.context = executed.context;
 						return executed.value;
 					});
-					return toPiResult(await maybeTransform(capabilities, {
+					const transformed = await maybeTransform(capabilities, {
 						tool: "remoteWorkbench",
 						value,
 						context: hookContext.context
-					}), formatter, {
+					});
+					return toPiResult(transformed, formatter, {
 						slug: hookContext.context.toolSlug,
 						authLinks,
 						denied: details.denied
@@ -579,11 +584,12 @@ const createPiSessionTools = (input, providerOptions, options = {}) => {
 						hookContext.context = executed.context;
 						return executed.value;
 					});
-					return toPiResult(await maybeTransform(capabilities, {
+					const transformed = await maybeTransform(capabilities, {
 						tool: "remoteBash",
 						value,
 						context: hookContext.context
-					}), formatter, {
+					});
+					return toPiResult(transformed, formatter, {
 						slug: hookContext.context.toolSlug,
 						authLinks,
 						denied: details.denied

package/dist/workbench/index.d.mts

@@ -6,7 +6,7 @@ interface LocalWorkbenchSession {
 }
 //#endregion
 //#region src/workbench/local-workbench.d.ts
-declare function experimental_createLocalWorkbenchSession(composio: Composio, session: Session<unknown, unknown, never>): Promise<LocalWorkbenchSession>;
+export declare function experimental_createLocalWorkbenchSession(composio: Composio, session: Session<unknown, unknown, never>): Promise<LocalWorkbenchSession>;
 //#endregion
 //#region src/workbench/shim.d.ts
 interface WorkbenchEnvOptions {
@@ -17,7 +17,7 @@ interface WorkbenchEnvOptions {
 interface PythonWorkbenchHelperSourceOptions {
   invokeLlmModel?: string;
 }
-declare function experimental_createWorkbenchEnv(env: WorkbenchEnvOptions): Record<string, string>;
-declare function experimental_createPythonWorkbenchHelperSource(opts?: PythonWorkbenchHelperSourceOptions): string;
+export declare function experimental_createWorkbenchEnv(env: WorkbenchEnvOptions): Record<string, string>;
+export declare function experimental_createPythonWorkbenchHelperSource(opts?: PythonWorkbenchHelperSourceOptions): string;
 //#endregion
-export { type LocalWorkbenchSession, type PythonWorkbenchHelperSourceOptions, type WorkbenchEnvOptions, experimental_createLocalWorkbenchSession, experimental_createPythonWorkbenchHelperSource, experimental_createWorkbenchEnv };
+export type { LocalWorkbenchSession, PythonWorkbenchHelperSourceOptions, WorkbenchEnvOptions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@composio/experimental",
-  "version": "0.2.3-beta.0",
+  "version": "0.2.3-beta.1",
   "description": "Experimental Composio integrations and helpers",
   "main": "dist/index.mjs",
   "type": "module",
@@ -54,7 +54,7 @@
   "license": "ISC",
   "dependencies": {
     "safe-stable-stringify": "^2.5.0",
-    "typebox": "1.3.16"
+    "typebox": "1.3.27"
   },
   "peerDependencies": {
     "@composio/core": ">=1.0.0-beta.0 <2.0.0",
@@ -70,13 +70,13 @@
     }
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.84.1",
-    "eve": "^0.31.3",
-    "tsdown": "^0.22.14",
-    "tsx": "^4.23.12",
+    "@earendil-works/pi-coding-agent": "^0.84.4",
+    "eve": "^0.52.1",
+    "tsdown": "^0.23.0",
+    "tsx": "^4.23.13",
     "typescript": "^7.0.2",
     "vitest": "^4.1.11",
-    "@composio/core": "1.0.0-beta.0"
+    "@composio/core": "1.0.0-beta.1"
   },
   "scripts": {
     "clean": "git clean -xdf node_modules",