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

next
ts 185 lines 5.83 KB
Raw
1 import { BadRequestError, InternalServerError } from '@composio/client/effect';
2 import { describe, expect, it } from 'vitest';
3
4 import {
5 ComposioNoActiveConnectionError,
6 mapComposioError,
7 mapOnlyComposioOverrideError,
8 } from 'src/services/composio-error-overrides';
9
10 const url = 'https://backend.composio.dev/api/v3.1/tools/execute/{tool_slug}';
11
12 // The client's error for a 400 answered with `envelope`.
13 const apiError = (envelope: { code: number; slug: string; message: string }) => {
14 const details = { status: 400, ...envelope };
15 return new BadRequestError({
16 message: `400 ${JSON.stringify({ error: details })}`,
17 method: 'POST',
18 url,
19 status: 400,
20 requestId: 'req_test',
21 details,
22 body: { error: details },
23 });
24 };
25
26 describe('composio-error-overrides', () => {
27 it('rewrites a 4302 API error by toolkit', () => {
28 const result = mapComposioError({
29 toolkit: 'gmail',
30 error: apiError({
31 code: 4302,
32 slug: 'SomethingElse',
33 message: 'No active connection',
34 }),
35 });
36
37 expect(result.normalized).toBeInstanceOf(ComposioNoActiveConnectionError);
38 expect(result.message).toBe(
39 'No active connection found for toolkit "gmail". Run `composio link gmail`, then retry.'
40 );
41 expect(result.apiDetails).toMatchObject({ code: 4302, status: 400, request_id: 'req_test' });
42 });
43
44 it('rewrites an execute no-connection slug by tool slug', () => {
45 const result = mapComposioError({
46 toolSlug: 'SLACK_SEND_MESSAGE',
47 error: apiError({
48 code: 1,
49 slug: 'ActionExecute_ConnectedAccountNotFound',
50 message: 'Missing connected account',
51 }),
52 });
53
54 expect(result.normalized).toBeInstanceOf(ComposioNoActiveConnectionError);
55 expect(result.message).toBe(
56 'No active connection found for toolkit "slack". Run `composio link slack`, then retry.'
57 );
58 });
59
60 it('names the dev-tree link when the failing command ran on the dev tree', () => {
61 const result = mapComposioError({
62 toolkit: 'slack',
63 tree: 'dev',
64 error: apiError({
65 code: 4302,
66 slug: 'ToolRouterV2_NoActiveConnection',
67 message: 'No active connection',
68 }),
69 });
70
71 expect(result.message).toBe(
72 'No active connection found for toolkit "slack". Run `composio dev connected-accounts link slack` (with the same `--user-id`, if you passed one), then retry.'
73 );
74 expect(result.normalized).toHaveProperty('message', result.message);
75 });
76
77 it('renames the link of an error the executor raised without knowing the tree', () => {
78 const raised = new ComposioNoActiveConnectionError({ details: {}, toolkit: 'slack' });
79 expect(raised.message).toContain('`composio link slack`');
80
81 const onDevTree = mapComposioError({ error: raised, tree: 'dev' });
82 expect(onDevTree.message).toContain('`composio dev connected-accounts link slack`');
83 expect(onDevTree.message).not.toContain('`composio link slack`');
84
85 // Reported from the root tree, the same error keeps its message and identity.
86 expect(mapComposioError({ error: raised }).normalized).toBe(raised);
87 });
88
89 it('still recognizes an API error wrapped in an Effect cause chain', () => {
90 const result = mapComposioError({
91 toolkit: 'gmail',
92 error: {
93 _tag: 'UnknownException',
94 cause: apiError({
95 code: 1,
96 slug: 'ToolRouterV2_NoActiveConnection',
97 message: 'No active connection',
98 }),
99 },
100 });
101
102 expect(result.normalized).toBeInstanceOf(ComposioNoActiveConnectionError);
103 expect(result.slugValue).toBe('ToolRouterV2_NoActiveConnection');
104 });
105
106 it('passes through unrelated errors', () => {
107 const error = new Error('boom');
108
109 const result = mapComposioError({ error });
110
111 expect(result.normalized).toBe(error);
112 expect(result.override).toBeNull();
113 expect(result.message).toBe('boom');
114 });
115
116 it('keeps a non-envelope API error unmapped, with the error message', () => {
117 const error = new InternalServerError({
118 message: '502 {"message":"Bad gateway"}',
119 method: 'POST',
120 url,
121 status: 502,
122 requestId: 'req_test',
123 details: undefined,
124 body: { message: 'Bad gateway' },
125 });
126
127 const result = mapComposioError({ error });
128
129 expect(result.override).toBeNull();
130 expect(result.apiDetails).toMatchObject({ status: 502, code: undefined, slug: undefined });
131 expect(result.message).toBe(error.message);
132 });
133
134 it('does not classify look-alike plain objects as API errors', () => {
135 const error = {
136 details: {
137 code: 4302,
138 slug: 'ToolRouterV2_NoActiveConnection',
139 message: 'Looks like an API error',
140 },
141 };
142
143 const result = mapComposioError({ toolkit: 'gmail', error });
144
145 expect(result.override).toBeNull();
146 expect(result.apiDetails).toBeUndefined();
147 });
148
149 it('preserves original generic errors for top-level CLI handling', () => {
150 const error = {
151 _tag: 'ToolExecutionError',
152 error: new Error('inner'),
153 };
154
155 expect(mapOnlyComposioOverrideError({ error })).toBe(error);
156 });
157
158 it('still rewrites override-class Composio errors at the top level', () => {
159 const mapped = mapOnlyComposioOverrideError({
160 toolkit: 'gmail',
161 error: apiError({
162 code: 4302,
163 slug: 'ToolRouterV2_NoActiveConnection',
164 message: 'No active connection',
165 }),
166 });
167
168 expect(mapped).toBeInstanceOf(ComposioNoActiveConnectionError);
169 });
170
171 it('keeps an unrelated API error unmapped, with the envelope message', () => {
172 const error = apiError({
173 code: 1803,
174 slug: 'Tool_NotFound',
175 message: 'Tool not found',
176 });
177
178 const result = mapComposioError({ error });
179
180 expect(result.override).toBeNull();
181 expect(result.normalized).toBe(error);
182 expect(result.message).toBe('Tool not found');
183 expect(mapOnlyComposioOverrideError({ error })).toBe(error);
184 });
185 });