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

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

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

Synced Nov 21, 06:00 UTC

next
ts 167 lines 5.42 KB
Raw
1 import type {
2 PiComposioSessionLike,
3 PiConnectionHandlers,
4 PiConnectionManagementContext,
5 PiConnectionManagementResult,
6 PiConnectionToolkitResult,
7 PiProviderOptions,
8 PiSessionToolCapabilities,
9 PiSessionToolOptions,
10 } from './types';
11 import { stringValue } from './utils';
12
13 export const defaultIsToolkitConnected = (state: unknown): boolean => {
14 if (!state || typeof state !== 'object') return false;
15 const record = state as Record<string, unknown>;
16 if (record.isNoAuth === true || record.is_no_auth === true) return true;
17 if (typeof record.isConnected === 'boolean') return record.isConnected;
18 if (typeof record.is_connected === 'boolean') return record.is_connected;
19
20 const connection = record.connection as Record<string, unknown> | undefined;
21 if (connection) {
22 if (connection.isActive === true || connection.is_active === true) return true;
23 if (connection.status === 'ACTIVE') return true;
24 const nestedConnectedAccount = connection.connectedAccount as
25 | Record<string, unknown>
26 | undefined;
27 if (nestedConnectedAccount?.status === 'ACTIVE') return true;
28 const nestedConnectedAccountSnake = connection.connected_account as
29 | Record<string, unknown>
30 | undefined;
31 if (nestedConnectedAccountSnake?.status === 'ACTIVE') return true;
32 }
33
34 const connectedAccount = record.connectedAccount as Record<string, unknown> | undefined;
35 if (connectedAccount?.status === 'ACTIVE') return true;
36 const connectedAccountSnake = record.connected_account as Record<string, unknown> | undefined;
37 if (connectedAccountSnake?.status === 'ACTIVE') return true;
38
39 return false;
40 };
41
42 const toolkitKeyFromState = (state: unknown): string | undefined => {
43 if (!state || typeof state !== 'object') return undefined;
44 const record = state as Record<string, unknown>;
45 const toolkit = record.toolkit as Record<string, unknown> | undefined;
46 return (
47 stringValue(record.slug) ??
48 stringValue(record.toolkitSlug) ??
49 stringValue(record.toolkit_slug) ??
50 stringValue(record.name) ??
51 stringValue(toolkit?.slug)
52 );
53 };
54
55 export const normalizeToolkitStateMap = (
56 raw: unknown,
57 requestedToolkits: string[]
58 ): Map<string, unknown> => {
59 const byToolkit = new Map<string, unknown>();
60 const addState = (toolkit: string | undefined, state: unknown) => {
61 if (toolkit) byToolkit.set(toolkit.toLowerCase(), state);
62 };
63
64 if (!raw) return byToolkit;
65
66 if (Array.isArray(raw)) {
67 raw.forEach((state, index) =>
68 addState(toolkitKeyFromState(state) ?? requestedToolkits[index], state)
69 );
70 return byToolkit;
71 }
72
73 if (typeof raw === 'object') {
74 const record = raw as Record<string, unknown>;
75 if (Array.isArray(record.items)) {
76 record.items.forEach((state, index) =>
77 addState(toolkitKeyFromState(state) ?? requestedToolkits[index], state)
78 );
79 return byToolkit;
80 }
81
82 for (const toolkit of requestedToolkits) {
83 if (record[toolkit] !== undefined) {
84 addState(toolkit, record[toolkit]);
85 }
86 }
87
88 if (byToolkit.size === 0 && requestedToolkits.length === 1) {
89 addState(toolkitKeyFromState(raw) ?? requestedToolkits[0], raw);
90 }
91 }
92
93 return byToolkit;
94 };
95
96 export const formatDefaultConnectionResult = <TState, TAuthorizeResult>(
97 results: Record<string, PiConnectionToolkitResult<TState, TAuthorizeResult>>
98 ): PiConnectionManagementResult<TState, TAuthorizeResult> => {
99 const missing = Object.values(results).filter(result => !result.connected).length;
100 return {
101 successful: true,
102 data: {
103 message:
104 missing === 0
105 ? 'All requested toolkits are connected.'
106 : 'Connection flow initiated for missing toolkits.',
107 results,
108 },
109 error: null,
110 };
111 };
112
113 const inferSessionConnections = (
114 session: PiComposioSessionLike,
115 options: PiSessionToolOptions
116 ): PiConnectionHandlers | undefined => {
117 if (!session.toolkits && !session.authorize) return undefined;
118 return {
119 getToolkitStates: session.toolkits
120 ? toolkits => session.toolkits?.({ toolkits, limit: Math.max(toolkits.length, 1) })
121 : undefined,
122 authorizeToolkit: session.authorize
123 ? (toolkit, authorizeOptions) =>
124 session.authorize?.(toolkit, {
125 callbackUrl: authorizeOptions.callbackUrl ?? options.callbackUrl,
126 alias: authorizeOptions.alias,
127 experimental: authorizeOptions.experimental,
128 })
129 : undefined,
130 };
131 };
132
133 const isCapabilityInput = (
134 value: PiComposioSessionLike | PiSessionToolCapabilities
135 ): value is PiSessionToolCapabilities =>
136 'connections' in value ||
137 'hooks' in value ||
138 'includeWorkbenchTools' in value ||
139 'names' in value;
140
141 export const toCapabilities = (
142 input: PiComposioSessionLike | PiSessionToolCapabilities,
143 providerOptions: PiProviderOptions,
144 options: PiSessionToolOptions = {}
145 ): PiSessionToolCapabilities => {
146 if (isCapabilityInput(input)) {
147 return {
148 ...providerOptions,
149 ...input,
150 names: { ...(providerOptions as PiSessionToolOptions).names, ...(input.names ?? {}) },
151 };
152 }
153
154 const mergedOptions = { ...providerOptions, ...options };
155 return {
156 ...mergedOptions,
157 sessionId: input.sessionId,
158 search: params => input.search(params),
159 execute: (toolSlug, args, executeOptions) =>
160 executeOptions
161 ? input.execute(toolSlug, args, executeOptions)
162 : input.execute(toolSlug, args),
163 connections: inferSessionConnections(input, mergedOptions),
164 };
165 };
166
167 export type { PiConnectionManagementContext };