@devries-cameron20 / composio Mirror · read-only / commits / a4c9e0ada
Fork 0

Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.

Mirrored from https://github.com/Camo67/composio.git

Synced Nov 21, 21:00 UTC

refactor(cli): define local tools as custom toolkits (#3356)

## Summary - Stacks this local-tools PR on top of #3360, which contains the core duplicate custom-toolkit child slug fix. - Refactors `@composio/cli-local-tools` to define bundled local toolkits with core `experimental_createTool` / `experimental_createToolkit` handles instead of hand-rolled schema objects. - Keeps Tool Router v3.1 inline custom toolkit definitions attached to session create/search/execute calls so bundled local tools remain searchable/executable. - Adds CLI/local-tools test coverage for forwarding local custom toolkit payloads and for core custom toolkit handles from the local registry. ## Stack - Base PR: #3360 (`fix(core): qualify custom toolkit child slug lookups`) - This PR should now show only CLI/local-tools changes relative to #3360. ## Tests - `pnpm --filter @composio/core typecheck` - `pnpm --filter @composio/cli-local-tools typecheck` - `pnpm --filter @composio/cli typecheck` - `pnpm --filter @composio/cli-local-tools test` - `pnpm --filter @composio/cli-local-tools build` - `pnpm --filter @composio/cli exec vitest run test/src/commands/tools/tools.search.cmd.test.ts test/src/commands/tools/tools.execute.cmd.test.ts` - `pnpm --filter @composio/core exec vitest run test/models/customTool.test.ts test/models/toolRouter.test.ts test/models/customToolRouting.test.ts`

Rahul Tarak committed May 7, 2026 at 05:29 UTC a4c9e0ada2b464c9f26f0e4982e1a7d6d939e51d
11 files changed +242 -117
pnpm-lock.yaml
+3 -3
@@ -1213,6 +1213,9 @@ importers:
1213
1214 ts/packages/cli-local-tools:
1215 dependencies:
1216 + '@composio/core':
1217 + specifier: workspace:*
1218 + version: link:../core
1219 '@modelcontextprotocol/sdk':
1220 specifier: ^1.26.0
1221 version: 1.26.0(@cfworker/json-schema@4.1.1)(zod@4.3.6)
@@ -1222,9 +1225,6 @@ importers:
1225 zod:
1226 specifier: 'catalog:'
1227 version: 4.3.6
1225 - zod-to-json-schema:
1226 - specifier: 'catalog:'
1227 - version: 3.25.1(zod@4.3.6)
1228 devDependencies:
1229 '@types/decompress':
1230 specifier: ^4.2.7
ts/packages/cli-local-tools/package.json
+2 -2
@@ -44,10 +44,10 @@
44 "typecheck:tsc": "tsc --noEmit -p ./tsconfig.src.json"
45 },
46 "dependencies": {
47 + "@composio/core": "workspace:*",
48 "@modelcontextprotocol/sdk": "^1.26.0",
49 "decompress": "^4.2.1",
49 - "zod": "catalog:",
50 - "zod-to-json-schema": "catalog:"
50 + "zod": "catalog:"
51 },
52 "devDependencies": {
53 "@types/decompress": "^4.2.7",
ts/packages/cli-local-tools/src/registry.test.ts
+14
@@ -4,6 +4,7 @@ import { describe, expect, it } from 'vitest';
4 import { z } from 'zod/v3';
5 import {
6 createLocalToolRouterExperimentalPayload,
7 + getLocalCustomToolkits,
8 getLocalToolkitDeclarations,
9 getLocalToolInputDefinition,
10 localToolkitDeclarations,
@@ -81,6 +82,19 @@ describe('@composio/cli-local-tools registry', () => {
82 ).toEqual([]);
83 });
84
85 + it('builds core custom toolkit handles for supported local toolkits', () => {
86 + const [toolkit] = getLocalCustomToolkits({
87 + currentPlatform: 'linux-x64',
88 + toolkits: ['fixture_app'],
89 + declarations: [fixtureToolkit],
90 + });
91 +
92 + expect(toolkit?.slug).toBe('FIXTURE_APP');
93 + expect(toolkit?.tools[0]?.slug).toBe('RUN_COMMAND');
94 + expect(toolkit?.tools[0]?.inputSchema.properties).toHaveProperty('args');
95 + expect(typeof toolkit?.tools[0]?.execute).toBe('function');
96 + });
97 +
98 it('builds Tool Router custom toolkit payloads for supported local toolkits', () => {
99 const payload = createLocalToolRouterExperimentalPayload({
100 currentPlatform: 'darwin-arm64',
ts/packages/cli-local-tools/src/registry.ts
+37 -69
@@ -1,8 +1,11 @@
1 -import zodToJsonSchema from 'zod-to-json-schema';
1 +import {
2 + experimental_createTool as createCustomTool,
3 + experimental_createToolkit as createCustomToolkit,
4 + type CustomToolkit,
5 +} from '@composio/core/experimental';
6 import { beeperImessageToolkit } from './toolkits/beeper-imessage';
7 import { chromeDevtoolsToolkit } from './toolkits/chrome-devtools';
8 import { peekabooToolkit } from './toolkits/peekaboo';
5 -import type { z } from 'zod/v3';
9 import { formatSupportedPlatforms, detectCliPlatform, supportsCliPlatform } from './platform';
10 import { executeLocalTool } from './runtime';
11 import type {
@@ -15,28 +18,7 @@ import type {
18
19 export const LOCAL_TOOL_PREFIX = 'LOCAL_';
20
18 -interface LocalCustomTool {
19 - readonly slug: string;
20 - readonly name: string;
21 - readonly description: string;
22 - readonly inputSchema: Record<string, unknown>;
23 - readonly outputSchema?: Record<string, unknown>;
24 -}
25 -
26 -interface LocalCustomToolkit {
27 - readonly slug: string;
28 - readonly name: string;
29 - readonly description: string;
30 - readonly tools: ReadonlyArray<LocalCustomTool>;
31 -}
32 -
33 -/**
34 - * Built-in local toolkits shipped with @composio/cli-local-tools.
35 - *
36 - * The foundation package intentionally starts empty. Concrete integrations are
37 - * added in separate stack PRs so each app can be reviewed and validated on its
38 - * own.
39 - */
21 +/** Built-in local toolkits shipped with @composio/cli-local-tools. */
22 export const localToolkitDeclarations: ReadonlyArray<LocalToolkitDeclaration> = [
23 beeperImessageToolkit,
24 chromeDevtoolsToolkit,
@@ -59,48 +41,34 @@ const descriptionWithPlatform = (
41 platforms: ReadonlyArray<LocalCliPlatform>
42 ): string => `${description}\n\nLocal CLI platforms: ${formatSupportedPlatforms(platforms)}.`;
43
62 -const zodObjectToJsonSchema = (schema: z.ZodTypeAny): Record<string, unknown> => {
63 - const converted = zodToJsonSchema(schema, { name: 'input' }) as {
64 - definitions?: { input?: Record<string, unknown> };
65 - } & Record<string, unknown>;
66 - const inputDefinition = converted.definitions?.input ?? converted;
67 - return {
68 - type: 'object',
69 - properties:
70 - inputDefinition.properties && typeof inputDefinition.properties === 'object'
71 - ? (inputDefinition.properties as Record<string, unknown>)
72 - : {},
73 - ...(Array.isArray(inputDefinition.required) ? { required: inputDefinition.required } : {}),
74 - };
75 -};
76 -
77 -const zodToOutputJsonSchema = (schema: z.ZodTypeAny): Record<string, unknown> => {
78 - const converted = zodToJsonSchema(schema, { name: 'output' }) as {
79 - definitions?: { output?: Record<string, unknown> };
80 - } & Record<string, unknown>;
81 - return converted.definitions?.output ?? converted;
82 -};
83 -
44 const toCustomTool = (
45 toolkit: LocalToolkitDeclaration,
86 - tool: LocalToolDeclaration
87 -): LocalCustomTool => ({
88 - slug: tool.slug,
89 - name: tool.name,
90 - description: descriptionWithPlatform(tool.description, tool.platforms),
91 - inputSchema: zodObjectToJsonSchema(tool.inputParams as z.ZodTypeAny),
92 - ...(tool.outputParams ? { outputSchema: zodToOutputJsonSchema(tool.outputParams) } : {}),
93 -});
46 + tool: LocalToolDeclaration,
47 + currentPlatform: LocalCliPlatform
48 +) =>
49 + createCustomTool(tool.slug, {
50 + name: tool.name,
51 + description: descriptionWithPlatform(tool.description, tool.platforms),
52 + inputParams: tool.inputParams,
53 + ...(tool.outputParams ? { outputParams: tool.outputParams } : {}),
54 + execute: async input =>
55 + executeLocalTool(tool.execution, input as Record<string, unknown>, {
56 + toolkit,
57 + tool,
58 + finalSlug: normalizeLocalToolSlug(tool.slug, toolkit.slug),
59 + platform: currentPlatform,
60 + }),
61 + });
62
63 const toCustomToolkit = (
64 toolkit: LocalToolkitDeclaration,
97 - tools: ReadonlyArray<LocalCustomTool>
98 -): LocalCustomToolkit => ({
99 - slug: toolkit.slug,
100 - name: toolkit.name,
101 - description: descriptionWithPlatform(toolkit.description, toolkit.platforms),
102 - tools,
103 -});
65 + currentPlatform: LocalCliPlatform
66 +): CustomToolkit =>
67 + createCustomToolkit(toolkit.slug, {
68 + name: toolkit.name,
69 + description: descriptionWithPlatform(toolkit.description, toolkit.platforms),
70 + tools: toolkit.tools.map(tool => toCustomTool(toolkit, tool, currentPlatform)),
71 + });
72
73 const toolkitMatchesFilter = (
74 toolkit: LocalToolkitDeclaration,
@@ -167,16 +135,15 @@ export const getLocalCustomToolkits = (
135 readonly toolkits?: ReadonlyArray<string>;
136 readonly declarations?: ReadonlyArray<LocalToolkitDeclaration>;
137 } = {}
170 -): ReadonlyArray<LocalCustomToolkit> =>
171 - getLocalToolkitDeclarations(options).map(toolkit =>
172 - toCustomToolkit(
173 - toolkit,
174 - toolkit.tools.map(tool => toCustomTool(toolkit, tool))
175 - )
138 +): ReadonlyArray<CustomToolkit> => {
139 + const currentPlatform = options.currentPlatform ?? detectCliPlatform();
140 + return getLocalToolkitDeclarations({ ...options, currentPlatform }).map(toolkit =>
141 + toCustomToolkit(toolkit, currentPlatform)
142 );
143 +};
144
145 const customToolkitToPayload = (
179 - toolkit: LocalCustomToolkit
146 + toolkit: CustomToolkit
147 ): NonNullable<LocalToolRouterExperimentalPayload['custom_toolkits']>[number] => ({
148 slug: toolkit.slug,
149 name: toolkit.name,
@@ -250,7 +217,8 @@ export const getLocalToolInputDefinition = (
217 return {
218 finalSlug: resolution.finalSlug,
219 toolkit: resolution.toolkit.slug,
253 - schema: toCustomTool(resolution.toolkit, resolution.tool).inputSchema,
220 + schema: toCustomTool(resolution.toolkit, resolution.tool, resolution.currentPlatform)
221 + .inputSchema,
222 version: 'local',
223 };
224 };
ts/packages/cli-local-tools/tsdown.config.ts
+1 -1
@@ -4,5 +4,5 @@ import { baseConfig } from '../../../tsdown.config.base.ts';
4 export default defineConfig({
5 ...baseConfig,
6 tsconfig: 'tsconfig.src.json',
7 - external: [/^bun:/],
7 + external: [...baseConfig.external, /^bun:/, /^@composio\/core(\/.*)?$/],
8 });
ts/packages/cli-local-tools/vitest.config.ts
+14
@@ -1,6 +1,20 @@
1 import { defineConfig } from 'vitest/config';
2 +import path from 'node:path';
3 +
4 +const __dirname = path.resolve(path.dirname(new URL(import.meta.url).pathname));
5 +const coreDir = path.resolve(__dirname, '../core');
6
7 export default defineConfig({
8 + resolve: {
9 + alias: {
10 + '@composio/core/experimental': path.join(coreDir, 'src/experimental/index.ts'),
11 + '@composio/core': path.join(coreDir, 'src/index.ts'),
12 + '#config_defaults': path.join(coreDir, 'src/utils/config-defaults/ConfigDefaults.node.ts'),
13 + '#platform': path.join(coreDir, 'src/platform/node.ts'),
14 + '#files': path.join(coreDir, 'src/models/Files.node.ts'),
15 + '#file_tool_modifier': path.join(coreDir, 'src/utils/modifiers/FileToolModifier.node.ts'),
16 + },
17 + },
18 test: {
19 include: ['src/**/*.test.ts'],
20 exclude: ['vendor/**', 'dist/**', 'node_modules/**'],
ts/packages/cli/src/commands/tools/commands/tools.search.cmd.ts
+19 -13
@@ -354,20 +354,26 @@ const runToolsSearch = (params: {
354 consumerUserId: resolvedUserId.value,
355 });
356 }
357 - const { sessionId } = yield* resolveToolRouterSession(client, resolvedUserId.value, {
358 - toolkits: toolkitList,
359 - cacheScope:
360 - resolvedProject.projectType === 'CONSUMER' && resolvedProject.consumerUserId
361 - ? {
362 - orgId: resolvedProject.orgId,
363 - consumerUserId: resolvedProject.consumerUserId,
364 - }
365 - : undefined,
366 - });
357 + const { sessionId, localExperimentalPayload } = yield* resolveToolRouterSession(
358 + client,
359 + resolvedUserId.value,
360 + {
361 + toolkits: toolkitList,
362 + cacheScope:
363 + resolvedProject.projectType === 'CONSUMER' && resolvedProject.consumerUserId
364 + ? {
365 + orgId: resolvedProject.orgId,
366 + consumerUserId: resolvedProject.consumerUserId,
367 + }
368 + : undefined,
369 + }
370 + );
371 + const searchPayload = {
372 + queries: queries.map(query => ({ use_case: query })),
373 + ...(localExperimentalPayload ? { experimental: localExperimentalPayload } : {}),
374 + };
375 const searchResponse = yield* Effect.tryPromise(() =>
368 - client.toolRouter.session.search(sessionId, {
369 - queries: queries.map(query => ({ use_case: query })),
370 - })
376 + client.toolRouter.session.search(sessionId, searchPayload)
377 );
378 return {
379 searchResponse,
ts/packages/cli/src/effects/create-tool-router-session.ts
+28 -5
@@ -39,15 +39,21 @@ export interface CreateToolRouterSessionOptions {
39 };
40 }
41
42 +export interface CreatedToolRouterSession {
43 + readonly sessionId: string;
44 + /** Inline local-tool custom definitions that should be forwarded to v3.1 search/execute calls. */
45 + readonly localExperimentalPayload?: ReturnType<typeof createLocalToolRouterExperimentalPayload>;
46 +}
47 +
48 /**
49 * Create an ephemeral Tool Router session for the given user ID.
44 - * Returns the session ID string.
50 + * Returns the session id plus any local-tool custom payload bound to the session.
51 *
52 * Accepts a pre-resolved client instance (from ComposioClientSingleton)
53 * so callers can resolve the dependency at layer construction time.
54 * Used by `ToolsExecutorLive` which already holds the client reference.
55 */
50 -export const createToolRouterSession = (
56 +export const createToolRouterSessionContext = (
57 client: Composio,
58 userId: string,
59 options?: CreateToolRouterSessionOptions
@@ -169,9 +175,26 @@ export const createToolRouterSession = (
175 toolkits: remoteToolkits.length > 0 ? { enable: [...remoteToolkits] } : undefined,
176 experimental: localExperimentalPayload,
177 })
172 - ).pipe(Effect.map(session => session.session_id));
178 + ).pipe(
179 + Effect.map(
180 + (session): CreatedToolRouterSession => ({
181 + sessionId: session.session_id,
182 + localExperimentalPayload,
183 + })
184 + )
185 + );
186 });
187
188 +/** Backward-compatible helper for callers that only need the session id. */
189 +export const createToolRouterSession = (
190 + client: Composio,
191 + userId: string,
192 + options?: CreateToolRouterSessionOptions
193 +) =>
194 + createToolRouterSessionContext(client, userId, options).pipe(
195 + Effect.map(session => session.sessionId)
196 + );
197 +
198 /**
199 * Resolve the Composio client and create a Tool Router session in one step.
200 * Returns `{ client, sessionId }` — eliminates the 3-step boilerplate
@@ -182,6 +205,6 @@ export const resolveToolRouterSession = (
205 userId: string,
206 options?: CreateToolRouterSessionOptions
207 ) =>
185 - createToolRouterSession(client, userId, options).pipe(
186 - Effect.map(sessionId => ({ client, sessionId }))
208 + createToolRouterSessionContext(client, userId, options).pipe(
209 + Effect.map(session => ({ client, ...session }))
210 );
ts/packages/cli/src/services/tools-executor.ts
+32 -23
@@ -1,14 +1,14 @@
1 import { FileSystem } from '@effect/platform';
2 import { Context, Effect, Layer } from 'effect';
3 import type { Composio } from '@composio/client';
4 -import { executeLocalToolBySlug, isLocalToolSlug } from '@composio/cli-local-tools';
4 +import { executeLocalToolBySlug, resolveLocalTool } from '@composio/cli-local-tools';
5 import type {
6 SessionExecuteResponse,
7 SessionExecuteMetaResponse,
8 SessionExecuteMetaParams,
9 } from '@composio/client/resources/tool-router';
10 import { ComposioClientSingleton } from 'src/services/composio-clients';
11 -import { createToolRouterSession } from 'src/effects/create-tool-router-session';
11 +import { createToolRouterSessionContext } from 'src/effects/create-tool-router-session';
12 import {
13 ComposioNoActiveConnectionError,
14 mapComposioError,
@@ -142,10 +142,11 @@ export const ToolsExecutorLive = Layer.effect(
142 execute: (slug, params) =>
143 Effect.gen(function* () {
144 const cliConfig = yield* ComposioCliUserConfig;
145 - if (
146 - isLocalToolSlug(slug) &&
147 - !cliConfig.isExperimentalFeatureEnabled(CLI_EXPERIMENTAL_FEATURES.LOCAL_TOOLS)
148 - ) {
145 + const localToolResolution = resolveLocalTool(slug, { includeUnsupported: true });
146 + const localToolsEnabled = cliConfig.isExperimentalFeatureEnabled(
147 + CLI_EXPERIMENTAL_FEATURES.LOCAL_TOOLS
148 + );
149 + if (localToolResolution && !localToolsEnabled) {
150 return yield* Effect.fail(
151 new Error(
152 `Local tools are experimental. Enable them with \`composio config experimental ${CLI_EXPERIMENTAL_FEATURES.LOCAL_TOOLS} on\` before executing ${slug}.`
@@ -153,26 +154,32 @@ export const ToolsExecutorLive = Layer.effect(
154 );
155 }
156
156 - const localResult = yield* Effect.tryPromise(() =>
157 - executeLocalToolBySlug(slug, params.arguments)
158 - );
159 - if (localResult) {
160 - return {
161 - successful: true,
162 - data: localResult as Record<string, unknown>,
163 - error: null,
164 - logId: '',
165 - } satisfies ToolExecuteResponse;
157 + if (localToolResolution) {
158 + const localResult = yield* Effect.tryPromise(() =>
159 + executeLocalToolBySlug(slug, params.arguments)
160 + );
161 + if (localResult) {
162 + return {
163 + successful: true,
164 + data: localResult as Record<string, unknown>,
165 + error: null,
166 + logId: '',
167 + } satisfies ToolExecuteResponse;
168 + }
169 }
170
171 const client = yield* clientSingleton.get();
172 const resolvedClient = params.client ?? client;
173 // One session per invocation — CLI runs one tool per process.
171 - const sessionId = yield* createToolRouterSession(resolvedClient, params.userId, {
172 - manageConnections: true,
173 - connectedAccounts: params.connectedAccounts,
174 - cacheScope: params.cacheScope,
175 - });
174 + const { sessionId, localExperimentalPayload } = yield* createToolRouterSessionContext(
175 + resolvedClient,
176 + params.userId,
177 + {
178 + manageConnections: true,
179 + connectedAccounts: params.connectedAccounts,
180 + cacheScope: params.cacheScope,
181 + }
182 + );
183 const normalizedArguments = isMetaToolSlug(slug)
184 ? params.arguments
185 : yield* getOrFetchToolInputDefinition(slug).pipe(
@@ -201,10 +208,12 @@ export const ToolsExecutorLive = Layer.effect(
208 arguments: normalizedArguments,
209 });
210 }
204 - return resolvedClient.toolRouter.session.execute(sessionId, {
211 + const executePayload = {
212 tool_slug: slug,
213 arguments: normalizedArguments,
207 - });
214 + ...(localExperimentalPayload ? { experimental: localExperimentalPayload } : {}),
215 + };
216 + return resolvedClient.toolRouter.session.execute(sessionId, executePayload);
217 }
218 );
219
ts/packages/cli/test/src/commands/tools/tools.search.cmd.test.ts
+91 -1
@@ -453,10 +453,100 @@ describe('CLI: composio search', () => {
453 }
454 );
455
456 + layer(TestLive(testLiveOptions))(
457 + '[Given] local toolkit filter [Then] it is sent as a custom toolkit',
458 + it => {
459 + it.scoped('injects and forwards local custom toolkit payloads', () =>
460 + Effect.gen(function* () {
461 + let createParams: SessionCreateParams | undefined;
462 + let searchParams:
463 + | (SessionSearchParams & { experimental?: SessionCreateParams['experimental'] })
464 + | undefined;
465 +
466 + const live = TestLive({
467 + baseConfigProvider: testConfigProvider,
468 + toolkitsData,
469 + fixture: 'global-test-user-id',
470 + toolRouter: {
471 + create: async params => {
472 + createParams = params;
473 + return {
474 + session_id: 'trs_test_session',
475 + config: {
476 + user_id: params.user_id,
477 + execute: {},
478 + search: {},
479 + preload: { tools: [] },
480 + },
481 + config_version: 1,
482 + mcp: { type: 'http', url: 'https://mcp.test.composio.dev' },
483 + tool_router_tools: ['COMPOSIO_SEARCH_TOOLS'],
484 + };
485 + },
486 + search: async (_sessionId, params) => {
487 + searchParams = params;
488 + return {
489 + success: true,
490 + error: null,
491 + results: [
492 + {
493 + index: 1,
494 + use_case: params.queries[0]?.use_case ?? '',
495 + primary_tool_slugs: ['LOCAL_CHROME_DEVTOOLS_LIST_PAGES'],
496 + related_tool_slugs: [],
497 + toolkits: ['CHROME_DEVTOOLS'],
498 + },
499 + ],
500 + tool_schemas: {
501 + LOCAL_CHROME_DEVTOOLS_LIST_PAGES: {
502 + tool_slug: 'LOCAL_CHROME_DEVTOOLS_LIST_PAGES',
503 + toolkit: 'CHROME_DEVTOOLS',
504 + description: 'List local Chrome pages',
505 + hasFullSchema: true,
506 + input_schema: { type: 'object', properties: {} },
507 + output_schema: { type: 'object', properties: {} },
508 + },
509 + },
510 + toolkit_connection_statuses: [
511 + {
512 + toolkit: 'CHROME_DEVTOOLS',
513 + description: 'Chrome DevTools local toolkit',
514 + has_active_connection: true,
515 + status_message: 'Local toolkit available',
516 + },
517 + ],
518 + next_steps_guidance: [],
519 + session: {
520 + id: 'trs_test_session',
521 + generate_id: false,
522 + instructions: 'Reuse this session id for follow-up calls.',
523 + },
524 + time_info: {
525 + current_time_utc: '2026-01-01T00:00:00.000Z',
526 + current_time_utc_epoch_seconds: 1767225600,
527 + message: 'UTC time',
528 + },
529 + };
530 + },
531 + },
532 + });
533 +
534 + yield* cli(['search', 'browser page', '--toolkits', 'chrome_devtools']).pipe(
535 + Effect.provide(live)
536 + );
537 +
538 + expect(createParams?.toolkits).toBeUndefined();
539 + expect(createParams?.experimental?.custom_toolkits?.[0]?.slug).toBe('CHROME_DEVTOOLS');
540 + expect(searchParams?.experimental?.custom_toolkits?.[0]?.slug).toBe('CHROME_DEVTOOLS');
541 + })
542 + );
543 + }
544 + );
545 +
546 layer(TestLive(testLiveOptions))(
547 '[Given] unknown local-style toolkit filter [Then] it is still sent as a remote toolkit',
548 it => {
459 - it.scoped('does not inject experimental custom toolkits in the foundation package', () =>
549 + it.scoped('does not inject experimental custom toolkits for unknown local-style names', () =>
550 Effect.gen(function* () {
551 let createParams: SessionCreateParams | undefined;
552
ts/packages/cli/vitest.config.ts
+1
@@ -13,6 +13,7 @@ export default defineConfig({
13 '~': path.resolve(__dirname, './'),
14 src: path.resolve(__dirname, './src'),
15 test: path.resolve(__dirname, './test'),
16 + '@composio/core/experimental': path.join(coreDir, 'src/experimental/index.ts'),
17 '@composio/core': path.join(coreDir, 'src/index.ts'),
18 '@composio/ts-builders': path.join(tsBuildersDir, 'src/index.ts'),
19 '@composio/json-schema-to-zod': path.join(jsonSchemaToZodDir, 'src/index.ts'),