Press n or j to go to the next uncovered block, b, p or k for the previous block.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 | 1x 1x 1x 1x 1x 1x 1x 953x 953x 2x 2x 2x 2x 953x 2x | import { tool } from "ai";
import { ComposioToolSet as BaseComposioToolSet } from "../sdk/base.toolset";
import { jsonSchemaToModel } from "../utils/shared";
import { z } from "zod";
import { CEG } from "../sdk/utils/error";
import { SDK_ERROR_CODES } from "../sdk/utils/errors/src/constants";
type Optional<T> = T | null;
const zExecuteToolCallParams = z.object({
actions: z.array(z.string()).optional(),
apps: z.array(z.string()).optional(),
params: z.record(z.any()).optional(),
entityId: z.string().optional(),
useCase: z.string().optional(),
usecaseLimit: z.number().optional(),
connectedAccountId: z.string().optional(),
tags: z.array(z.string()).optional(),
filterByAvailableApps: z.boolean().optional().default(false),
});
export class VercelAIToolSet extends BaseComposioToolSet {
constructor(
config: {
apiKey?: Optional<string>;
baseUrl?: Optional<string>;
entityId?: string;
} = {}
) {
super(
config.apiKey || null,
config.baseUrl || null,
"vercel-ai",
config.entityId || "default"
);
}
private generateVercelTool(schema: Record<string, any>) {
const parameters = jsonSchemaToModel(schema.parameters);
return tool({
description: schema.description,
parameters,
execute: async (params: Record<string, string>) => {
return await this.executeToolCall(
{
name: schema.name,
arguments: JSON.stringify(params),
},
this.entityId
);
},
});
}
// change this implementation
async getTools(filters: {
actions?: Array<string>;
apps?: Array<string>;
tags?: Optional<Array<string>>;
useCase?: Optional<string>;
usecaseLimit?: Optional<number>;
filterByAvailableApps?: Optional<boolean>;
}): Promise<{ [key: string]: any }> {
const {
apps,
tags,
useCase,
usecaseLimit,
filterByAvailableApps,
actions,
} = zExecuteToolCallParams.parse(filters);
const actionsList = await this.client.actions.list({
...(apps && { apps: apps?.join(",") }),
...(tags && { tags: tags?.join(",") }),
...(useCase && { useCase: useCase }),
...(actions && { actions: actions?.join(",") }),
...(usecaseLimit && { usecaseLimit: usecaseLimit }),
filterByAvailableApps: filterByAvailableApps ?? undefined,
});
const tools = {};
actionsList.items?.forEach((actionSchema) => {
// @ts-ignore
tools[actionSchema.name!] = this.generateVercelTool(actionSchema);
});
return tools;
}
async executeToolCall(
tool: { name: string; arguments: unknown },
entityId: Optional<string> = null
): Promise<string> {
return JSON.stringify(
await this.executeAction({
action: tool.name,
params:
typeof tool.arguments === "string"
? JSON.parse(tool.arguments)
: tool.arguments,
entityId: entityId || this.entityId,
})
);
}
}
|