Skip to content

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

Add multi-account selection and experimental CLI feature flags (#3129)

Rahul Tarakc4654159c76b
diff --git a/ts/packages/cli/src/analytics/dispatch.ts b/ts/packages/cli/src/analytics/dispatch.ts
index d205b4c5b..057c01446 100644
--- a/ts/packages/cli/src/analytics/dispatch.ts
+++ b/ts/packages/cli/src/analytics/dispatch.ts
@@ -533,7 +533,10 @@ export const runBackgroundWorkerFromArgv = async (argv: ReadonlyArray<string>):
try {
const decoded = decodeBase64Url(encodedPayload);
const body = JSON.parse(decoded) as ReturnType<typeof createCliCodactFailureBody>;
- if (body?.failure_type !== 'wrong_tool_slug' && body?.failure_type !== 'wrong_tool_input_param') {
+ if (
+ body?.failure_type !== 'wrong_tool_slug' &&
+ body?.failure_type !== 'wrong_tool_input_param'
+ ) {
return;
}
diff --git a/ts/packages/cli/src/commands/connected-accounts/commands/connected-accounts.link.cmd.ts b/ts/packages/cli/src/commands/connected-accounts/commands/connected-accounts.link.cmd.ts
index c67d37a5c..beb6897e9 100644
--- a/ts/packages/cli/src/commands/connected-accounts/commands/connected-accounts.link.cmd.ts
+++ b/ts/packages/cli/src/commands/connected-accounts/commands/connected-accounts.link.cmd.ts
@@ -10,11 +10,19 @@ import { extractMessage, extractSlug } from 'src/utils/api-error-extraction';
import { ProjectContext } from 'src/services/project-context';
import { ComposioClientSingleton, getSessionInfoByUserApiKey } from 'src/services/composio-clients';
import {
- resolveCommandProject,
formatResolveCommandProjectError,
+ resolveCommandProject,
} from 'src/services/command-project';
-import { invalidateConsumerConnectedToolkitsCache } from 'src/services/consumer-short-term-cache';
+import {
+ invalidateConsumerConnectedToolkitsCache,
+ writeConsumerConnectedToolkitsCache,
+} from 'src/services/consumer-short-term-cache';
import { appendCliSessionHistory } from 'src/services/cli-session-artifacts';
+import { formatConnectedAccountsTable } from '../format';
+import {
+ groupCachedConnectedAccountsByToolkit,
+ resolveDefaultConnectedAccountsByToolkit,
+} from 'src/services/connected-account-selection';
const toolkit = Args.text({ name: 'toolkit' }).pipe(
Args.withDescription('Toolkit slug to link (e.g. "github", "gmail")'),
@@ -41,6 +49,20 @@ const noWait = Options.boolean('no-wait').pipe(
Options.withDescription('Do not wait for authorization; only print link info')
);
+const alias = Options.text('alias').pipe(
+ Options.withDescription(
+ 'Alias to assign to the connected account. Required when creating an additional account for the same toolkit/auth config.'
+ ),
+ Options.optional
+);
+
+const list = Options.boolean('list').pipe(
+ Options.withDefault(false),
+ Options.withDescription(
+ 'List existing connected accounts for the toolkit instead of creating a new link'
+ )
+);
+
const showRedirectUrl = (
ui: TerminalUI,
redirectUrl: string,
@@ -198,12 +220,400 @@ const getConsumerCacheScope = (resolvedProject: {
}
: undefined;
+const normalizeAlias = (rawAlias: string) => rawAlias.trim();
+
+const listActiveConnectedAccounts = (params: {
+ readonly client: RawComposioClient;
+ readonly userId: string;
+ readonly toolkitSlug?: string;
+ readonly authConfigId?: string;
+}) =>
+ Effect.tryPromise(() =>
+ params.client.connectedAccounts.list({
+ user_ids: [params.userId],
+ toolkit_slugs: params.toolkitSlug ? [params.toolkitSlug] : undefined,
+ auth_config_ids: params.authConfigId ? [params.authConfigId] : undefined,
+ statuses: ['ACTIVE'],
+ limit: 100,
+ })
+ );
+
+const formatExistingAccountLabels = (
+ items: ReadonlyArray<{
+ readonly id: string;
+ readonly alias?: string | null;
+ readonly word_id?: string | null;
+ }>
+) =>
+ items
+ .map(item => {
+ const labels = [item.alias, item.word_id].filter(
+ (value): value is string => typeof value === 'string' && value.trim().length > 0
+ );
+ return labels.length > 0 ? `${item.id} (${labels.join(', ')})` : item.id;
+ })
+ .join(', ');
+
+const ensureAliasForAdditionalAccount = (params: {
+ readonly ui: TerminalUI;
+ readonly alias: Option.Option<string>;
+ readonly connectedAccountId: string;
+ readonly existingAccounts: {
+ readonly items: ReadonlyArray<{
+ readonly id: string;
+ readonly alias?: string | null;
+ readonly word_id?: string | null;
+ }>;
+ };
+ readonly scopeDescription: string;
+}) =>
+ Effect.gen(function* () {
+ if (Option.isSome(params.alias)) {
+ return true as const;
+ }
+
+ const existingIds = new Set(params.existingAccounts.items.map(item => item.id));
+ if (params.existingAccounts.items.length === 0 || existingIds.has(params.connectedAccountId)) {
+ return true as const;
+ }
+
+ yield* params.ui.log.error(
+ `A connected account already exists for ${params.scopeDescription}. Pass --alias to create another one.`
+ );
+ yield* params.ui.note(
+ formatExistingAccountLabels(params.existingAccounts.items),
+ 'Existing accounts'
+ );
+ return false as const;
+ });
+
+const patchConnectedAccountAlias = (params: {
+ readonly ui: TerminalUI;
+ readonly client: RawComposioClient;
+ readonly connectedAccountId: string;
+ readonly alias: Option.Option<string>;
+}) =>
+ Effect.gen(function* () {
+ if (Option.isNone(params.alias)) {
+ return;
+ }
+
+ const normalizedAlias = normalizeAlias(params.alias.value);
+ if (normalizedAlias.length === 0) {
+ return yield* Effect.fail(new Error('`--alias` cannot be empty.'));
+ }
+
+ yield* params.ui.withSpinner(
+ `Assigning alias "${normalizedAlias}"...`,
+ Effect.tryPromise(() =>
+ params.client.patch(`/api/v3/connected_accounts/${params.connectedAccountId}`, {
+ body: { alias: normalizedAlias },
+ })
+ )
+ );
+ });
+
+const resolveLinkUserId = (params: {
+ readonly resolvedProject: {
+ readonly projectType: 'CONSUMER' | 'DEVELOPER';
+ readonly consumerUserId?: string;
+ };
+ readonly requestedUserId: Option.Option<string>;
+ readonly projectContext: {
+ readonly resolve: Effect.Effect<
+ Option.Option<{ readonly testUserId: Option.Option<string> }>,
+ unknown
+ >;
+ };
+ readonly userContext: {
+ readonly data: {
+ readonly testUserId: Option.Option<string>;
+ };
+ };
+}) =>
+ Effect.gen(function* () {
+ const resolvedProjectContext = yield* params.projectContext.resolve.pipe(
+ Effect.catchAll(() => Effect.succeed(Option.none()))
+ );
+ const localTestUserId = Option.flatMap(resolvedProjectContext, keys => keys.testUserId);
+
+ const resolvedUserId =
+ params.resolvedProject.projectType === 'CONSUMER'
+ ? Option.fromNullable(params.resolvedProject.consumerUserId)
+ : Option.match(params.requestedUserId, {
+ onSome: value => Option.some(value),
+ onNone: () => Option.orElse(localTestUserId, () => params.userContext.data.testUserId),
+ });
+
+ return {
+ resolvedUserId,
+ resolvedProjectContext,
+ localTestUserId,
+ };
+ });
+
+const handleListConnectedAccounts = (params: {
+ readonly toolkit: Option.Option<string>;
+ readonly authConfig: Option.Option<string>;
+ readonly rootOnly: boolean;
+ readonly projectName: Option.Option<string>;
+ readonly userId: Option.Option<string>;
+ readonly ui: TerminalUI;
+ readonly clientSingleton: {
+ readonly getFor: (params: {
+ readonly orgId: string;
+ readonly projectId: string;
+ }) => Effect.Effect<RawComposioClient, unknown>;
+ };
+ readonly projectContext: {
+ readonly resolve: Effect.Effect<
+ Option.Option<{ readonly testUserId: Option.Option<string> }>,
+ unknown
+ >;
+ };
+ readonly userContext: {
+ readonly data: {
+ readonly testUserId: Option.Option<string>;
+ };
+ };
+}) =>
+ Effect.gen(function* () {
+ if (Option.isNone(params.toolkit)) {
+ yield* params.ui.log.error(
+ '`--list` requires a toolkit slug, e.g. `composio link gmail --list`.'
+ );
+ return;
+ }
+ if (Option.isSome(params.authConfig)) {
+ yield* params.ui.log.error('`--list` cannot be combined with `--auth-config`.');
+ return;
+ }
+
+ const toolkitSlug = params.toolkit.value;
+ const resolvedProject = yield* resolveCommandProject({
+ mode: 'consumer',
+ projectName: params.rootOnly ? undefined : Option.getOrUndefined(params.projectName),
+ }).pipe(Effect.mapError(formatResolveCommandProjectError));
+ const client = yield* params.clientSingleton.getFor({
+ orgId: resolvedProject.orgId,
+ projectId: resolvedProject.projectId,
+ });
+ const { resolvedUserId } = yield* resolveLinkUserId({
+ resolvedProject,
+ requestedUserId: params.userId,
+ projectContext: params.projectContext,
+ userContext: params.userContext,
+ });
+
+ if (Option.isNone(resolvedUserId)) {
+ return yield* Effect.fail(
+ new Error('Missing user id. Provide --user-id or run composio dev init/login first.')
+ );
+ }
+
+ const accounts = yield* params.ui.withSpinner(
+ `Listing connected accounts for "${toolkitSlug}"...`,
+ Effect.tryPromise(() =>
+ client.connectedAccounts.list({
+ toolkit_slugs: [toolkitSlug],
+ user_ids: [resolvedUserId.value],
+ statuses: ['ACTIVE'],
+ limit: 100,
+ })
+ )
+ );
+
+ if (resolvedProject.projectType === 'CONSUMER' && resolvedProject.consumerUserId) {
+ yield* writeConsumerConnectedToolkitsCache({
+ orgId: resolvedProject.orgId,
+ consumerUserId: resolvedProject.consumerUserId,
+ toolkits: [toolkitSlug],
+ toolRouterConnectedAccounts: {
+ connectedAccounts: resolveDefaultConnectedAccountsByToolkit(
+ accounts.items as Parameters<typeof resolveDefaultConnectedAccountsByToolkit>[0]
+ ),
+ availableConnectedAccounts: groupCachedConnectedAccountsByToolkit(
+ accounts.items as Parameters<typeof groupCachedConnectedAccountsByToolkit>[0]
+ ),
+ },
+ }).pipe(Effect.catchAll(() => Effect.void));
+ }
+
+ if (accounts.items.length === 0) {
+ yield* params.ui.log.warn(`No active connected accounts found for "${toolkitSlug}".`);
+ yield* params.ui.output(
+ JSON.stringify({ toolkit: toolkitSlug, items: [], total: 0 }, null, 2),
+ { force: true }
+ );
+ return;
+ }
+
+ yield* params.ui.note(
+ formatConnectedAccountsTable(
+ accounts.items as Parameters<typeof formatConnectedAccountsTable>[0]
+ ),
+ `${toolkitSlug}: connected accounts`
+ );
+ yield* params.ui.output(
+ JSON.stringify(
+ {
+ toolkit: toolkitSlug,
+ total: accounts.items.length,
+ items: accounts.items,
+ },
+ null,
+ 2
+ ),
+ { force: true }
+ );
+ });
+
+const handleLegacyAuthConfigLink = (params: {
+ readonly authConfigId: string;
+ readonly requestedUserId: Option.Option<string>;
+ readonly projectName: Option.Option<string>;
+ readonly noWait: boolean;
+ readonly alias: Option.Option<string>;
+ readonly ui: TerminalUI;
+ readonly clientSingleton: {
+ readonly getFor: (params: {
+ readonly orgId: string;
+ readonly projectId: string;
+ }) => Effect.Effect<RawComposioClient, unknown>;
+ };
+ readonly projectContext: {
+ readonly resolve: Effect.Effect<
+ Option.Option<{ readonly testUserId: Option.Option<string> }>,
+ unknown
+ >;
+ };
+ readonly userContext: {
+ readonly data: {
+ readonly testUserId: Option.Option<string>;
+ };
+ };
+}) =>
+ Effect.gen(function* () {
+ const resolvedProjectContext = yield* params.projectContext.resolve.pipe(
+ Effect.catchAll(() => Effect.succeed(Option.none()))
+ );
+ const localTestUserId = Option.flatMap(resolvedProjectContext, keys => keys.testUserId);
+ const globalTestUserId = params.userContext.data.testUserId;
+ const resolvedUserId = Option.match(params.requestedUserId, {
+ onSome: value => Option.some(value),
+ onNone: () => Option.orElse(localTestUserId, () => globalTestUserId),
+ });
+
+ if (Option.isNone(resolvedUserId)) {
+ return yield* Effect.fail(
+ new Error(
+ 'Missing user id. Provide --user-id or run composio dev init to set test_user_id.'
+ )
+ );
+ }
+ if (Option.isNone(params.projectName) && Option.isNone(resolvedProjectContext)) {
+ yield* params.ui.log.error(
+ '`--auth-config` is developer-project scoped. Pass `--project-name <name>` or run from a directory initialized with `composio dev init`.'
+ );
+ return;
+ }
+ if (Option.isNone(params.requestedUserId) && Option.isSome(localTestUserId)) {
+ yield* params.ui.log.warn(`Using test user id "${localTestUserId.value}"`);
+ } else if (Option.isNone(params.requestedUserId) && Option.isSome(globalTestUserId)) {
+ yield* params.ui.log.warn(`Using global test user id "${globalTestUserId.value}"`);
+ }
+
+ const resolvedProject = yield* resolveCommandProject({
+ mode: 'developer',
+ projectName: Option.getOrUndefined(params.projectName),
+ }).pipe(Effect.mapError(formatResolveCommandProjectError));
+ const client = yield* params.clientSingleton.getFor({
+ orgId: resolvedProject.orgId,
+ projectId: resolvedProject.projectId,
+ });
+ const existingAccounts = yield* listActiveConnectedAccounts({
+ client,
+ userId: resolvedUserId.value,
+ authConfigId: params.authConfigId,
+ }).pipe(Effect.catchAll(() => Effect.succeed({ items: [] })));
+ const linkOpt = yield* params.ui
+ .withSpinner(
+ 'Creating link session...',
+ Effect.tryPromise(() =>
+ client.link.create({
+ auth_config_id: params.authConfigId,
+ user_id: resolvedUserId.value,
+ })
+ )
+ )
+ .pipe(
+ Effect.asSome,
+ Effect.catchAll(error =>
+ Effect.gen(function* () {
+ const message =
+ extractMessage(error) ??
+ `Failed to create link for auth config "${params.authConfigId}".`;
+ yield* params.ui.log.error(message);
+ yield* params.ui.log.step(
+ 'Browse available auth configs:\n> composio dev auth-configs list'
+ );
+ return Option.none();
+ })
+ )
+ );
+
+ if (Option.isNone(linkOpt)) return;
+
+ const validatedLink = yield* validateLinkResponse(params.ui, linkOpt.value);
+ if (Option.isNone(validatedLink)) return;
+
+ const { connectedAccountId, redirectUrl } = validatedLink.value;
+ const canContinue = yield* ensureAliasForAdditionalAccount({
+ ui: params.ui,
+ alias: params.alias,
+ connectedAccountId,
+ existingAccounts,
+ scopeDescription: `user "${resolvedUserId.value}" in auth config "${params.authConfigId}"`,
+ });
+ if (!canContinue) return;
+
+ yield* patchConnectedAccountAlias({
+ ui: params.ui,
+ client,
+ connectedAccountId,
+ alias: params.alias,
+ });
+
+ if (params.noWait) {
+ yield* showRedirectUrl(params.ui, redirectUrl);
+ yield* params.ui.output(
+ JSON.stringify(
+ {
+ status: 'pending',
+ message: 'Complete authorization by opening the URL',
+ connected_account_id: connectedAccountId,
+ redirect_url: redirectUrl,
+ project_type: resolvedProject.projectType,
+ },
+ null,
+ 2
+ ),
+ { force: true }
+ );
+ return;
+ }
+
+ yield* waitForActiveConnection(params.ui, client, connectedAccountId, redirectUrl);
+ });
+
const runConnectedAccountsLink = (params: {
toolkit: Option.Option<string>;
authConfig: Option.Option<string>;
userId: Option.Option<string>;
projectName: Option.Option<string>;
noWait: boolean;
+ alias: Option.Option<string>;
+ list: boolean;
rootOnly: boolean;
}) =>
Effect.gen(function* () {
@@ -244,93 +654,33 @@ const runConnectedAccountsLink = (params: {
return;
}
- if (Option.isSome(params.authConfig)) {
- const authConfigId = params.authConfig.value;
- const resolvedProjectContext = yield* projectContext.resolve.pipe(
- Effect.catchAll(() => Effect.succeed(Option.none()))
- );
- const localTestUserId = Option.flatMap(resolvedProjectContext, keys => keys.testUserId);
- const globalTestUserId = userContext.data.testUserId;
- const resolvedUserId = Option.match(params.userId, {
- onSome: value => Option.some(value),
- onNone: () => Option.orElse(localTestUserId, () => globalTestUserId),
- });
- if (Option.isNone(resolvedUserId)) {
- return yield* Effect.fail(
- new Error(
- 'Missing user id. Provide --user-id or run composio dev init to set test_user_id.'
- )
- );
- }
- if (Option.isNone(params.projectName) && Option.isNone(resolvedProjectContext)) {
- yield* ui.log.error(
- '`--auth-config` is developer-project scoped. Pass `--project-name <name>` or run from a directory initialized with `composio dev init`.'
- );
- return;
- }
- if (Option.isNone(params.userId) && Option.isSome(localTestUserId)) {
- yield* ui.log.warn(`Using test user id "${localTestUserId.value}"`);
- } else if (Option.isNone(params.userId) && Option.isSome(globalTestUserId)) {
- yield* ui.log.warn(`Using global test user id "${globalTestUserId.value}"`);
- }
- const resolvedProject = yield* resolveCommandProject({
- mode: 'developer',
- projectName: Option.getOrUndefined(params.projectName),
- }).pipe(Effect.mapError(formatResolveCommandProjectError));
- const client = yield* clientSingleton.getFor({
- orgId: resolvedProject.orgId,
- projectId: resolvedProject.projectId,
+ if (params.list) {
+ yield* handleListConnectedAccounts({
+ toolkit: params.toolkit,
+ authConfig: params.authConfig,
+ rootOnly: params.rootOnly,
+ projectName: params.projectName,
+ userId: params.userId,
+ ui,
+ clientSingleton,
+ projectContext,
+ userContext,
});
- const linkOpt = yield* ui
- .withSpinner(
- 'Creating link session...',
- Effect.tryPromise(() =>
- client.link.create({
- auth_config_id: authConfigId,
- user_id: resolvedUserId.value,
- })
- )
- )
- .pipe(
- Effect.asSome,
- Effect.catchAll(error =>
- Effect.gen(function* () {
- const message =
- extractMessage(error) ?? `Failed to create link for auth config "${authConfigId}".`;
- yield* ui.log.error(message);
- yield* ui.log.step(
- 'Browse available auth configs:\n> composio dev auth-configs list'
- );
- return Option.none();
- })
- )
- );
+ return;
+ }
- if (Option.isNone(linkOpt)) return;
-
- const validatedLink = yield* validateLinkResponse(ui, linkOpt.value);
- if (Option.isNone(validatedLink)) return;
-
- const { connectedAccountId: connId, redirectUrl } = validatedLink.value;
- if (params.noWait) {
- yield* showRedirectUrl(ui, redirectUrl);
- yield* ui.output(
- JSON.stringify(
- {
- status: 'pending',
- message: 'Complete authorization by opening the URL',
- connected_account_id: connId,
- redirect_url: redirectUrl,
- project_type: resolvedProject.projectType,
- },
- null,
- 2
- ),
- { force: true }
- );
- } else {
- yield* waitForActiveConnection(ui, client, connId, redirectUrl);
- }
+ if (Option.isSome(params.authConfig)) {
+ yield* handleLegacyAuthConfigLink({
+ authConfigId: params.authConfig.value,
+ requestedUserId: params.userId,
+ projectName: params.projectName,
+ noWait: params.noWait,
+ alias: params.alias,
+ ui,
+ clientSingleton,
+ projectContext,
+ userContext,
+ });
return;
}
@@ -357,6 +707,11 @@ const runConnectedAccountsLink = (params: {
orgId: resolvedProject.orgId,
projectId: resolvedProject.projectId,
});
+ const existingAccounts = yield* listActiveConnectedAccounts({
+ client,
+ userId: resolvedUserId.value,
+ toolkitSlug,
+ }).pipe(Effect.catchAll(() => Effect.succeed({ items: [] })));
const linkOpt = yield* ui
.withSpinner(
@@ -401,6 +756,21 @@ const runConnectedAccountsLink = (params: {
if (Option.isNone(validatedLink)) return;
const { connectedAccountId: connAccountId, redirectUrl } = validatedLink.value;
+ const canContinue = yield* ensureAliasForAdditionalAccount({
+ ui,
+ alias: params.alias,
+ connectedAccountId: connAccountId,
+ existingAccounts,
+ scopeDescription: `user "${resolvedUserId.value}" in toolkit "${toolkitSlug}"`,
+ });
+ if (!canContinue) return;
+
+ yield* patchConnectedAccountAlias({
+ ui,
+ client,
+ connectedAccountId: connAccountId,
+ alias: params.alias,
+ });
if (params.noWait) {
yield* showRedirectUrl(ui, redirectUrl);
@@ -450,14 +820,16 @@ const runConnectedAccountsLink = (params: {
export const connectedAccountsCmd$Link = Command.make(
'link',
- { toolkit, authConfig, userId, projectName, noWait },
- ({ toolkit, authConfig, userId, projectName, noWait }) =>
+ { toolkit, authConfig, userId, projectName, noWait, alias, list },
+ ({ toolkit, authConfig, userId, projectName, noWait, alias, list }) =>
runConnectedAccountsLink({
toolkit,
authConfig,
userId,
projectName,
noWait,
+ alias,
+ list,
rootOnly: false,
})
).pipe(
@@ -468,6 +840,8 @@ export const connectedAccountsCmd$Link = Command.make(
'',
'Examples:',
' composio link github',
+ ' composio link gmail --alias work',
+ ' composio link github --list',
'',
'See also:',
' composio search "<query>" Find tools to use after linking',
@@ -478,14 +852,16 @@ export const connectedAccountsCmd$Link = Command.make(
export const rootConnectedAccountsCmd$Link = Command.make(
'link',
- { toolkit, noWait },
- ({ toolkit, noWait }) =>
+ { toolkit, noWait, alias, list },
+ ({ toolkit, noWait, alias, list }) =>
runConnectedAccountsLink({
toolkit,
authConfig: Option.none(),
userId: Option.none(),
projectName: Option.none(),
noWait,
+ alias,
+ list,
rootOnly: true,
})
).pipe(
@@ -496,6 +872,8 @@ export const rootConnectedAccountsCmd$Link = Command.make(
'',
'Examples:',
' composio link github',
+ ' composio link gmail --alias work',
+ ' composio link github --list',
'',
'See also:',
' composio search "<query>" Find tools to use after linking',
diff --git a/ts/packages/cli/src/commands/connected-accounts/commands/connected-accounts.whoami.cmd.ts b/ts/packages/cli/src/commands/connected-accounts/commands/connected-accounts.whoami.cmd.ts
index 695d35191..0c5431e14 100644
--- a/ts/packages/cli/src/commands/connected-accounts/commands/connected-accounts.whoami.cmd.ts
+++ b/ts/packages/cli/src/commands/connected-accounts/commands/connected-accounts.whoami.cmd.ts
@@ -72,6 +72,8 @@ export const connectedAccountsCmd$Whoami = Command.make('whoami', { id }, ({ id
JSON.stringify(
{
id: item.id,
+ alias: item.alias,
+ word_id: item.word_id,
toolkit: item.toolkit.slug,
user_id: item.user_id,
status: item.status,
diff --git a/ts/packages/cli/src/commands/connected-accounts/format.ts b/ts/packages/cli/src/commands/connected-accounts/format.ts
index b25e398bc..700c9eaa7 100644
--- a/ts/packages/cli/src/commands/connected-accounts/format.ts
+++ b/ts/packages/cli/src/commands/connected-accounts/format.ts
@@ -7,10 +7,12 @@ import { truncate } from 'src/ui/truncate';
* Format a list of connected accounts as a human-readable table.
*/
export function formatConnectedAccountsTable(items: ReadonlyArray<ConnectedAccountItem>): string {
- const header = `${bold('Id'.padEnd(18))} ${bold('User Id'.padEnd(20))} ${bold('Toolkit'.padEnd(14))} ${bold('Auth Config'.padEnd(18))} ${bold('Auth Scheme'.padEnd(14))} ${bold('Status')}`;
+ const header = `${bold('Id'.padEnd(18))} ${bold('Alias'.padEnd(14))} ${bold('Word'.padEnd(12))} ${bold('User Id'.padEnd(20))} ${bold('Toolkit'.padEnd(14))} ${bold('Auth Config'.padEnd(18))} ${bold('Auth Scheme'.padEnd(14))} ${bold('Status')}`;
const rows = items.map(item => {
const id = truncate(redact({ value: item.id, prefix: 'con_' }), 18).padEnd(18);
+ const alias = truncate(item.alias || '-', 14).padEnd(14);
+ const wordId = truncate(item.word_id || '-', 12).padEnd(12);
const userId = truncate(item.user_id, 20).padEnd(20);
const toolkit = truncate(item.toolkit.slug, 14).padEnd(14);
const authConfig = truncate(redact({ value: item.auth_config.id, prefix: 'ac_' }), 18).padEnd(
@@ -18,7 +20,7 @@ export function formatConnectedAccountsTable(items: ReadonlyArray<ConnectedAccou
);
const authScheme = truncate(item.auth_config.auth_scheme || '-', 14).padEnd(14);
const status = item.status === 'ACTIVE' ? item.status : gray(item.status);
- return `${id} ${userId} ${toolkit} ${authConfig} ${authScheme} ${status}`;
+ return `${id} ${alias} ${wordId} ${userId} ${toolkit} ${authConfig} ${authScheme} ${status}`;
});
return [header, ...rows].join('\n');
@@ -31,6 +33,8 @@ export function formatConnectedAccountsJson(items: ReadonlyArray<ConnectedAccoun
return JSON.stringify(
items.map(item => ({
id: item.id,
+ alias: item.alias,
+ word_id: item.word_id,
user_id: item.user_id,
toolkit_slug: item.toolkit.slug,
auth_config_id: item.auth_config.id,
@@ -50,6 +54,8 @@ export function formatConnectedAccountInfo(item: ConnectedAccountItem): string {
const lines: string[] = [];
lines.push(`${bold('Id:')} ${redact({ value: item.id, prefix: 'con_' })}`);
+ lines.push(`${bold('Alias:')} ${item.alias || '-'}`);
+ lines.push(`${bold('Word Id:')} ${item.word_id || '-'}`);
lines.push(`${bold('Status:')} ${item.status === 'ACTIVE' ? item.status : gray(item.status)}`);
if (item.status_reason) {
@@ -79,6 +85,8 @@ export function formatConnectedAccountInfo(item: ConnectedAccountItem): string {
export function formatConnectedAccountWhoami(item: ConnectedAccountItem): string {
const lines: string[] = [];
lines.push(`${bold('Id:')} ${redact({ value: item.id, prefix: 'con_' })}`);
+ lines.push(`${bold('Alias:')} ${item.alias || '-'}`);
+ lines.push(`${bold('Word Id:')} ${item.word_id || '-'}`);
lines.push(`${bold('Status:')} ${item.status === 'ACTIVE' ? item.status : gray(item.status)}`);
lines.push(`${bold('Toolkit:')} ${item.toolkit.slug}`);
lines.push(`${bold('User Id:')} ${item.user_id}`);
diff --git a/ts/packages/cli/src/commands/index.ts b/ts/packages/cli/src/commands/index.ts
index 9335b7dc0..f0b0781ca 100644
--- a/ts/packages/cli/src/commands/index.ts
+++ b/ts/packages/cli/src/commands/index.ts
@@ -1,7 +1,6 @@
import process from 'node:process';
import { Effect, Option } from 'effect';
import { Command } from '@effect/cli';
-import * as constants from 'src/constants';
import { $defaultCmd } from './$default.cmd';
import { getVersion } from 'src/effects/version';
import { versionCmd } from './version.cmd';
diff --git a/ts/packages/cli/src/commands/listen.cmd.ts b/ts/packages/cli/src/commands/listen.cmd.ts
index a48f1a2bc..becb229f6 100644
--- a/ts/packages/cli/src/commands/listen.cmd.ts
+++ b/ts/packages/cli/src/commands/listen.cmd.ts
@@ -16,6 +16,10 @@ import {
} from 'src/services/cli-session-artifacts';
import { TerminalUI } from 'src/services/terminal-ui';
import { TriggersRealtime } from 'src/services/triggers-realtime';
+import {
+ formatConnectedAccountChoices,
+ resolveConnectedAccountSelection,
+} from 'src/services/connected-account-selection';
import { parseJsonIsh } from 'src/utils/parse-json-ish';
import { toolkitFromToolSlug } from 'src/utils/toolkit-from-tool-slug';
import { matchesTriggerListenFilters } from './triggers/filter';
@@ -51,6 +55,12 @@ const stream = Options.text('stream').pipe(
),
Options.optional
);
+const account = Options.text('account').pipe(
+ Options.withDescription(
+ 'Connected account selector. Matches alias, word_id, or connected account id for the inferred toolkit.'
+ ),
+ Options.optional
+);
const debug = Options.boolean('debug').pipe(
Options.withDescription(
@@ -103,6 +113,7 @@ const resolveConnectedAccountIdForTrigger = (params: {
client: RawComposioClient;
slug: string;
consumerUserId: string;
+ account: Option.Option<string>;
}) =>
Effect.gen(function* () {
const toolkitSlug = toolkitFromToolSlug(params.slug);
@@ -125,36 +136,29 @@ const resolveConnectedAccountIdForTrigger = (params: {
catch: error =>
new Error(`Failed to list connected accounts for "${toolkitSlug}": ${String(error)}`),
});
- const connectedAccountId = selectConnectedAccountId(connectedAccounts.items);
-
- if (!connectedAccountId) {
- return yield* Effect.fail(
- new Error(
- `No active connected account found for toolkit "${toolkitSlug}" and consumer user "${params.consumerUserId}". Run \`composio link ${toolkitSlug}\` first.`
- )
- );
+ const selectedAccount = resolveConnectedAccountSelection(
+ connectedAccounts.items as Parameters<typeof resolveConnectedAccountSelection>[0],
+ Option.getOrUndefined(params.account)
+ );
+ if (selectedAccount?.id) {
+ return selectedAccount.id;
}
- return connectedAccountId;
+ const choices = formatConnectedAccountChoices(
+ connectedAccounts.items as Parameters<typeof formatConnectedAccountChoices>[0]
+ );
+ const suffix =
+ Option.isSome(params.account) && choices.length > 0
+ ? ` Available accounts: ${choices.join(', ')}.`
+ : '';
+ return yield* Effect.fail(
+ new Error(
+ Option.isSome(params.account)
+ ? `No connected account matched "${params.account.value}" for toolkit "${toolkitSlug}" and consumer user "${params.consumerUserId}".${suffix}`
+ : `No active connected account found for toolkit "${toolkitSlug}" and consumer user "${params.consumerUserId}". Run \`composio link ${toolkitSlug}\` first.`
+ )
+ );
});
-
-const selectConnectedAccountId = (
- items: ReadonlyArray<{
- id: string;
- updated_at: string;
- is_disabled: boolean;
- }>
-): string | undefined => {
- const active = items.filter(item => !item.is_disabled);
- if (active.length === 0) {
- return undefined;
- }
-
- return [...active]
- .sort((left, right) => Date.parse(right.updated_at) - Date.parse(left.updated_at))
- .at(0)?.id;
-};
-
const emitStreamLine = (line: string, ui: TerminalUI) =>
Effect.gen(function* () {
yield* ui.log.message(line);
@@ -303,10 +307,78 @@ const parseTimeoutMs = (value: string): number => {
return Math.round(amount * unitMs);
};
+const resolveListenSetup = (params: {
+ readonly slug: string;
+ readonly inputParams: Option.Option<string>;
+ readonly timeout: Option.Option<string>;
+ readonly stream: Option.Option<string>;
+ readonly maxEvents: Option.Option<number>;
+ readonly account: Option.Option<string>;
+ readonly client: RawComposioClient;
+ readonly resolvedProject: {
+ readonly orgId: string;
+ readonly projectId: string;
+ readonly consumerUserId?: string;
+ };
+}) =>
+ Effect.gen(function* () {
+ if (!params.resolvedProject.consumerUserId) {
+ return yield* Effect.fail(
+ new Error('No consumer user is available in the current project context.')
+ );
+ }
+
+ const listeningToProjectEvent = isProjectEventType(params.slug);
+ const rawParams = Option.isSome(params.inputParams)
+ ? (yield* resolveParamsInput(params.inputParams))?.trim() || '{}'
+ : '{}';
+ const createParamsInput = yield* parseCreateParams(rawParams);
+ yield* assertSupportedListenParams({
+ listeningToProjectEvent,
+ slug: params.slug,
+ createParamsInput,
+ });
+
+ const resolvedConnectedAccountId = listeningToProjectEvent
+ ? undefined
+ : yield* resolveConnectedAccountIdForTrigger({
+ client: params.client,
+ slug: params.slug,
+ consumerUserId: params.resolvedProject.consumerUserId,
+ account: params.account,
+ });
+
+ const createParams = listeningToProjectEvent
+ ? undefined
+ : ({
+ ...createParamsInput,
+ connected_account_id: resolvedConnectedAccountId,
+ } as Parameters<typeof params.client.triggerInstances.upsert>[1]);
+
+ return {
+ listeningToProjectEvent,
+ createParams,
+ timeoutMs: Option.match(params.timeout, {
+ onNone: () => undefined,
+ onSome: value => parseTimeoutMs(value),
+ }),
+ streamPath: Option.match(params.stream, {
+ onNone: () => undefined,
+ onSome: value => {
+ const trimmed = value.trim();
+ return trimmed.length === 0 ? [] : parseStreamPath(trimmed);
+ },
+ }),
+ shouldStream: Option.isSome(params.stream),
+ maxEventsLimit: Option.getOrUndefined(params.maxEvents),
+ consumerUserId: params.resolvedProject.consumerUserId,
+ };
+ });
+
export const listenCmd = Command.make(
'listen',
- { slug, params, maxEvents, timeout, stream, debug },
- ({ slug, params, maxEvents, timeout, stream, debug }) =>
+ { slug, params, maxEvents, timeout, stream, account, debug },
+ ({ slug, params, maxEvents, timeout, stream, account, debug }) =>
Effect.gen(function* () {
if (!(yield* requireAuth)) return;
@@ -324,50 +396,28 @@ export const listenCmd = Command.make(
orgId: resolvedProject.orgId,
projectId: resolvedProject.projectId,
});
-
- if (!resolvedProject.consumerUserId) {
- return yield* Effect.fail(
- new Error('No consumer user is available in the current project context.')
- );
- }
-
- const listeningToProjectEvent = isProjectEventType(slug);
- const rawParams = Option.isSome(params)
- ? (yield* resolveParamsInput(params))?.trim() || '{}'
- : '{}';
- const createParamsInput = yield* parseCreateParams(rawParams);
- yield* assertSupportedListenParams({ listeningToProjectEvent, slug, createParamsInput });
-
- const resolvedConnectedAccountId = listeningToProjectEvent
- ? undefined
- : yield* resolveConnectedAccountIdForTrigger({
- client,
- slug,
- consumerUserId: resolvedProject.consumerUserId,
- });
-
- const createParams = listeningToProjectEvent
- ? undefined
- : ({
- ...createParamsInput,
- connected_account_id: resolvedConnectedAccountId,
- } as Parameters<typeof client.triggerInstances.upsert>[1]);
- const timeoutMs = Option.match(timeout, {
- onNone: () => undefined,
- onSome: value => parseTimeoutMs(value),
- });
- const streamPath = Option.match(stream, {
- onNone: () => undefined,
- onSome: value => {
- const trimmed = value.trim();
- return trimmed.length === 0 ? [] : parseStreamPath(trimmed);
- },
+ const {
+ listeningToProjectEvent,
+ createParams,
+ timeoutMs,
+ streamPath,
+ shouldStream,
+ maxEventsLimit,
+ consumerUserId,
+ } = yield* resolveListenSetup({
+ slug,
+ inputParams: params,
+ timeout,
+ stream,
+ maxEvents,
+ account,
+ client,
+ resolvedProject,
});
- const shouldStream = Option.isSome(stream);
const artifactsOption = yield* resolveCliSessionArtifacts({
orgId: resolvedProject.orgId,
- consumerUserId: resolvedProject.consumerUserId,
+ consumerUserId,
});
const artifactsRoot = Option.match(artifactsOption, {
onNone: () => resolveFallbackArtifactsDir(),
@@ -383,7 +433,6 @@ export const listenCmd = Command.make(
yield* fs.makeDirectory(triggerDir, { recursive: true });
yield* fs.writeFileString(streamFilePath, '', { flag: 'a' });
- const maxEventsLimit = Option.getOrUndefined(maxEvents);
const stopWhenDone = yield* Deferred.make<'max-events' | 'timeout'>();
let matchingEvents = 0;
const seenEventIds = new Set<string>();
diff --git a/ts/packages/cli/src/commands/tools/commands/tools.execute.cmd.ts b/ts/packages/cli/src/commands/tools/commands/tools.execute.cmd.ts
index 13a4efa66..6fee32e41 100644
--- a/ts/packages/cli/src/commands/tools/commands/tools.execute.cmd.ts
+++ b/ts/packages/cli/src/commands/tools/commands/tools.execute.cmd.ts
@@ -1,4 +1,5 @@
import { Args, Command, Options } from '@effect/cli';
+import type { Composio } from '@composio/client';
import util from 'node:util';
import { Effect, Option, Either, Exit, Fiber, Cause } from 'effect';
import { encodingForModel } from 'js-tiktoken';
@@ -43,6 +44,10 @@ import {
getFreshConsumerConnectedToolkitsFromCache,
refreshConsumerConnectedToolkitsCache,
} from 'src/services/consumer-short-term-cache';
+import {
+ formatConnectedAccountChoices,
+ resolveConnectedAccountSelection,
+} from 'src/services/connected-account-selection';
import {
appendCliSessionHistory,
resolveCliSessionArtifacts,
@@ -69,6 +74,12 @@ const file = Options.text('file').pipe(
Options.withDescription('Inject a local file path into the single file_uploadable input'),
Options.optional
);
+const accountOption = Options.text('account').pipe(
+ Options.withDescription(
+ 'Connected account selector for the inferred toolkit. Matches alias, word_id, or connected account id.'
+ ),
+ Options.optional
+);
const userId = Options.text('user-id').pipe(
Options.optional,
@@ -271,6 +282,8 @@ const getExecuteOutputEncoder = () => {
return executeOutputEncoder;
};
+const shouldStoreLargeExecuteOutput = () => process.env.COMPOSIO_CLI_INVOCATION_ORIGIN !== 'run';
+
type StoredExecuteOutputSummary = {
readonly successful: true;
readonly error: null;
@@ -327,7 +340,7 @@ const prepareExecuteOutput = (
Effect.gen(function* () {
const json = serializeExecuteOutput(result);
const tokenCount = getExecuteOutputEncoder().encode(json).length;
- if (tokenCount <= EXECUTE_INLINE_OUTPUT_TOKEN_THRESHOLD) {
+ if (tokenCount <= EXECUTE_INLINE_OUTPUT_TOKEN_THRESHOLD || !shouldStoreLargeExecuteOutput()) {
return {
kind: 'inline' as const,
json,
@@ -812,6 +825,7 @@ type RunToolsExecuteParams = {
slug: string;
data: Option.Option<string>;
file: Option.Option<string>;
+ account: Option.Option<string>;
userId: Option.Option<string>;
projectName: Option.Option<string>;
surface: 'root' | 'dev';
@@ -828,6 +842,7 @@ type SharedRunToolsExecuteParams = Omit<RunToolsExecuteParams, 'slug' | 'data' |
type ParallelExecuteSpec = {
readonly slug: string;
readonly data: Option.Option<string>;
+ readonly account: Option.Option<string>;
};
type ParsedParallelExecuteArgs = SharedRunToolsExecuteParams & {
@@ -859,6 +874,7 @@ type ResolvedExecuteContext = {
};
readonly args: Record<string, unknown>;
readonly resolvedUserId: string;
+ readonly selectedConnectedAccountId?: string;
readonly executeParams: ToolExecuteParams;
readonly executeOutputDir?: string;
};
@@ -901,6 +917,57 @@ const emitCachedSchema = (
);
});
+const resolveExplicitConnectedAccount = (params: {
+ readonly client: Composio;
+ readonly toolkitSlug?: string;
+ readonly userId: string;
+ readonly selector: Option.Option<string>;
+}): Effect.Effect<string | undefined, Error> =>
+ Effect.gen(function* () {
+ if (!params.toolkitSlug) return undefined;
+ const toolkitSlug = params.toolkitSlug;
+
+ const accounts = yield* Effect.tryPromise({
+ try: () =>
+ params.client.connectedAccounts.list({
+ toolkit_slugs: [toolkitSlug],
+ user_ids: [params.userId],
+ statuses: ['ACTIVE'],
+ limit: 100,
+ }),
+ catch: error =>
+ new Error(
+ `Failed to load connected accounts for toolkit "${toolkitSlug}": ${String(error)}`
+ ),
+ });
+
+ const selected = resolveConnectedAccountSelection(
+ accounts.items as Parameters<typeof resolveConnectedAccountSelection>[0],
+ Option.getOrUndefined(params.selector)
+ );
+
+ if (selected) {
+ return selected.id;
+ }
+
+ if (Option.isNone(params.selector)) {
+ return undefined;
+ }
+
+ const choices = formatConnectedAccountChoices(
+ accounts.items as Parameters<typeof formatConnectedAccountChoices>[0]
+ );
+ const hint =
+ choices.length > 0
+ ? ` Available accounts: ${choices.join(', ')}.`
+ : ' No active connected accounts were found for that toolkit.';
+ return yield* Effect.fail(
+ new Error(
+ `No connected account matched "${params.selector.value}" for toolkit "${toolkitSlug}".${hint}`
+ )
+ );
+ });
+
const resolveExecuteContext = (params: RunToolsExecuteParams) =>
Effect.gen(function* () {
const resolvedProject = yield* resolveCommandProject({
@@ -942,6 +1009,13 @@ const resolveExecuteContext = (params: RunToolsExecuteParams) =>
orgId: resolvedProject.orgId,
projectId: resolvedProject.projectId,
});
+ const toolkitSlug = toolkitFromToolSlug(params.slug);
+ const selectedConnectedAccountId = yield* resolveExplicitConnectedAccount({
+ client,
+ toolkitSlug,
+ userId: resolvedUserId.value,
+ selector: params.account,
+ });
const args = Option.isSome(params.file)
? yield* getOrFetchToolInputDefinition(params.slug, {
orgId: resolvedProject.orgId,
@@ -973,11 +1047,18 @@ const resolveExecuteContext = (params: RunToolsExecuteParams) =>
resolvedProject,
args,
resolvedUserId: resolvedUserId.value,
+ selectedConnectedAccountId,
executeOutputDir,
executeParams: {
userId: resolvedUserId.value,
arguments: args,
client,
+ connectedAccounts:
+ toolkitSlug && selectedConnectedAccountId
+ ? {
+ [toolkitSlug]: selectedConnectedAccountId,
+ }
+ : undefined,
cacheScope:
resolvedProject.projectType === 'CONSUMER' && resolvedProject.consumerUserId
? {
@@ -1400,6 +1481,7 @@ const runToolsExecute = (params: RunToolsExecuteParams) =>
toolDebugLog('execute_params', {
slug: params.slug,
userId: context.resolvedUserId,
+ connectedAccountId: context.selectedConnectedAccountId,
arguments: context.args,
projectId: context.resolvedProject.projectId,
orgId: context.resolvedProject.orgId,
@@ -1439,6 +1521,7 @@ const parseParallelExecuteArgs = (
let skipConnectionCheck = false;
let skipToolParamsCheck = false;
let skipChecks = false;
+ let account = Option.none<string>();
let userId = Option.none<string>();
let projectName = Option.none<string>();
const specs: ParallelExecuteSpec[] = [];
@@ -1492,6 +1575,12 @@ const parseParallelExecuteArgs = (
skipChecks = true;
continue;
}
+ if (token === '--account' || token.startsWith('--account=')) {
+ const parsed = readValue(token, i);
+ account = Option.some(parsed.value);
+ i = parsed.nextIndex;
+ continue;
+ }
if (token === '--user-id' || token.startsWith('--user-id=')) {
if (!config.allowUserId) {
throw new Error(`${token} is not supported for this execute command.`);
@@ -1525,6 +1614,7 @@ const parseParallelExecuteArgs = (
currentSpec = {
slug: currentSpec.slug,
data: Option.some(parsed.value),
+ account: currentSpec.account,
};
i = parsed.nextIndex;
continue;
@@ -1537,6 +1627,7 @@ const parseParallelExecuteArgs = (
currentSpec = {
slug: token,
data: Option.none(),
+ account,
};
}
@@ -1559,6 +1650,7 @@ const parseParallelExecuteArgs = (
skipConnectionCheck,
skipToolParamsCheck,
skipChecks,
+ account,
};
};
@@ -1628,6 +1720,7 @@ const runParallelSchemaFetchFromParsed = (params: ParsedParallelExecuteArgs) =>
params.specs,
() =>
resolveSchemaContext({
+ account: params.account,
userId: params.userId,
projectName: params.projectName,
surface: params.surface,
@@ -1725,6 +1818,7 @@ const runParallelToolsExecuteFromParsed = (params: ParsedParallelExecuteArgs) =>
slug: spec.slug,
data: spec.data,
file: Option.none(),
+ account: spec.account,
userId: params.userId,
projectName: params.projectName,
surface: params.surface,
@@ -1906,12 +2000,33 @@ export const runParallelToolsExecuteFromArgv = (argv: ReadonlyArray<string>) =>
export const rootToolsCmd$Execute = Command.make(
'execute',
- { slug, data, file, getSchema, dryRun, skipConnectionCheck, skipToolParamsCheck, skipChecks },
- ({ slug, data, file, getSchema, dryRun, skipConnectionCheck, skipToolParamsCheck, skipChecks }) =>
+ {
+ slug,
+ data,
+ file,
+ account: accountOption,
+ getSchema,
+ dryRun,
+ skipConnectionCheck,
+ skipToolParamsCheck,
+ skipChecks,
+ },
+ ({
+ slug,
+ data,
+ file,
+ account,
+ getSchema,
+ dryRun,
+ skipConnectionCheck,
+ skipToolParamsCheck,
+ skipChecks,
+ }) =>
runToolsExecute({
slug,
data,
file,
+ account,
userId: Option.none(),
projectName: Option.none(),
surface: 'root',
@@ -1930,6 +2045,7 @@ export const rootToolsCmd$Execute = Command.make(
'',
'Examples:',
' composio execute GMAIL_SEND_EMAIL -d \'{ recipient_email: "[email protected]", body: "Hello" }\'',
+ ' composio execute GMAIL_SEND_EMAIL --account default -d \'{ recipient_email: "[email protected]" }\'',
' composio execute SLACK_UPLOAD_OR_CREATE_A_FILE_IN_SLACK --file ./image.png -d \'{ channels: "C123" }\'',
' composio execute --parallel GMAIL_SEND_EMAIL -d \'{ recipient_email: "[email protected]" }\' GITHUB_CREATE_AN_ISSUE -d \'{ owner: "acme", repo: "app", title: "Bug" }\'',
" composio execute GMAIL_SEND_EMAIL --dry-run -d '{ ... }' Preview without executing",
@@ -1937,6 +2053,7 @@ export const rootToolsCmd$Execute = Command.make(
'',
'Flags:',
' --file <path> Inject a local file path into the single file_uploadable input',
+ ' --account <selector> Select connected account by alias, word_id, or account id',
' -p, --parallel Execute repeated TOOL_SLUG -d <json> groups concurrently',
' --skip-connection-check Skip the connected-account check',
' --skip-tool-params-check Skip input validation against cached schema',
@@ -1956,6 +2073,7 @@ export const devToolsCmd$Execute = Command.make(
slug,
data,
file,
+ account: accountOption,
userId,
projectName,
getSchema,
@@ -1968,6 +2086,7 @@ export const devToolsCmd$Execute = Command.make(
slug,
data,
file,
+ account,
userId,
projectName,
getSchema,
@@ -1980,6 +2099,7 @@ export const devToolsCmd$Execute = Command.make(
slug,
data,
file,
+ account,
userId,
projectName,
surface: 'dev',
@@ -1999,12 +2119,14 @@ export const devToolsCmd$Execute = Command.make(
'',
'Examples:',
' composio dev playground-execute GMAIL_SEND_EMAIL -d \'{ recipient_email: "[email protected]", body: "Hello" }\'',
+ ' composio dev playground-execute GMAIL_SEND_EMAIL --account default -d \'{ recipient_email: "[email protected]" }\'',
' composio dev playground-execute SLACK_UPLOAD_OR_CREATE_A_FILE_IN_SLACK --file ./image.png -d \'{ channels: "C123" }\'',
' composio dev playground-execute GMAIL_SEND_EMAIL --dry-run -d \'{ recipient_email: "[email protected]", body: "Hello" }\'',
' composio dev playground-execute GMAIL_SEND_EMAIL --get-schema',
'',
'Flags:',
' --file <path> Inject a local file path into the single file_uploadable input',
+ ' --account <selector> Select connected account by alias, word_id, or account id',
' -p, --parallel Execute repeated TOOL_SLUG -d <json> groups concurrently',
].join('\n')
)
diff --git a/ts/packages/cli/src/effects/create-tool-router-session.ts b/ts/packages/cli/src/effects/create-tool-router-session.ts
index 140d5c61a..adfe12c25 100644
--- a/ts/packages/cli/src/effects/create-tool-router-session.ts
+++ b/ts/packages/cli/src/effects/create-tool-router-session.ts
@@ -2,6 +2,7 @@ import { Effect, Option } from 'effect';
import type { Composio } from '@composio/client';
import {
getFreshConsumerToolRouterAuthConfigsFromCache,
+ getFreshConsumerToolRouterConnectedAccountsFromCache,
writeConsumerConnectedToolkitsCache,
} from 'src/services/consumer-short-term-cache';
import { resolveToolRouterSessionConnections } from 'src/services/tool-router-session-connections';
@@ -16,6 +17,8 @@ export interface CreateToolRouterSessionOptions {
readonly orgId: string;
readonly consumerUserId: string;
};
+ /** Explicit connected-account pins by toolkit slug. */
+ readonly connectedAccounts?: Record<string, string>;
}
/**
@@ -32,6 +35,11 @@ export const createToolRouterSession = (
options?: CreateToolRouterSessionOptions
) =>
Effect.gen(function* () {
+ const mergeConnectedAccounts = (...mappings: Array<Record<string, string> | undefined>) => {
+ const merged = Object.assign({}, ...mappings.filter(Boolean));
+ return Object.keys(merged).length > 0 ? merged : undefined;
+ };
+
const cachedAuthConfigs = options?.cacheScope
? yield* getFreshConsumerToolRouterAuthConfigsFromCache({
orgId: options.cacheScope.orgId,
@@ -39,15 +47,39 @@ export const createToolRouterSession = (
toolkits: options.toolkits,
})
: Option.none();
+ const cachedConnectedAccounts = options?.cacheScope
+ ? yield* getFreshConsumerToolRouterConnectedAccountsFromCache({
+ orgId: options.cacheScope.orgId,
+ consumerUserId: options.cacheScope.consumerUserId,
+ toolkits: options.toolkits,
+ })
+ : Option.none();
const connectionContext = Option.isSome(cachedAuthConfigs)
? {
connectedToolkits: options?.toolkits ?? [],
authConfigs: cachedAuthConfigs.value.authConfigs,
+ connectedAccounts: mergeConnectedAccounts(
+ Option.isSome(cachedConnectedAccounts)
+ ? cachedConnectedAccounts.value.connectedAccounts
+ : undefined,
+ options?.connectedAccounts
+ ),
+ availableConnectedAccounts: Option.isSome(cachedConnectedAccounts)
+ ? cachedConnectedAccounts.value.availableConnectedAccounts
+ : undefined,
}
: yield* resolveToolRouterSessionConnections(client, userId, {
toolkits: options?.toolkits,
- });
+ }).pipe(
+ Effect.map(connectionContext => ({
+ ...connectionContext,
+ connectedAccounts: mergeConnectedAccounts(
+ connectionContext.connectedAccounts,
+ options?.connectedAccounts
+ ),
+ }))
+ );
if (options?.cacheScope && Option.isNone(cachedAuthConfigs)) {
yield* writeConsumerConnectedToolkitsCache({
@@ -57,6 +89,10 @@ export const createToolRouterSession = (
toolRouterAuthConfigs: {
authConfigs: connectionContext.authConfigs,
},
+ toolRouterConnectedAccounts: {
+ connectedAccounts: connectionContext.connectedAccounts,
+ availableConnectedAccounts: connectionContext.availableConnectedAccounts,
+ },
}).pipe(Effect.catchAll(() => Effect.void));
}
@@ -64,6 +100,7 @@ export const createToolRouterSession = (
client.toolRouter.session.create({
user_id: userId,
auth_configs: connectionContext.authConfigs,
+ connected_accounts: connectionContext.connectedAccounts,
manage_connections: { enable: options?.manageConnections ?? false },
toolkits:
options?.toolkits && options.toolkits.length > 0
diff --git a/ts/packages/cli/src/models/connected-accounts.ts b/ts/packages/cli/src/models/connected-accounts.ts
index 9c8674d00..91128e845 100644
--- a/ts/packages/cli/src/models/connected-accounts.ts
+++ b/ts/packages/cli/src/models/connected-accounts.ts
@@ -11,6 +11,8 @@ import { Schema } from 'effect';
*/
export const ConnectedAccountItem = Schema.Struct({
id: Schema.String,
+ word_id: Schema.optional(Schema.NullOr(Schema.String)),
+ alias: Schema.optional(Schema.NullOr(Schema.String)),
status: Schema.Literal('INITIALIZING', 'INITIATED', 'ACTIVE', 'FAILED', 'EXPIRED', 'INACTIVE'),
status_reason: Schema.optionalWith(Schema.NullOr(Schema.String), { default: () => null }),
is_disabled: Schema.Boolean,
diff --git a/ts/packages/cli/src/services/connected-account-selection.ts b/ts/packages/cli/src/services/connected-account-selection.ts
new file mode 100644
index 000000000..6e298d9ba
--- /dev/null
+++ b/ts/packages/cli/src/services/connected-account-selection.ts
@@ -0,0 +1,126 @@
+import type { ConnectedAccountItem } from 'src/models/connected-accounts';
+
+export type CachedConnectedAccountSummary = {
+ readonly id: string;
+ readonly alias: string | null;
+ readonly wordId: string | null;
+ readonly updatedAt: string;
+ readonly createdAt: string;
+};
+
+const normalizeSelector = (value: string): string => value.trim().toLowerCase();
+
+const parseTimestamp = (value: string | undefined): number => {
+ if (!value) return 0;
+ const parsed = Date.parse(value);
+ return Number.isFinite(parsed) ? parsed : 0;
+};
+
+const compareNewestFirst = (
+ left: Pick<ConnectedAccountItem, 'updated_at' | 'created_at'>,
+ right: Pick<ConnectedAccountItem, 'updated_at' | 'created_at'>
+): number =>
+ Math.max(parseTimestamp(right.updated_at), parseTimestamp(right.created_at)) -
+ Math.max(parseTimestamp(left.updated_at), parseTimestamp(left.created_at));
+
+const compareSummaryNewestFirst = (
+ left: Pick<CachedConnectedAccountSummary, 'updatedAt' | 'createdAt'>,
+ right: Pick<CachedConnectedAccountSummary, 'updatedAt' | 'createdAt'>
+): number =>
+ Math.max(parseTimestamp(right.updatedAt), parseTimestamp(right.createdAt)) -
+ Math.max(parseTimestamp(left.updatedAt), parseTimestamp(left.createdAt));
+
+export const isUsableConnectedAccount = (
+ item: Pick<ConnectedAccountItem, 'status' | 'is_disabled'>
+): boolean => item.status === 'ACTIVE' && !item.is_disabled;
+
+export const toCachedConnectedAccountSummary = (
+ item: Pick<ConnectedAccountItem, 'id' | 'alias' | 'word_id' | 'updated_at' | 'created_at'>
+): CachedConnectedAccountSummary => ({
+ id: item.id,
+ alias: item.alias ?? null,
+ wordId: item.word_id ?? null,
+ updatedAt: item.updated_at,
+ createdAt: item.created_at,
+});
+
+export const groupCachedConnectedAccountsByToolkit = (
+ items: ReadonlyArray<ConnectedAccountItem>
+): Record<string, ReadonlyArray<CachedConnectedAccountSummary>> => {
+ const grouped = new Map<string, CachedConnectedAccountSummary[]>();
+
+ for (const item of items) {
+ if (!isUsableConnectedAccount(item)) continue;
+ const toolkit = item.toolkit.slug.trim().toLowerCase();
+ if (!toolkit) continue;
+
+ const next = grouped.get(toolkit) ?? [];
+ next.push(toCachedConnectedAccountSummary(item));
+ grouped.set(toolkit, next);
+ }
+
+ return Object.fromEntries(
+ [...grouped.entries()].map(([toolkit, summaries]) => [
+ toolkit,
+ [...summaries].sort(compareSummaryNewestFirst),
+ ])
+ );
+};
+
+export const resolveDefaultConnectedAccountsByToolkit = (
+ items: ReadonlyArray<ConnectedAccountItem>
+): Record<string, string> => {
+ const grouped = new Map<string, ConnectedAccountItem[]>();
+
+ for (const item of items) {
+ if (!isUsableConnectedAccount(item)) continue;
+ const toolkit = item.toolkit.slug.trim().toLowerCase();
+ if (!toolkit) continue;
+
+ const next = grouped.get(toolkit) ?? [];
+ next.push(item);
+ grouped.set(toolkit, next);
+ }
+
+ return Object.fromEntries(
+ [...grouped.entries()]
+ .map(([toolkit, toolkitItems]) => {
+ const selected = resolveConnectedAccountSelection(toolkitItems);
+ return selected ? ([toolkit, selected.id] as const) : null;
+ })
+ .filter((entry): entry is readonly [string, string] => entry !== null)
+ );
+};
+
+export const resolveConnectedAccountSelection = (
+ items: ReadonlyArray<ConnectedAccountItem>,
+ selector?: string
+): ConnectedAccountItem | undefined => {
+ const usable = items.filter(isUsableConnectedAccount).sort(compareNewestFirst);
+ if (usable.length === 0) return undefined;
+
+ if (!selector || selector.trim().length === 0) {
+ return usable.find(item => normalizeSelector(item.alias ?? '') === 'default') ?? usable[0];
+ }
+
+ const normalized = normalizeSelector(selector);
+ return (
+ usable.find(item => normalizeSelector(item.id) === normalized) ??
+ usable.find(item => normalizeSelector(item.alias ?? '') === normalized) ??
+ usable.find(item => normalizeSelector(item.word_id ?? '') === normalized)
+ );
+};
+
+export const formatConnectedAccountChoice = (
+ item: Pick<ConnectedAccountItem, 'id' | 'alias' | 'word_id'>
+): string => {
+ const labels = [item.alias, item.word_id].filter(
+ (value): value is string => typeof value === 'string' && value.trim().length > 0
+ );
+ return labels.length > 0 ? `${labels.join(' / ')} (${item.id})` : item.id;
+};
+
+export const formatConnectedAccountChoices = (
+ items: ReadonlyArray<ConnectedAccountItem>
+): ReadonlyArray<string> =>
+ items.filter(isUsableConnectedAccount).sort(compareNewestFirst).map(formatConnectedAccountChoice);
diff --git a/ts/packages/cli/src/services/consumer-short-term-cache.ts b/ts/packages/cli/src/services/consumer-short-term-cache.ts
index 45737d6ed..92d725fd2 100644
--- a/ts/packages/cli/src/services/consumer-short-term-cache.ts
+++ b/ts/packages/cli/src/services/consumer-short-term-cache.ts
@@ -10,6 +10,7 @@ import {
getConsumerConnectedToolkits,
resolveConsumerProject,
} from 'src/services/composio-clients';
+import type { CachedConnectedAccountSummary } from 'src/services/connected-account-selection';
import { resolveCommandProject } from 'src/services/command-project';
import { resolveToolRouterSessionConnections } from 'src/services/tool-router-session-connections';
import { ComposioUserContext } from 'src/services/user-context';
@@ -22,10 +23,19 @@ export type ConsumerToolRouterAuthConfigMappings = {
readonly authConfigs?: Record<string, string>;
};
+export type ConsumerToolRouterConnectedAccountMappings = {
+ readonly connectedAccounts?: Record<string, string>;
+ readonly availableConnectedAccounts?: Record<
+ string,
+ ReadonlyArray<CachedConnectedAccountSummary>
+ >;
+};
+
type CacheEntry = {
readonly toolkits: ReadonlyArray<string>;
readonly expiresAt: string;
readonly toolRouterAuthConfigs?: ConsumerToolRouterAuthConfigMappings;
+ readonly toolRouterConnectedAccounts?: ConsumerToolRouterConnectedAccountMappings;
readonly probablyMyCliSessionsByCwdHash?: Record<
string,
{
@@ -164,6 +174,70 @@ const mergeAuthConfigMappings = (params: {
});
};
+const normalizeConnectedAccountMappings = (
+ mappings?: ConsumerToolRouterConnectedAccountMappings
+): ConsumerToolRouterConnectedAccountMappings | undefined => {
+ if (!mappings) return undefined;
+
+ const connectedAccounts = Object.fromEntries(
+ Object.entries(mappings.connectedAccounts ?? {})
+ .map(([toolkit, connectedAccountId]) => [toolkit.toLowerCase(), connectedAccountId])
+ .filter(
+ ([, connectedAccountId]) =>
+ typeof connectedAccountId === 'string' && connectedAccountId.length > 0
+ )
+ );
+
+ const availableConnectedAccounts = Object.fromEntries(
+ Object.entries(mappings.availableConnectedAccounts ?? {})
+ .map(([toolkit, accounts]) => [
+ toolkit.toLowerCase(),
+ accounts.filter(
+ account =>
+ typeof account.id === 'string' &&
+ account.id.length > 0 &&
+ typeof account.updatedAt === 'string' &&
+ typeof account.createdAt === 'string'
+ ),
+ ])
+ .filter(([, accounts]) => accounts.length > 0)
+ );
+
+ if (
+ Object.keys(connectedAccounts).length === 0 &&
+ Object.keys(availableConnectedAccounts).length === 0
+ ) {
+ return undefined;
+ }
+
+ return {
+ connectedAccounts: Object.keys(connectedAccounts).length > 0 ? connectedAccounts : undefined,
+ availableConnectedAccounts:
+ Object.keys(availableConnectedAccounts).length > 0 ? availableConnectedAccounts : undefined,
+ };
+};
+
+const mergeConnectedAccountMappings = (params: {
+ readonly current?: ConsumerToolRouterConnectedAccountMappings;
+ readonly next?: ConsumerToolRouterConnectedAccountMappings;
+}) => {
+ const current = normalizeConnectedAccountMappings(params.current);
+ const next = normalizeConnectedAccountMappings(params.next);
+ if (!current) return next;
+ if (!next) return current;
+
+ return normalizeConnectedAccountMappings({
+ connectedAccounts: {
+ ...(current.connectedAccounts ?? {}),
+ ...(next.connectedAccounts ?? {}),
+ },
+ availableConnectedAccounts: {
+ ...(current.availableConnectedAccounts ?? {}),
+ ...(next.availableConnectedAccounts ?? {}),
+ },
+ });
+};
+
export const getFreshConsumerConnectedToolkitsFromCache = (params: {
orgId: string;
consumerUserId: string;
@@ -232,6 +306,65 @@ export const getFreshConsumerToolRouterAuthConfigsFromCache = (params: {
return filtered ? Option.some(filtered) : Option.none<ConsumerToolRouterAuthConfigMappings>();
});
+export const getFreshConsumerToolRouterConnectedAccountsFromCache = (params: {
+ orgId: string;
+ consumerUserId: string;
+ toolkits?: ReadonlyArray<string>;
+}) =>
+ Effect.gen(function* () {
+ const disabled = yield* APP_CONFIG.DISABLE_CONNECTED_ACCOUNT_CACHE;
+ if (disabled) {
+ return Option.none<ConsumerToolRouterConnectedAccountMappings>();
+ }
+ const state = yield* readCache();
+ const entry = state[cacheKey(params.orgId, params.consumerUserId)];
+ if (!entry) {
+ return Option.none<ConsumerToolRouterConnectedAccountMappings>();
+ }
+ const expiresAtMs = Date.parse(entry.expiresAt);
+ if (!Number.isFinite(expiresAtMs) || expiresAtMs <= Date.now()) {
+ return Option.none<ConsumerToolRouterConnectedAccountMappings>();
+ }
+
+ const mappings = normalizeConnectedAccountMappings(entry.toolRouterConnectedAccounts);
+ if (!mappings) {
+ return Option.none<ConsumerToolRouterConnectedAccountMappings>();
+ }
+
+ if (!params.toolkits || params.toolkits.length === 0) {
+ return Option.some(mappings);
+ }
+
+ const requestedToolkits = params.toolkits.map(toolkit => toolkit.toLowerCase());
+ const filteredConnectedAccounts = requestedToolkits.reduce<Record<string, string>>(
+ (acc, toolkit) => {
+ const connectedAccountId = mappings.connectedAccounts?.[toolkit];
+ if (typeof connectedAccountId === 'string') {
+ acc[toolkit] = connectedAccountId;
+ }
+ return acc;
+ },
+ {}
+ );
+ const filteredAvailableConnectedAccounts = requestedToolkits.reduce<
+ Record<string, ReadonlyArray<CachedConnectedAccountSummary>>
+ >((acc, toolkit) => {
+ const accounts = mappings.availableConnectedAccounts?.[toolkit];
+ if (Array.isArray(accounts) && accounts.length > 0) {
+ acc[toolkit] = accounts;
+ }
+ return acc;
+ }, {});
+ const filtered = normalizeConnectedAccountMappings({
+ connectedAccounts: filteredConnectedAccounts,
+ availableConnectedAccounts: filteredAvailableConnectedAccounts,
+ });
+
+ return filtered
+ ? Option.some(filtered)
+ : Option.none<ConsumerToolRouterConnectedAccountMappings>();
+ });
+
export const invalidateConsumerConnectedToolkitsCache = () =>
Effect.gen(function* () {
const fs = yield* FileSystem.FileSystem;
@@ -350,6 +483,15 @@ export const refreshConsumerConnectedToolkitsCache = (params?: {
}
: undefined,
}),
+ toolRouterConnectedAccounts: mergeConnectedAccountMappings({
+ current: currentEntry?.toolRouterConnectedAccounts,
+ next: Option.isSome(directToolkits)
+ ? {
+ connectedAccounts: directToolkits.value.connectedAccounts,
+ availableConnectedAccounts: directToolkits.value.availableConnectedAccounts,
+ }
+ : undefined,
+ }),
...searchSessionFields,
},
});
@@ -360,6 +502,7 @@ export const writeConsumerConnectedToolkitsCache = (params: {
readonly consumerUserId: string;
readonly toolkits: ReadonlyArray<string>;
readonly toolRouterAuthConfigs?: ConsumerToolRouterAuthConfigMappings;
+ readonly toolRouterConnectedAccounts?: ConsumerToolRouterConnectedAccountMappings;
}) =>
Effect.gen(function* () {
const disabled = yield* APP_CONFIG.DISABLE_CONNECTED_ACCOUNT_CACHE;
@@ -377,12 +520,19 @@ export const writeConsumerConnectedToolkitsCache = (params: {
yield* writeCache({
...state,
[key]: {
- toolkits: normalizeCachedToolkits(params.toolkits, noAuthToolkits),
+ toolkits: normalizeCachedToolkits(
+ [...(currentEntry?.toolkits ?? []), ...params.toolkits],
+ noAuthToolkits
+ ),
expiresAt: new Date(Date.now() + CACHE_TTL_MS).toISOString(),
toolRouterAuthConfigs: mergeAuthConfigMappings({
current: currentEntry?.toolRouterAuthConfigs,
next: params.toolRouterAuthConfigs,
}),
+ toolRouterConnectedAccounts: mergeConnectedAccountMappings({
+ current: currentEntry?.toolRouterConnectedAccounts,
+ next: params.toolRouterConnectedAccounts,
+ }),
...searchSessionFields,
},
});
@@ -429,6 +579,8 @@ export const getOrCreateProbablyMyCliSessionIdForCurrentCwd = (params?: {
[key]: {
toolkits: currentEntry?.toolkits ?? [],
expiresAt: currentEntry?.expiresAt ?? new Date(Date.now() + CACHE_TTL_MS).toISOString(),
+ toolRouterAuthConfigs: currentEntry?.toolRouterAuthConfigs,
+ toolRouterConnectedAccounts: currentEntry?.toolRouterConnectedAccounts,
...searchSessionFields,
},
});
diff --git a/ts/packages/cli/src/services/run-helpers-runtime.ts b/ts/packages/cli/src/services/run-helpers-runtime.ts
index 0fa61f910..3b982db31 100644
--- a/ts/packages/cli/src/services/run-helpers-runtime.ts
+++ b/ts/packages/cli/src/services/run-helpers-runtime.ts
@@ -79,7 +79,7 @@ type RunGlobalScope = typeof globalThis & {
z: typeof z;
zod: typeof z;
search: (query: string, options?: Record<string, unknown>) => Promise<RunCliResult>;
- execute: (slug: string, data?: unknown) => Promise<RunCliResult>;
+ execute: (slug: string, data?: unknown, options?: { account?: string }) => Promise<RunCliResult>;
experimental_subAgent: (prompt: string, options?: Record<string, unknown>) => Promise<unknown>;
invokeAgent: (prompt: string, options?: Record<string, unknown>) => Promise<unknown>;
proxy: (
@@ -754,13 +754,20 @@ export const installRunHelpers = async ({
return runCliJson(args);
};
- runGlobals.execute = async (slug, data = {}) => {
- helperDebugLog('execute.prepare', { slug, hasData: data !== undefined });
+ runGlobals.execute = async (slug, data = {}, options = {}) => {
+ helperDebugLog('execute.prepare', {
+ slug,
+ hasData: data !== undefined,
+ account: options.account ?? null,
+ });
const args = ['execute', slug];
if (helperContext.dryRun === true) args.push('--dry-run');
if (helperContext.skipConnectionCheck === true) args.push('--skip-connection-check');
if (helperContext.skipToolParamsCheck === true) args.push('--skip-tool-params-check');
if (helperContext.skipChecks === true) args.push('--skip-checks');
+ if (typeof options.account === 'string' && options.account.trim().length > 0) {
+ args.push('--account', options.account.trim());
+ }
if (data !== undefined) {
const preparedData = await materializeExecutePayload(data);
const serialized =
diff --git a/ts/packages/cli/src/services/tool-router-session-connections.ts b/ts/packages/cli/src/services/tool-router-session-connections.ts
index 1b53539ee..2a727d56a 100644
--- a/ts/packages/cli/src/services/tool-router-session-connections.ts
+++ b/ts/packages/cli/src/services/tool-router-session-connections.ts
@@ -1,8 +1,18 @@
import { Effect } from 'effect';
import type { Composio } from '@composio/client';
+import {
+ groupCachedConnectedAccountsByToolkit,
+ resolveDefaultConnectedAccountsByToolkit,
+} from 'src/services/connected-account-selection';
+import type { ConnectedAccountItem } from 'src/models/connected-accounts';
type RawConnectedAccount = {
readonly id: string;
+ readonly alias?: string | null;
+ readonly word_id?: string | null;
+ readonly is_disabled?: boolean | null;
+ readonly status?: string | null;
+ readonly user_id?: string | null;
readonly toolkit?: {
readonly slug?: string | null;
} | null;
@@ -17,6 +27,17 @@ type RawConnectedAccount = {
export type ToolRouterSessionConnectionContext = {
readonly connectedToolkits: ReadonlyArray<string>;
readonly authConfigs?: Record<string, string>;
+ readonly connectedAccounts?: Record<string, string>;
+ readonly availableConnectedAccounts?: Record<
+ string,
+ ReadonlyArray<{
+ readonly id: string;
+ readonly alias: string | null;
+ readonly wordId: string | null;
+ readonly updatedAt: string;
+ readonly createdAt: string;
+ }>
+ >;
};
const parseTimestamp = (value?: string | null): number => {
@@ -25,6 +46,22 @@ const parseTimestamp = (value?: string | null): number => {
return Number.isFinite(parsed) ? parsed : 0;
};
+const normalizeConnectedAccountStatus = (
+ status?: string | null
+): ConnectedAccountItem['status'] => {
+ switch (status) {
+ case 'INITIALIZING':
+ case 'INITIATED':
+ case 'ACTIVE':
+ case 'FAILED':
+ case 'EXPIRED':
+ case 'INACTIVE':
+ return status;
+ default:
+ return 'INACTIVE';
+ }
+};
+
const isNewerAccount = (candidate: RawConnectedAccount, current: RawConnectedAccount): boolean => {
const candidateTimestamp = Math.max(
parseTimestamp(candidate.updated_at),
@@ -55,12 +92,36 @@ export const resolveToolRouterSessionConnections = (
).pipe(
Effect.map(response => {
const items = (response.items ?? []) as ReadonlyArray<RawConnectedAccount>;
+ const normalizedItems: ConnectedAccountItem[] = items.map(
+ item =>
+ ({
+ id: item.id,
+ alias: item.alias ?? null,
+ word_id: item.word_id ?? null,
+ status: normalizeConnectedAccountStatus(item.status),
+ status_reason: null,
+ is_disabled: item.is_disabled ?? false,
+ user_id: item.user_id ?? '',
+ toolkit: {
+ slug: item.toolkit?.slug ?? '',
+ },
+ auth_config: {
+ id: item.auth_config?.id ?? '',
+ auth_scheme: '',
+ is_composio_managed: item.auth_config?.is_composio_managed ?? true,
+ is_disabled: false,
+ },
+ created_at: item.created_at ?? '',
+ updated_at: item.updated_at ?? '',
+ test_request_endpoint: '',
+ }) satisfies ConnectedAccountItem
+ );
const connectedToolkits = new Set<string>();
const explicitAccountsByToolkit = new Map<string, RawConnectedAccount>();
for (const item of items) {
const toolkit = item.toolkit?.slug?.toLowerCase().trim();
- if (!toolkit) continue;
+ if (!toolkit || item.is_disabled) continue;
connectedToolkits.add(toolkit);
@@ -87,12 +148,22 @@ export const resolveToolRouterSessionConnections = (
return {
connectedToolkits: [...connectedToolkits],
authConfigs: Object.keys(authConfigs).length > 0 ? authConfigs : undefined,
+ connectedAccounts: (() => {
+ const selected = resolveDefaultConnectedAccountsByToolkit(normalizedItems);
+ return Object.keys(selected).length > 0 ? selected : undefined;
+ })(),
+ availableConnectedAccounts: (() => {
+ const grouped = groupCachedConnectedAccountsByToolkit(normalizedItems);
+ return Object.keys(grouped).length > 0 ? grouped : undefined;
+ })(),
} satisfies ToolRouterSessionConnectionContext;
}),
Effect.catchAll(() =>
Effect.succeed({
connectedToolkits: [],
authConfigs: undefined,
+ connectedAccounts: undefined,
+ availableConnectedAccounts: undefined,
} satisfies ToolRouterSessionConnectionContext)
)
);
diff --git a/ts/packages/cli/src/services/tools-executor.ts b/ts/packages/cli/src/services/tools-executor.ts
index 1b1e133fc..bc2a21b6f 100644
--- a/ts/packages/cli/src/services/tools-executor.ts
+++ b/ts/packages/cli/src/services/tools-executor.ts
@@ -26,6 +26,7 @@ export interface ToolExecuteParams {
readonly userId: string;
readonly arguments: Record<string, unknown>;
readonly client?: Composio;
+ readonly connectedAccounts?: Record<string, string>;
readonly cacheScope?: {
readonly orgId: string;
readonly consumerUserId: string;
@@ -137,6 +138,7 @@ export const ToolsExecutorLive = Layer.effect(
// One session per invocation — CLI runs one tool per process.
const sessionId = yield* createToolRouterSession(resolvedClient, params.userId, {
manageConnections: true,
+ connectedAccounts: params.connectedAccounts,
cacheScope: params.cacheScope,
});
const normalizedArguments = isMetaToolSlug(slug)
diff --git a/ts/packages/cli/test/__utils__/services/test-layer.ts b/ts/packages/cli/test/__utils__/services/test-layer.ts
index 08eeab0ee..a98190b3b 100644
--- a/ts/packages/cli/test/__utils__/services/test-layer.ts
+++ b/ts/packages/cli/test/__utils__/services/test-layer.ts
@@ -106,6 +106,7 @@ export interface TestLiveInput {
connectedAccountsData?: {
items?: ConnectedAccountItem[];
linkResponse?: LinkCreateResponse;
+ onPatch?: (params: { path: string; body: Record<string, unknown> | undefined }) => void;
};
/**
@@ -949,6 +950,28 @@ export const TestLayer = (input?: TestLiveInput) =>
return response;
},
},
+ patch: async (path: string, options?: { body?: Record<string, unknown> }) => {
+ connectedAccountsData.onPatch?.({ path, body: options?.body });
+
+ const match = path.match(/^\/api\/v3\/connected_accounts\/([^/]+)$/);
+ if (!match) {
+ throw new Error(`Unhandled PATCH path "${path}"`);
+ }
+
+ const connectedAccountId = match[1];
+ const account = connectedAccountsData.items.find(item => item.id === connectedAccountId);
+ if (!account) {
+ throw new Error(`Connected account "${connectedAccountId}" not found`);
+ }
+
+ if (typeof options?.body?.alias === 'string') {
+ Object.assign(account as { alias?: string | null }, {
+ alias: options.body.alias,
+ });
+ }
+
+ return account;
+ },
connectedAccounts: {
list: async (params?: {
toolkit_slugs?: string[];
diff --git a/ts/packages/cli/test/src/commands/connected-accounts/connected-accounts.link.cmd.test.ts b/ts/packages/cli/test/src/commands/connected-accounts/connected-accounts.link.cmd.test.ts
index 1a81aa677..eee2c6ea3 100644
--- a/ts/packages/cli/test/src/commands/connected-accounts/connected-accounts.link.cmd.test.ts
+++ b/ts/packages/cli/test/src/commands/connected-accounts/connected-accounts.link.cmd.test.ts
@@ -17,29 +17,33 @@ const extractJsonObject = (output: string): Record<string, unknown> | null => {
return jsonMatch ? JSON.parse(jsonMatch[0]) : null;
};
-const testConnectedAccounts: ConnectedAccountItem[] = [
- {
- id: 'con_test_link',
- status: 'ACTIVE',
- status_reason: null,
+const makeConnectedAccount = (overrides?: Partial<ConnectedAccountItem>): ConnectedAccountItem => ({
+ id: 'con_test_link',
+ alias: 'default',
+ word_id: 'castle',
+ status: 'ACTIVE',
+ status_reason: null,
+ is_disabled: false,
+ user_id: 'consumer-user-org_test',
+ toolkit: { slug: 'gmail' },
+ auth_config: {
+ id: 'ac_gmail_oauth',
+ auth_scheme: 'OAUTH2',
+ is_composio_managed: true,
is_disabled: false,
- user_id: 'default',
- toolkit: { slug: 'gmail' },
- auth_config: {
- id: 'ac_gmail_oauth',
- auth_scheme: 'OAUTH2',
- is_composio_managed: true,
- is_disabled: false,
- },
- created_at: '2026-01-01T00:00:00Z',
- updated_at: '2026-01-15T00:00:00Z',
- test_request_endpoint: '',
},
-];
+ created_at: '2026-01-01T00:00:00Z',
+ updated_at: '2026-01-15T00:00:00Z',
+ test_request_endpoint: '',
+ ...overrides,
+});
-const connectedAccountsData = {
- items: testConnectedAccounts,
-} satisfies TestLiveInput['connectedAccountsData'];
+const makeConnectedAccountsData = (
+ overrides?: Partial<NonNullable<TestLiveInput['connectedAccountsData']>>
+): NonNullable<TestLiveInput['connectedAccountsData']> => ({
+ items: [makeConnectedAccount()],
+ ...overrides,
+});
const testConfigProvider = ConfigProvider.fromMap(
new Map([['COMPOSIO_USER_API_KEY', 'test_api_key']])
@@ -76,6 +80,8 @@ const RecordingTerminalUI = TerminalUI.of({
});
describe('CLI: composio dev connected-accounts link', () => {
+ const aliasPatchSpy = vi.fn();
+
afterEach(() => {
vi.clearAllMocks();
});
@@ -83,7 +89,7 @@ describe('CLI: composio dev connected-accounts link', () => {
layer(
TestLive({
baseConfigProvider: testConfigProvider,
- connectedAccountsData,
+ connectedAccountsData: makeConnectedAccountsData(),
fixture: 'global-test-user-id',
})
)('[Given] valid toolkit link [Then] creates link and waits (default)', it => {
@@ -105,7 +111,51 @@ describe('CLI: composio dev connected-accounts link', () => {
layer(
TestLive({
baseConfigProvider: testConfigProvider,
- connectedAccountsData,
+ connectedAccountsData: makeConnectedAccountsData(),
+ fixture: 'global-test-user-id',
+ })
+ )('[Given] --list [Then] it shows existing accounts without opening a new link', it => {
+ it.scoped('lists alias and word_id for existing accounts', () =>
+ Effect.gen(function* () {
+ yield* cli(['link', 'gmail', '--list']);
+ const lines = yield* MockConsole.getLines({ stripAnsi: true });
+ const output = lines.join('\n');
+
+ expect(output).toContain('default');
+ expect(output).toContain('castle');
+ expect(output).toContain('"toolkit": "gmail"');
+ expect(vi.mocked(open)).not.toHaveBeenCalled();
+ })
+ );
+ });
+
+ layer(
+ TestLive({
+ baseConfigProvider: testConfigProvider,
+ connectedAccountsData: makeConnectedAccountsData(),
+ fixture: 'global-test-user-id',
+ })
+ )(
+ '[Given] dev connected-accounts link --list without developer project context [Then] it still uses consumer resolution',
+ it => {
+ it.scoped('lists connected accounts instead of requiring a developer project', () =>
+ Effect.gen(function* () {
+ yield* cli(['dev', 'connected-accounts', 'link', 'gmail', '--list']);
+ const lines = yield* MockConsole.getLines({ stripAnsi: true });
+ const output = lines.join('\n');
+
+ expect(output).toContain('default');
+ expect(output).toContain('castle');
+ expect(output).not.toContain('MissingDeveloperProjectError');
+ })
+ );
+ }
+ );
+
+ layer(
+ TestLive({
+ baseConfigProvider: testConfigProvider,
+ connectedAccountsData: makeConnectedAccountsData(),
fixture: 'global-test-user-id',
terminalUI: RecordingTerminalUI,
})
@@ -134,7 +184,7 @@ describe('CLI: composio dev connected-accounts link', () => {
layer(
TestLive({
baseConfigProvider: testConfigProvider,
- connectedAccountsData,
+ connectedAccountsData: makeConnectedAccountsData(),
fixture: 'global-test-user-id',
terminalUI: RecordingTerminalUI,
})
@@ -174,7 +224,7 @@ describe('CLI: composio dev connected-accounts link', () => {
layer(
TestLive({
baseConfigProvider: testConfigProvider,
- connectedAccountsData,
+ connectedAccountsData: makeConnectedAccountsData(),
fixture: 'global-test-user-id',
})
)('[Given] composio link [Then] works for consumer toolkit linking', it => {
@@ -194,7 +244,7 @@ describe('CLI: composio dev connected-accounts link', () => {
layer(
TestLive({
baseConfigProvider: testConfigProvider,
- connectedAccountsData,
+ connectedAccountsData: makeConnectedAccountsData(),
fixture: 'global-test-user-id',
})
)('[Given] --no-wait [Then] outputs valid JSON parseable by jq', it => {
@@ -215,7 +265,7 @@ describe('CLI: composio dev connected-accounts link', () => {
layer(
TestLive({
baseConfigProvider: testConfigProvider,
- connectedAccountsData,
+ connectedAccountsData: makeConnectedAccountsData(),
fixture: 'global-test-user-id',
toolRouter: {
link: async () => ({
@@ -244,7 +294,7 @@ describe('CLI: composio dev connected-accounts link', () => {
layer(
TestLive({
baseConfigProvider: testConfigProvider,
- connectedAccountsData,
+ connectedAccountsData: makeConnectedAccountsData(),
fixture: 'global-test-user-id',
})
)('[Given] default (wait) [Then] waits for ACTIVE and outputs success JSON for jq', it => {
@@ -263,4 +313,58 @@ describe('CLI: composio dev connected-accounts link', () => {
})
);
});
+
+ layer(
+ TestLive({
+ baseConfigProvider: testConfigProvider,
+ connectedAccountsData: makeConnectedAccountsData({
+ items: [makeConnectedAccount({ status: 'INITIATED' })],
+ onPatch: params => {
+ aliasPatchSpy(params);
+ },
+ }),
+ fixture: 'global-test-user-id',
+ })
+ )('[Given] --alias [Then] it patches the created connected account alias', it => {
+ it.scoped('updates the connected account alias through the patch API', () =>
+ Effect.gen(function* () {
+ yield* cli(['link', 'gmail', '--alias', 'work', '--no-wait']);
+
+ expect(aliasPatchSpy).toHaveBeenCalledWith({
+ path: '/api/v3/connected_accounts/con_test_link',
+ body: { alias: 'work' },
+ });
+ })
+ );
+ });
+
+ layer(
+ TestLive({
+ baseConfigProvider: testConfigProvider,
+ connectedAccountsData: makeConnectedAccountsData(),
+ toolRouter: {
+ link: async () => ({
+ connected_account_id: 'con_second_link',
+ link_token: 'lt_test_token',
+ redirect_url: 'https://app.composio.dev/link?token=lt_test_token',
+ }),
+ },
+ fixture: 'global-test-user-id',
+ })
+ )(
+ '[Given] an existing active account and no --alias [Then] link blocks the second connected account',
+ it => {
+ it.scoped('fails locally and tells the user to pass --alias', () =>
+ Effect.gen(function* () {
+ yield* cli(['link', 'gmail']);
+ const lines = yield* MockConsole.getLines({ stripAnsi: true });
+ const output = lines.join('\n');
+
+ expect(output).toContain('Pass --alias to create another one');
+ expect(output).toContain('con_test_link');
+ expect(output).not.toContain('"status": "success"');
+ })
+ );
+ }
+ );
});
diff --git a/ts/packages/cli/test/src/commands/tools/tools.execute.cmd.test.ts b/ts/packages/cli/test/src/commands/tools/tools.execute.cmd.test.ts
index 47d2c4619..ef5c10634 100644
--- a/ts/packages/cli/test/src/commands/tools/tools.execute.cmd.test.ts
+++ b/ts/packages/cli/test/src/commands/tools/tools.execute.cmd.test.ts
@@ -93,6 +93,215 @@ describe('CLI: composio execute', () => {
);
});
+ layer(
+ TestLive({
+ baseConfigProvider: testConfigProvider,
+ fixture: 'global-test-user-id',
+ stdin: { isTTY: true, data: '' },
+ toolsExecutor: {
+ respondWith: {
+ data: {
+ content: 'token '.repeat(20_000),
+ },
+ error: null,
+ successful: true,
+ logId: 'log_large_output',
+ },
+ },
+ })
+ )(
+ '[Given] a large execution response during composio run [Then] it stays inline instead of storing a temp file',
+ it => {
+ it.scoped('returns the full JSON payload when invocation origin is run', () =>
+ Effect.gen(function* () {
+ vi.stubEnv('COMPOSIO_CLI_INVOCATION_ORIGIN', 'run');
+
+ yield* cli(['execute', 'GMAIL_SEND_EMAIL', '-d', '{"recipient":"a"}']);
+ const lines = yield* MockConsole.getLines({ stripAnsi: true });
+ const output = parseLastJson(lines) as unknown as {
+ successful: boolean;
+ storedInFile?: boolean;
+ outputFilePath?: string;
+ data: {
+ content: string;
+ };
+ };
+
+ expect(output.successful).toBe(true);
+ expect(output.storedInFile).not.toBe(true);
+ expect(output.outputFilePath).toBeUndefined();
+ expect(output.data.content).toContain('token token token');
+ })
+ );
+ }
+ );
+
+ layer(
+ TestLive({
+ baseConfigProvider: testConfigProvider,
+ fixture: 'global-test-user-id',
+ stdin: { isTTY: true, data: '' },
+ connectedAccountsData: {
+ items: [
+ {
+ id: 'con_gmail_default',
+ alias: 'default',
+ word_id: 'castle',
+ status: 'ACTIVE',
+ status_reason: null,
+ is_disabled: false,
+ user_id: 'consumer-user-org_test',
+ toolkit: { slug: 'gmail' },
+ auth_config: {
+ id: 'ac_gmail_oauth',
+ auth_scheme: 'OAUTH2',
+ is_composio_managed: true,
+ is_disabled: false,
+ },
+ created_at: '2026-01-01T00:00:00.000Z',
+ updated_at: '2026-01-01T00:00:00.000Z',
+ test_request_endpoint: '',
+ },
+ {
+ id: 'con_gmail_secondary',
+ alias: 'work',
+ word_id: 'forest',
+ status: 'ACTIVE',
+ status_reason: null,
+ is_disabled: false,
+ user_id: 'consumer-user-org_test',
+ toolkit: { slug: 'gmail' },
+ auth_config: {
+ id: 'ac_gmail_oauth',
+ auth_scheme: 'OAUTH2',
+ is_composio_managed: true,
+ is_disabled: false,
+ },
+ created_at: '2026-01-02T00:00:00.000Z',
+ updated_at: '2026-01-02T00:00:00.000Z',
+ test_request_endpoint: '',
+ },
+ ],
+ },
+ toolRouter: {
+ create: async params => {
+ recordedSessionCreateParams.push(params as unknown as Record<string, unknown>);
+ return {
+ session_id: 'trs_gmail_default_session',
+ config: { user_id: params.user_id },
+ mcp: { type: 'http' as const, url: 'https://mcp.test.composio.dev' },
+ tool_router_tools: ['COMPOSIO_SEARCH_TOOLS', 'COMPOSIO_MANAGE_CONNECTIONS'],
+ };
+ },
+ execute: async (_sessionId, params) => ({
+ data: { tool_slug: params.tool_slug, arguments: params.arguments },
+ error: null,
+ log_id: 'log_gmail_default',
+ }),
+ },
+ })
+ )('[Given] default alias exists [Then] execute pins the default connected account', it => {
+ it.scoped('passes connected_accounts with the default alias account', () =>
+ Effect.gen(function* () {
+ yield* cli([
+ 'execute',
+ 'GMAIL_SEND_EMAIL',
+ '--skip-connection-check',
+ '-d',
+ '{"recipient":"a"}',
+ ]);
+
+ expect(recordedSessionCreateParams[0]?.connected_accounts).toEqual({
+ gmail: 'con_gmail_default',
+ });
+ })
+ );
+ });
+
+ layer(
+ TestLive({
+ baseConfigProvider: testConfigProvider,
+ fixture: 'global-test-user-id',
+ stdin: { isTTY: true, data: '' },
+ connectedAccountsData: {
+ items: [
+ {
+ id: 'con_gmail_default',
+ alias: 'default',
+ word_id: 'castle',
+ status: 'ACTIVE',
+ status_reason: null,
+ is_disabled: false,
+ user_id: 'consumer-user-org_test',
+ toolkit: { slug: 'gmail' },
+ auth_config: {
+ id: 'ac_gmail_oauth',
+ auth_scheme: 'OAUTH2',
+ is_composio_managed: true,
+ is_disabled: false,
+ },
+ created_at: '2026-01-01T00:00:00.000Z',
+ updated_at: '2026-01-01T00:00:00.000Z',
+ test_request_endpoint: '',
+ },
+ {
+ id: 'con_gmail_secondary',
+ alias: 'work',
+ word_id: 'forest',
+ status: 'ACTIVE',
+ status_reason: null,
+ is_disabled: false,
+ user_id: 'consumer-user-org_test',
+ toolkit: { slug: 'gmail' },
+ auth_config: {
+ id: 'ac_gmail_oauth',
+ auth_scheme: 'OAUTH2',
+ is_composio_managed: true,
+ is_disabled: false,
+ },
+ created_at: '2026-01-02T00:00:00.000Z',
+ updated_at: '2026-01-02T00:00:00.000Z',
+ test_request_endpoint: '',
+ },
+ ],
+ },
+ toolRouter: {
+ create: async params => {
+ recordedSessionCreateParams.push(params as unknown as Record<string, unknown>);
+ return {
+ session_id: 'trs_gmail_explicit_session',
+ config: { user_id: params.user_id },
+ mcp: { type: 'http' as const, url: 'https://mcp.test.composio.dev' },
+ tool_router_tools: ['COMPOSIO_SEARCH_TOOLS', 'COMPOSIO_MANAGE_CONNECTIONS'],
+ };
+ },
+ execute: async (_sessionId, params) => ({
+ data: { tool_slug: params.tool_slug, arguments: params.arguments },
+ error: null,
+ log_id: 'log_gmail_explicit',
+ }),
+ },
+ })
+ )('[Given] --account selector [Then] execute pins the matched connected account', it => {
+ it.scoped('matches by alias, word_id, or id', () =>
+ Effect.gen(function* () {
+ yield* cli([
+ 'execute',
+ 'GMAIL_SEND_EMAIL',
+ '--account',
+ 'forest',
+ '--skip-connection-check',
+ '-d',
+ '{"recipient":"a"}',
+ ]);
+
+ expect(recordedSessionCreateParams[0]?.connected_accounts).toEqual({
+ gmail: 'con_gmail_secondary',
+ });
+ })
+ );
+ });
+
layer(
TestLive({
baseConfigProvider: testConfigProvider,
@@ -157,7 +366,9 @@ describe('CLI: composio execute', () => {
expect(recordedSessionCreateParams[0]?.auth_configs).toEqual({
posthog: 'ac_posthog_custom',
});
- expect(recordedSessionCreateParams[0]?.connected_accounts).toBeUndefined();
+ expect(recordedSessionCreateParams[0]?.connected_accounts).toEqual({
+ posthog: 'con_posthog_active',
+ });
})
);
}
diff --git a/ts/packages/cli/test/src/services/connected-account-selection.test.ts b/ts/packages/cli/test/src/services/connected-account-selection.test.ts
new file mode 100644
index 000000000..6bf12801b
--- /dev/null
+++ b/ts/packages/cli/test/src/services/connected-account-selection.test.ts
@@ -0,0 +1,96 @@
+import { describe, expect, it } from 'vitest';
+import {
+ formatConnectedAccountChoices,
+ groupCachedConnectedAccountsByToolkit,
+ resolveConnectedAccountSelection,
+ resolveDefaultConnectedAccountsByToolkit,
+} from 'src/services/connected-account-selection';
+import type { ConnectedAccountItem } from 'src/models/connected-accounts';
+
+const makeAccount = (overrides: Partial<ConnectedAccountItem>): ConnectedAccountItem => ({
+ id: 'con_default',
+ alias: null,
+ word_id: null,
+ status: 'ACTIVE',
+ status_reason: null,
+ is_disabled: false,
+ user_id: 'default',
+ toolkit: { slug: 'gmail' },
+ auth_config: {
+ id: 'ac_gmail',
+ auth_scheme: 'OAUTH2',
+ is_composio_managed: true,
+ is_disabled: false,
+ },
+ created_at: '2026-01-01T00:00:00.000Z',
+ updated_at: '2026-01-01T00:00:00.000Z',
+ test_request_endpoint: '',
+ ...overrides,
+});
+
+describe('connected-account-selection', () => {
+ it('prefers alias=default when no selector is provided', () => {
+ const selected = resolveConnectedAccountSelection([
+ makeAccount({
+ id: 'con_newer',
+ updated_at: '2026-01-03T00:00:00.000Z',
+ }),
+ makeAccount({
+ id: 'con_default_alias',
+ alias: 'default',
+ updated_at: '2026-01-02T00:00:00.000Z',
+ }),
+ ]);
+
+ expect(selected?.id).toBe('con_default_alias');
+ });
+
+ it('matches explicit selectors by alias, word_id, and id', () => {
+ const items = [
+ makeAccount({ id: 'con_alpha', alias: 'work', word_id: 'castle' }),
+ makeAccount({ id: 'con_beta', alias: 'default', word_id: 'forest' }),
+ ];
+
+ expect(resolveConnectedAccountSelection(items, 'work')?.id).toBe('con_alpha');
+ expect(resolveConnectedAccountSelection(items, 'castle')?.id).toBe('con_alpha');
+ expect(resolveConnectedAccountSelection(items, 'con_beta')?.id).toBe('con_beta');
+ });
+
+ it('builds default account mappings and grouped cache payloads', () => {
+ const items = [
+ makeAccount({ id: 'con_default_gmail', alias: 'default' }),
+ makeAccount({
+ id: 'con_alt_gmail',
+ alias: 'secondary',
+ word_id: 'castle',
+ updated_at: '2026-01-02T00:00:00.000Z',
+ }),
+ makeAccount({
+ id: 'con_default_slack',
+ alias: 'default',
+ toolkit: { slug: 'slack' },
+ }),
+ ];
+
+ expect(resolveDefaultConnectedAccountsByToolkit(items)).toEqual({
+ gmail: 'con_default_gmail',
+ slack: 'con_default_slack',
+ });
+
+ expect(groupCachedConnectedAccountsByToolkit(items)).toMatchObject({
+ gmail: [
+ expect.objectContaining({ id: 'con_alt_gmail', alias: 'secondary', wordId: 'castle' }),
+ expect.objectContaining({ id: 'con_default_gmail', alias: 'default', wordId: null }),
+ ],
+ slack: [expect.objectContaining({ id: 'con_default_slack', alias: 'default', wordId: null })],
+ });
+ });
+
+ it('formats available account choices for CLI error messages', () => {
+ expect(
+ formatConnectedAccountChoices([
+ makeAccount({ id: 'con_default', alias: 'default', word_id: 'castle' }),
+ ])
+ ).toEqual(['default / castle (con_default)']);
+ });
+});
diff --git a/ts/packages/cli/test/src/services/consumer-short-term-cache.test.ts b/ts/packages/cli/test/src/services/consumer-short-term-cache.test.ts
index 30cec92ef..fee92c65e 100644
--- a/ts/packages/cli/test/src/services/consumer-short-term-cache.test.ts
+++ b/ts/packages/cli/test/src/services/consumer-short-term-cache.test.ts
@@ -6,6 +6,7 @@ import * as composioClients from 'src/services/composio-clients';
import {
getFreshConsumerConnectedToolkitsFromCache,
getFreshConsumerToolRouterAuthConfigsFromCache,
+ getFreshConsumerToolRouterConnectedAccountsFromCache,
refreshConsumerConnectedToolkitsCache,
writeConsumerConnectedToolkitsCache,
} from 'src/services/consumer-short-term-cache';
@@ -240,4 +241,60 @@ describe('consumer short-term cache', () => {
);
}
);
+
+ layer(TestLive({ baseConfigProvider: cacheEnabledTestConfigProvider }))(
+ '[Given] cached connected account metadata [Then] default mappings and summaries are readable',
+ it => {
+ it.scoped('returns cached connected account selectors by toolkit', () =>
+ Effect.gen(function* () {
+ yield* writeConsumerConnectedToolkitsCache({
+ orgId: 'org_test',
+ consumerUserId: 'consumer-user-test',
+ toolkits: ['gmail'],
+ toolRouterConnectedAccounts: {
+ connectedAccounts: {
+ gmail: 'con_default',
+ },
+ availableConnectedAccounts: {
+ gmail: [
+ {
+ id: 'con_default',
+ alias: 'default',
+ wordId: 'castle',
+ updatedAt: '2026-01-02T00:00:00.000Z',
+ createdAt: '2026-01-01T00:00:00.000Z',
+ },
+ ],
+ },
+ },
+ });
+
+ const cached = yield* getFreshConsumerToolRouterConnectedAccountsFromCache({
+ orgId: 'org_test',
+ consumerUserId: 'consumer-user-test',
+ toolkits: ['gmail'],
+ });
+
+ expect(cached).toEqual(
+ Option.some({
+ connectedAccounts: {
+ gmail: 'con_default',
+ },
+ availableConnectedAccounts: {
+ gmail: [
+ {
+ id: 'con_default',
+ alias: 'default',
+ wordId: 'castle',
+ updatedAt: '2026-01-02T00:00:00.000Z',
+ createdAt: '2026-01-01T00:00:00.000Z',
+ },
+ ],
+ },
+ })
+ );
+ })
+ );
+ }
+ );
});
diff --git a/ts/packages/core/src/types/connectedAccounts.types.ts b/ts/packages/core/src/types/connectedAccounts.types.ts
index e22bf2732..5207605ed 100644
--- a/ts/packages/core/src/types/connectedAccounts.types.ts
+++ b/ts/packages/core/src/types/connectedAccounts.types.ts
@@ -88,6 +88,8 @@ export type ConnectedAccountAuthConfig = z.infer<typeof ConnectedAccountAuthConf
export const ConnectedAccountRetrieveResponseSchema: z.ZodType<{
id: string;
authConfig: z.infer<typeof ConnectedAccountAuthConfigSchema>;
+ wordId?: string | null;
+ alias?: string | null;
/** @deprecated use connectedAccount.state instead */
data?: Record<string, unknown>;
/** @deprecated use connectedAccount.state instead */
@@ -103,6 +105,8 @@ export const ConnectedAccountRetrieveResponseSchema: z.ZodType<{
}> = z.object({
id: z.string(),
authConfig: ConnectedAccountAuthConfigSchema,
+ wordId: z.string().nullable().optional(),
+ alias: z.string().nullable().optional(),
/**
* @deprecated use connectedAccount.state instead
*/
diff --git a/ts/packages/core/src/utils/transformers/connectedAccounts.ts b/ts/packages/core/src/utils/transformers/connectedAccounts.ts
index 00368cfdc..0dc34a378 100644
--- a/ts/packages/core/src/utils/transformers/connectedAccounts.ts
+++ b/ts/packages/core/src/utils/transformers/connectedAccounts.ts
@@ -9,10 +9,17 @@ import {
ConnectedAccountRetrieveResponseSchema,
} from '../../types/connectedAccounts.types';
import { ConnectionDataSchema } from '../../types/connectedAccountAuthStates.types';
-import { ValidationError } from '../../errors';
import logger from '../logger';
import { transform } from '../transform';
+type RawConnectedAccountResponseWithLabels = (
+ | RawConnectedAccountRetrieveResponse
+ | RawConnectedAccountListResponse['items'][0]
+) & {
+ word_id?: string | null;
+ alias?: string | null;
+};
+
/**
* Transforms the raw connected account response from the Composio API to the SDK format.
*
@@ -28,6 +35,8 @@ import { transform } from '../transform';
export function transformConnectedAccountResponse(
response: RawConnectedAccountRetrieveResponse | RawConnectedAccountListResponse['items'][0]
): ConnectedAccountRetrieveResponse {
+ const responseWithLabels = response as RawConnectedAccountResponseWithLabels;
+
// Safely parse the state field, filtering out unsupported auth schemes
const parseState = (state: unknown) => {
try {
@@ -51,6 +60,8 @@ export function transformConnectedAccountResponse(
isComposioManaged: response.auth_config.is_composio_managed,
isDisabled: response.auth_config.is_disabled,
},
+ wordId: responseWithLabels.word_id ?? null,
+ alias: responseWithLabels.alias ?? null,
data: (response as unknown as ConnectedAccountRetrieveResponse).data ?? undefined,
state: parseState(response.state),
status: response.status,
diff --git a/ts/packages/core/test/connectedAccounts/connectedAccounts.test.ts b/ts/packages/core/test/connectedAccounts/connectedAccounts.test.ts
index c7f5110e2..784b32e15 100644
--- a/ts/packages/core/test/connectedAccounts/connectedAccounts.test.ts
+++ b/ts/packages/core/test/connectedAccounts/connectedAccounts.test.ts
@@ -479,6 +479,8 @@ describe('ConnectedAccounts', () => {
isComposioManaged: true,
isDisabled: false,
},
+ wordId: null,
+ alias: null,
state: {
authScheme: AuthSchemeTypes.OAUTH2,
val: {
@@ -499,6 +501,35 @@ describe('ConnectedAccounts', () => {
testRequestEndpoint: undefined,
});
});
+
+ it('should preserve alias and wordId when the API returns them', async () => {
+ const nanoid = 'conn_456';
+ const mockResponse = {
+ id: nanoid,
+ status: 'ACTIVE',
+ word_id: 'castle',
+ alias: 'Work Gmail',
+ auth_config: {
+ id: 'test-auth-config',
+ is_composio_managed: true,
+ is_disabled: false,
+ },
+ is_disabled: false,
+ created_at: '2023-01-01T00:00:00Z',
+ updated_at: '2023-01-01T00:00:00Z',
+ status_reason: null,
+ toolkit: {
+ slug: 'gmail',
+ },
+ };
+
+ extendedMockClient.connectedAccounts.retrieve.mockResolvedValueOnce(mockResponse);
+
+ const result = await connectedAccounts.get(nanoid);
+
+ expect(result.wordId).toBe('castle');
+ expect(result.alias).toBe('Work Gmail');
+ });
});
describe('delete', () => {
@@ -713,6 +744,7 @@ describe('ConnectedAccounts', () => {
expect(result).toEqual({
id: nanoid,
status: ConnectedAccountStatuses.ACTIVE,
+ alias: null,
authConfig: {
id: 'auth_config_123',
authScheme: AuthSchemeTypes.OAUTH2,
@@ -737,6 +769,7 @@ describe('ConnectedAccounts', () => {
slug: 'test-toolkit',
},
testRequestEndpoint: undefined,
+ wordId: null,
});
});
@@ -808,8 +841,10 @@ describe('ConnectedAccounts', () => {
expect(result).toEqual({
id: nanoid,
status: ConnectedAccountStatuses.ACTIVE,
+ alias: null,
authConfig: {
id: 'auth_config_123',
+ authScheme: undefined,
isComposioManaged: true,
isDisabled: false,
},
@@ -831,6 +866,7 @@ describe('ConnectedAccounts', () => {
slug: 'test-toolkit',
},
testRequestEndpoint: undefined,
+ wordId: null,
});
});
});