Basic Hono Server

1
import { OpenAI } from 'openai';
2
import { Composio } from '@composio/core';
3
import { OpenAIProvider } from '@composio/openai';
4
5
export async function runGmailAgent(
6
    composioClient: Composio<OpenAIProvider>,
7
    openaiClient: OpenAI,
8
    userId: string,  // Composio uses the User ID to store and access user-level authentication tokens.
9
    prompt: string,
10
): Promise<any[]> {
11
    // Step 1: Fetch the necessary Gmail tools list with Composio
12
    const tools = await composioClient.tools.get(
13
        userId,
14
        {
15
            tools: [
16
                "GMAIL_FETCH_EMAILS",
17
                "GMAIL_SEND_EMAIL", 
18
                "GMAIL_CREATE_EMAIL_DRAFT"
19
            ]
20
        }
21
    );
22
23
    // Step 2: Use OpenAI to generate a response based on the prompt and available tools
24
    const response = await openaiClient.chat.completions.create({
25
        model: "gpt-4.1",
26
        tools,
27
        messages: [{ role: "user", content: prompt }],
28
    });
29
30
    // Step 3: Handle tool calls with Composio and return the result
31
    const result = await composioClient.provider.handleToolCalls(
32
        userId,
33
        response
34
    );
35
    return result;
36
}

1
import { Composio } from '@composio/core';
2
import { OpenAIProvider } from '@composio/openai';
3
4
export async function createAuthConfig(composioClient: Composio<OpenAIProvider>) {
5
    /**
6
     * Create a auth config for the gmail toolkit.
7
     */
8
    const clientId = process.env.GMAIL_CLIENT_ID;
9
    const clientSecret = process.env.GMAIL_CLIENT_SECRET;
10
    if (!clientId || !clientSecret) {
11
        throw new Error("GMAIL_CLIENT_ID and GMAIL_CLIENT_SECRET must be set");
12
    }
13
14
    return composioClient.authConfigs.create(
15
        "GMAIL",
16
        {
17
            "name": "default_gmail_auth_config",
18
            "type": "use_custom_auth",
19
            "authScheme": "OAUTH2",
20
            "credentials": {
21
                "clientId": clientId,
22
                "clientSecret": clientSecret,
23
            },
24
        },
25
    );
26
}

1
export async function fetchAuthConfig(composioClient: Composio<OpenAIProvider>) {
2
    /**
3
     * Fetch the auth config for a given user id.
4
     */
5
    const authConfigs = await composioClient.authConfigs.list();
6
    for (const authConfig of authConfigs.items) {
7
        if (authConfig.toolkit.slug === "gmail") {
8
            return authConfig;
9
        }
10
    }
11
12
    return null;
13
}

1
import { Hono } from 'hono';
2
3
// Function to initiate a connected account
4
export async function createConnection(composioClient: Composio<OpenAIProvider>, userId: string) {
5
    /**
6
     * Create a connection for a given user id and auth config id.
7
     */
8
    // Fetch or create the auth config for the gmail toolkit
9
    let authConfig = await fetchAuthConfig(composioClient);
10
    if (!authConfig) {
11
        authConfig = await createAuthConfig(composioClient);
12
    }
13
14
    // Create a connection for the user
15
    return composioClient.connectedAccounts.initiate(
16
        userId,
17
        authConfig.id,
18
    );
19
}
20
21
// Setup Hono
22
const app = new Hono();
23
24
// Connection initiation endpoint
25
app.post("/connection/create", async (c) => {
26
    /**
27
     * Create a connection for a given user id.
28
     */
29
    // For demonstration, using a default user_id. Replace with real user logic in production.
30
    const userId = "default";
31
32
    // Create a new connection for the user
33
    const connectionRequest = await createConnection(composioClient, userId);
34
    return c.json({
35
        "connection_id": connectionRequest.id,
36
        "redirect_url": connectionRequest.redirectUrl,
37
    });
38
});

1
import { Composio } from '@composio/core';
2
import { OpenAIProvider } from '@composio/openai';
3
import { OpenAI } from 'openai';
4
5
let _composioClient: Composio<OpenAIProvider> | null = null;
6
7
export function provideComposioClient(): Composio<OpenAIProvider> {
8
    /**
9
     * Provide a Composio client.
10
     */
11
    if (_composioClient === null) {
12
        _composioClient = new Composio({ 
13
            provider: new OpenAIProvider() 
14
        });
15
    }
16
    return _composioClient;
17
}
18
19
// A Composio client dependency.
20
export type ComposioClient = Composio<OpenAIProvider>;

1
export function checkConnectedAccountExists(
2
    composioClient: Composio<OpenAIProvider>,
3
    userId: string,
4
): Promise<boolean> {
5
    /**
6
     * Check if a connected account exists for a given user id.
7
     */
8
    // Fetch all connected accounts for the user
9
    return composioClient.connectedAccounts.list({ userIds: [userId], toolkitSlugs: ["GMAIL"] }).then(connectedAccounts => {
10
11
        // Check if there's an active connected account
12
        for (const account of connectedAccounts.items) {
13
            if (account.status === "ACTIVE") {
14
                return true;
15
            }
16
17
            // Ideally you should not have inactive accounts, but if you do, delete them.
18
            console.log(`[warning] inactive account ${account.id} found for user id: ${userId}`);
19
        }
20
        return false;
21
    });
22
}
23
24
export async function validateUserId(userId: string, composioClient: ComposioClient): Promise<string> {
25
    /**
26
     * Validate the user id, if no connected account is found, create a new connection.
27
     */
28
    if (await checkConnectedAccountExists(composioClient, userId)) {
29
        return userId;
30
    }
31
32
    throw new Error("No connected account found for the user id");
33
}
34
35
// Endpoint: Run the Gmail agent for a given user id and prompt
36
app.post("/agent", async (c) => {
37
    /**
38
     * Run the Gmail agent for a given user id and prompt.
39
     */
40
    const request = await c.req.json();
41
    
42
    // For demonstration, using a default user_id. Replace with real user logic in production.
43
    const userId = "default";
44
45
    // Validate the user id before proceeding
46
    await validateUserId(userId, composioClient);
47
48
    // Run the Gmail agent using Composio and OpenAI
49
    const result = await runGmailAgent(
50
        composioClient,
51
        openaiClient,
52
        userId,
53
        request.prompt,
54
    );
55
    return c.json(result);
56
});