8 |
9 | 
10 |
11 | You can integrate in 3 ways:
12 |
13 | | | Approach | Description |
14 | | --- | ------------------------------------------------------------------------- | ---------------------------------------------------------------------- |
15 | | 1 | `SuperflowsButton` component _(recommended)_ | Easiest & fastest |
16 | | 2 | `SuperflowsChat` component | Most flexible & customizable |
17 | | 3 | The modal (`SuperflowsModal`) or sidebar (`SuperflowsSidebar`) components | (#1 but you have total control over the button that opens the chatbot) |
18 |
19 | ## Installation
20 |
21 | ```bash
22 | npm install @superflows/chat-ui-react
23 | ```
24 |
25 | ## Documentation
26 |
27 | Find the [integration guide here.](https://docs.superflows.ai/docs/category/integration-guide)
28 |
29 | Find [documentation for the Chat UI components here](https://docs.superflows.ai/docs/category/ui-components-react).
30 |
--------------------------------------------------------------------------------
/__tests__/convertToRenderable.test.ts:
--------------------------------------------------------------------------------
1 | /**
2 | * @jest-environment jsdom
3 | */
4 | import uuid from "uuid";
5 | import { describe, expect, it } from "@jest/globals";
6 | import { convertToMarkdownTable } from "../src/lib/utils";
7 |
8 | describe("convertToRenderable", () => {
9 | it("should convert short array of numbers to a markdown table", () => {
10 | const input = [1, 2, 3, 4, 5, 6];
11 | const output = convertToMarkdownTable(input);
12 | expect(output).toEqual(
13 | `| | | | | | |
14 | |---|---|---|---|---|---|
15 | | 1 | 2 | 3 | 4 | 5 | 6 |
16 | `,
17 | );
18 | });
19 | it("should convert long array of numbers to a markdown table", () => {
20 | const input = [1, 2, 3, 4, 5, 6, 7];
21 | const output = convertToMarkdownTable(input);
22 | expect(output).toEqual(
23 | `| |
24 | |---|
25 | | 1 |
26 | | 2 |
27 | | 3 |
28 | | 4 |
29 | | 5 |
30 | | 6 |
31 | | 7 |
32 | `,
33 | );
34 | });
35 | it("should convert object with 1 key and value of long array of numbers to a markdown table", () => {
36 | const input = { whatsthedifferencebetweenmeandyou: [1, 2, 3, 4, 5, 6, 7] };
37 | const output = convertToMarkdownTable(input);
38 | expect(output).toEqual(
39 | `### Whatsthedifferencebetweenmeandyou
40 |
41 | | |
42 | |---|
43 | | 1 |
44 | | 2 |
45 | | 3 |
46 | | 4 |
47 | | 5 |
48 | | 6 |
49 | | 7 |
50 | `,
51 | );
52 | });
53 | it("should convert array of arrays to a markdown table", () => {
54 | const input = [
55 | [1, 2, 3],
56 | [4, 5, 6],
57 | [7, 8, 9],
58 | ];
59 | const output = convertToMarkdownTable(input);
60 | expect(output).toEqual(
61 | `| 0 | 1 | 2 |
62 | | :---: | :---: | :---: |
63 | | 1 | 2 | 3 |
64 | | 4 | 5 | 6 |
65 | | 7 | 8 | 9 |
66 | `,
67 | );
68 | });
69 | it("should convert an array of objects to a markdown table", () => {
70 | const input = [
71 | { a: 1, b: 2, c: 3 },
72 | { a: 4, b: 5, c: 6 },
73 | ];
74 | const output = convertToMarkdownTable(input);
75 | expect(output).toEqual(
76 | `| a | b | c |
77 | | :---: | :---: | :---: |
78 | | 1 | 2 | 3 |
79 | | 4 | 5 | 6 |
80 | `,
81 | );
82 | });
83 | it("should convert an array of objects with nested arrays to a markdown table", () => {
84 | const input = [
85 | { a: 1, b: 2, c: [1, 2, 3] },
86 | { a: 4, b: 5, c: [4, 5, 6] },
87 | ];
88 | const output = convertToMarkdownTable(input);
89 | expect(output).toEqual(
90 | `| a | b | c |
91 | | :---: | :---: | :---: |
92 | | 1 | 2 | 1,2,3 |
93 | | 4 | 5 | 4,5,6 |
94 | `,
95 | );
96 | });
97 | it("should convert an array of objects with nested objects to a markdown table", () => {
98 | const input = [
99 | { a: 1, b: 2, c: { fire: 1, sale: 2, aaaa: 3, theburning: 4 } },
100 | { a: 4, b: 5, c: { fire: 1, sale: 2, aaaa: 3, theburning: 4 } },
101 | ];
102 | const output = convertToMarkdownTable(input);
103 | expect(output)
104 | .toEqual(`| a | b | c -> Fire | c -> Sale | c -> Aaaa | c -> Theburning |
105 | | :---: | :---: | :-------: | :-------: | :-------: | :-------------: |
106 | | 1 | 2 | 1 | 2 | 3 | 4 |
107 | | 4 | 5 | 1 | 2 | 3 | 4 |
108 | `);
109 | });
110 | it("should convert object with long array of objects into a markdown table", () => {
111 | const input = {
112 | responses: [
113 | {
114 | score: 5,
115 | comment: "Very quick and easy to sort out",
116 | updated_at: "2023-08-02T14:02:18.818Z",
117 | data_source: "Trustpilot",
118 | themes: [
119 | {
120 | name: "Ease of Use / Navigation",
121 | },
122 | {
123 | name: "Speed of Use / Navigation",
124 | },
125 | ],
126 | },
127 | {
128 | score: 1,
129 | comment:
130 | "This bank has the worst customer service ever as soon as they open I'm shutting down my accounts,,,\nSHHIIIIITTTTTT SERVICE 45 MINUTES ON HOLD !!!!",
131 | updated_at: "2023-08-02T14:02:10.108Z",
132 | data_source: "Trustpilot",
133 | },
134 | {
135 | score: 5,
136 | comment: "Have been great for when abroad.",
137 | updated_at: "2023-08-02T14:02:18.945Z",
138 | data_source: "Trustpilot",
139 | themes: [
140 | {
141 | name: "General",
142 | },
143 | ],
144 | },
145 | ],
146 | };
147 | const out = convertToMarkdownTable(input);
148 | expect(out).toEqual(`### Responses
149 |
150 | | Score | Comment | Updated At | Data Source | Themes |
151 | | :---: | :----------------------------------------------------------------------------------------------------------------------------------------------------: | :----------------------: | :---------: | :--------------------------------------------------------------: |
152 | | 5 | Very quick and easy to sort out | 2023-08-02T14:02:18.818Z | Trustpilot | {name:Ease of Use / Navigation},{name:Speed of Use / Navigation} |
153 | | 1 | This bank has the worst customer service ever as soon as they open I'm shutting down my accounts,,,
SHHIIIIITTTTTT SERVICE 45 MINUTES ON HOLD !!!! | 2023-08-02T14:02:10.108Z | Trustpilot | |
154 | | 5 | Have been great for when abroad. | 2023-08-02T14:02:18.945Z | Trustpilot | {name:General} |
155 | `);
156 | });
157 | it("should convert simple object to a markdown table", () => {
158 | const input = {
159 | if: "you can keep your head",
160 | when: "all about you are losing theirs",
161 | and: "blaming it on you",
162 | };
163 | const output = convertToMarkdownTable(input);
164 | expect(output).toEqual(
165 | `| Name | Value |
166 | | :---- | :------------------------------ |
167 | | if | you can keep your head |
168 | | when | all about you are losing theirs |
169 | | and | blaming it on you |
170 | `,
171 | );
172 | });
173 | it("should convert object with 1 array field to a markdown table", () => {
174 | const input = {
175 | if: ["you ", "can ", "trust", " yourself"],
176 | when: "all men doubt you",
177 | but: "keep allowance for their doubting too",
178 | };
179 | const output = convertToMarkdownTable(input);
180 | expect(output).toEqual(
181 | `| Name | Value |
182 | | :---- | :------------------------------------ |
183 | | if | you ,can ,trust, yourself |
184 | | when | all men doubt you |
185 | | but | keep allowance for their doubting too |
186 | `,
187 | );
188 | });
189 | it("should convert object with 1 object field to a markdown table", () => {
190 | const input = {
191 | if: ["you ", "can ", "wait"],
192 | and: { not: "be", tired: "of", waiting: "." },
193 | };
194 | const output = convertToMarkdownTable(input);
195 | const expected = `| Name | Value |
196 | | :------------- | :------------- |
197 | | if | you ,can ,wait |
198 | | and -> not | be |
199 | | and -> tired | of |
200 | | and -> waiting | . |
201 | `;
202 | expect(output).toEqual(expected);
203 | });
204 |
205 | it("removes uuid from key:value pairs", () => {
206 | const input = {
207 | well: "i dreamed i saw the knights in armor coming",
208 | saying: "something about a queen",
209 | uuid: uuid.v4(),
210 | };
211 | const output = convertToMarkdownTable(input);
212 | expect(output).toEqual(
213 | `| Name | Value |
214 | | :----- | :------------------------------------------ |
215 | | well | i dreamed i saw the knights in armor coming |
216 | | saying | something about a queen |
217 | `,
218 | );
219 | });
220 |
221 | it("removes uuid from array", () => {
222 | const input = "look at mother nature on the run".split(" ");
223 | input.push(uuid.v4());
224 | const output = convertToMarkdownTable(input);
225 | const expected = `| |
226 | |---|
227 | | look |
228 | | at |
229 | | mother |
230 | | nature |
231 | | on |
232 | | the |
233 | | run |
234 | `;
235 | expect(output).toEqual(expected);
236 | });
237 | it("removes nested uuid from array", () => {
238 | const input = [
239 | ["i", "was"],
240 | ["lying", "in"],
241 | ["a", "burned"],
242 | ["out", "basement"],
243 | ["with", uuid.v4()],
244 | ];
245 | const output = convertToMarkdownTable(input);
246 | const expected = `| 0 | 1 |
247 | | :---: | :------: |
248 | | i | was |
249 | | lying | in |
250 | | a | burned |
251 | | out | basement |
252 | | with | |
253 | `;
254 | expect(output).toEqual(expected);
255 | });
256 | it("removes uuid from nested object", () => {
257 | const input = [
258 | { flying: "mother nature's silver seed", to: "a new home in the sun" },
259 | { flying: "mother nature's on the run", to: uuid.v4() },
260 | ];
261 | const output = convertToMarkdownTable(input);
262 | const expected = `| Flying | To |
263 | | :-------------------------: | :-------------------: |
264 | | mother nature's silver seed | a new home in the sun |
265 | | mother nature's on the run | |
266 | `;
267 | expect(output).toEqual(expected);
268 | });
269 | it("real world example - nested object", () => {
270 | const input = {
271 | workflow: { code: "client.sub-account" },
272 | data: {
273 | account: {
274 | id: "6e9e250d-47d9-4fda-b223-9687a71afc0b",
275 | clientId: "a800b3e5-15e0-4b3c-9d0f-e95f3aed30ba",
276 | status: "active",
277 | country: "GB",
278 | currency: "GBP",
279 | alias: "GBP Account",
280 | routingCodes: {},
281 | // @ts-ignore
282 | iban: null,
283 | // @ts-ignore
284 | accountNumber: null,
285 | ledgerNumber: "43668932",
286 | availableBalance: 0,
287 | accountHolderIdentityType: "corporate",
288 | accountHolderName: "I.F Technology Ltd",
289 | mainAccountId: "f51db37b-9da6-47e3-a20a-93e642a8fb2c",
290 | },
291 | },
292 | connect: { type: "explicit", serviceProvider: "currencycloud" },
293 | metadata: {},
294 | };
295 | const output = convertToMarkdownTable(input);
296 | const expected = `| Name | Value |
297 | | :------------------------------------------- | :----------------- |
298 | | workflow -> code | client.sub-account |
299 | | data -> account -> status | active |
300 | | data -> account -> country | GB |
301 | | data -> account -> currency | GBP |
302 | | data -> account -> alias | GBP Account |
303 | | data -> account -> ledgerNumber | 43668932 |
304 | | data -> account -> availableBalance | 0 |
305 | | data -> account -> accountHolderIdentityType | corporate |
306 | | data -> account -> accountHolderName | I.F Technology Ltd |
307 | | connect -> type | explicit |
308 | | connect -> serviceProvider | currencycloud |
309 | `;
310 | expect(output).toEqual(expected);
311 | });
312 | });
313 |
--------------------------------------------------------------------------------
/__tests__/graph.test.ts:
--------------------------------------------------------------------------------
1 | import { describe, expect, it } from "@jest/globals";
2 | import {
3 | checkStringMatch,
4 | extractGraphData,
5 | findFirstArray,
6 | possibleYlabels,
7 | } from "../src/components/graph";
8 | import { GraphData } from "../src/lib/types";
9 |
10 | describe("checkStringMatch", () => {
11 | it("basic match", () => {
12 | const possibleLabels = ["Value", "Genre", "Groups", "Label"];
13 | expect(checkStringMatch("value", possibleLabels)).toBeTruthy();
14 | });
15 | it("match plural", () => {
16 | const possibleLabels = ["Values", "Genre", "Groups", "Label"];
17 | expect(checkStringMatch("value", possibleLabels)).toBeTruthy();
18 | });
19 |
20 | it("match camel", () => {
21 | const possibleLabels = ["Values", "Genre", "TimeDays", "Label"];
22 | expect(checkStringMatch("time days", possibleLabels)).toBeTruthy();
23 | });
24 |
25 | it("no match", () => {
26 | const possibleLabels = ["Values", "Genre", "TimeDays", "Label"];
27 | expect(checkStringMatch("puppy", possibleLabels)).toBeFalsy();
28 | });
29 |
30 | it("match score", () => {
31 | expect(checkStringMatch("score", possibleYlabels)).toBeTruthy();
32 | });
33 | });
34 |
35 | describe("findFirstArray", () => {
36 | it("basic match", () => {
37 | const data = { x: [1, 2, 3] };
38 | const { result, arrayKey } = findFirstArray(data);
39 | expect(result).toEqual([1, 2, 3]);
40 | expect(arrayKey).toEqual("x");
41 | });
42 |
43 | it("data is array", () => {
44 | const data = [1, 2, 3];
45 | const { result, arrayKey } = findFirstArray(data);
46 | expect(result).toEqual([1, 2, 3]);
47 | expect(arrayKey).toBeNull();
48 | });
49 |
50 | it("array of objects", () => {
51 | const data = {
52 | x: "1",
53 | y: 200,
54 | arr: [
55 | { x: 1, y: 2 },
56 | { x: 2, y: 3 },
57 | { x: 3, y: 4 },
58 | ],
59 | xisDate: false,
60 | };
61 |
62 | const { result, arrayKey } = findFirstArray(data);
63 |
64 | expect(result).toEqual([
65 | { x: 1, y: 2 },
66 | { x: 2, y: 3 },
67 | { x: 3, y: 4 },
68 | ]);
69 | expect(arrayKey).toEqual("arr");
70 | });
71 |
72 | it("multiple arrays", () => {
73 | const data = {
74 | x: "1",
75 | y: [200, 300, 400],
76 | a: {
77 | arr2: [
78 | { x: 1, y: 2 },
79 | { x: 2, y: 3 },
80 | { x: 3, y: 4 },
81 | ],
82 | },
83 | xisDate: false,
84 | };
85 | const { result, arrayKey } = findFirstArray(data);
86 | expect(result).toEqual([200, 300, 400]);
87 | expect(arrayKey).toEqual("y");
88 | });
89 |
90 | it("no arrays", () => {
91 | const data = {
92 | April: "is",
93 | the: "cruelest",
94 | month: 100,
95 | };
96 | const { result, arrayKey } = findFirstArray(data);
97 | expect(result).toEqual(null);
98 | expect(arrayKey).toEqual(null);
99 | });
100 | });
101 |
102 | describe("extractGraphData", () => {
103 | it("basic match", () => {
104 | const data = { numberOfCustomers: [1, 2, 3] };
105 | const expected: GraphData = {
106 | type: "line",
107 | data: [
108 | { x: 0, y: 1 },
109 | { x: 1, y: 2 },
110 | { x: 2, y: 3 },
111 | ],
112 | graphTitle: "numberOfCustomers",
113 | };
114 | expect(extractGraphData(data, "line")).toEqual(expected);
115 | });
116 | it("match array of objects", () => {
117 | const data = {
118 | numberOfCustomers: [
119 | { category: 1, value: 2 },
120 | { category: 2, value: 3 },
121 | ],
122 | };
123 | const expected: GraphData = {
124 | type: "line",
125 | data: [
126 | { x: 1, y: 2 },
127 | { x: 2, y: 3 },
128 | ],
129 | xLabel: "category",
130 | yLabel: "value",
131 | graphTitle: "numberOfCustomers",
132 | xIsdate: false,
133 | };
134 | expect(extractGraphData(data, "line")).toEqual(expected);
135 | });
136 | it("match array of objects date", () => {
137 | const data = {
138 | numberOfCustomers: [
139 | { date: "2023-08-22", value: 2 },
140 | { date: "2023-08-23", value: 3 },
141 | ],
142 | };
143 | expect(extractGraphData(data, "line")?.xIsdate).toEqual(true);
144 | expect(extractGraphData(data, "line")?.data[0].y).toEqual(2);
145 | expect(extractGraphData(data, "line")?.data[1].y).toEqual(3);
146 |
147 | expect(extractGraphData(data, "line")?.data[0].x).toBeGreaterThan(19590);
148 | expect(extractGraphData(data, "line")?.data[0].x).toBeLessThan(
149 | 19590 + 365 * 100,
150 | ); // test will fail in 100 years time
151 | expect(extractGraphData(data, "line")?.data[1].x).toBeGreaterThan(
152 | extractGraphData(data, "line")?.data[0].x as number,
153 | );
154 | });
155 | it("no arrays", () => {
156 | const data = { numberOfCustomers: 100 };
157 | expect(extractGraphData(data, "line")).toEqual(null);
158 | });
159 | it("Only y axis match", () => {
160 | const data = {
161 | numberOfCustomers: [
162 | { snooker: 1, score: 2 },
163 | { snooker: 2, score: 3 },
164 | ],
165 | };
166 | const expected: GraphData = {
167 | type: "line",
168 | data: [
169 | { x: 0, y: 2 },
170 | { x: 1, y: 3 },
171 | ],
172 | yLabel: "score",
173 | graphTitle: "numberOfCustomers",
174 | };
175 | const res = extractGraphData(data, "line");
176 | expect(res).toEqual(expected);
177 | });
178 |
179 | it("No y axis match, but x axis match", () => {
180 | const data = {
181 | numberOfCustomers: [
182 | { date: 1, year: 2 },
183 | { date: 2, year: 3 },
184 | ],
185 | };
186 | expect(extractGraphData(data, "line")).toEqual(null);
187 | });
188 | it("multiple y axis match and x axis match", () => {
189 | const data = {
190 | numberOfCustomers: [
191 | { date: 1, year: 2, score: 100 },
192 | { date: 2, year: 3, score: 105 },
193 | ],
194 | };
195 | // This might be a bad test because the order of keys in a json is not guaranteed
196 | const expected: GraphData = {
197 | type: "line",
198 | data: [
199 | { x: 1, y: 100 },
200 | { x: 2, y: 105 },
201 | ],
202 | yLabel: "score",
203 | xLabel: "date",
204 | graphTitle: "numberOfCustomers",
205 | xIsdate: false,
206 | };
207 |
208 | expect(extractGraphData(data, "line")).toEqual(expected);
209 | });
210 | });
211 |
--------------------------------------------------------------------------------
/__tests__/parsers.test.ts:
--------------------------------------------------------------------------------
1 | import { describe, it, expect } from "@jest/globals";
2 | import {
3 | FunctionCall,
4 | makeDoubleExternalQuotes,
5 | parseFunctionCall,
6 | parseOutput,
7 | } from "../src/lib/parser";
8 |
9 | describe("Parse output", () => {
10 | it("should not error", () => {
11 | const output = parseOutput(
12 | "Reasoning: We have successfully retrieved the recent information about Mr. Daniel Solís Martínez's case. The most recent event is an insurance note related to water damage from a plumbing issue. The claim has not yet been completed and the case has been passed on to WekLaw.\n" +
13 | "\n" +
14 | "Plan:\n" +
15 | "- Inform the user about the retrieved information.\n" +
16 | "\n" +
17 | "Commands:\n",
18 | );
19 | expect(output).toBeDefined();
20 | expect(output.reasoning).toBe(
21 | "We have successfully retrieved the recent information about Mr. Daniel Solís Martínez's case. The most recent event is an insurance note related to water damage from a plumbing issue. The claim has not yet been completed and the case has been passed on to WekLaw.",
22 | );
23 | expect(output.plan).toBe(
24 | "- Inform the user about the retrieved information.",
25 | );
26 | expect(output.tellUser).toBe("");
27 | expect(output.commands).toStrictEqual([]);
28 | expect(output.completed).toBe(true);
29 | });
30 | it("should not error including tell user", () => {
31 | const output = parseOutput(
32 | "Reasoning:\n" +
33 | "The user's request is vague and needs clarification. We need to understand what kind of trap they are referring to, for which customer this is for, and what the context of the scheduling is about.\n" +
34 | "\n" +
35 | "Plan:\n" +
36 | "- Ask the user for more information about the type of trap, the customer involved, and any other relevant details.\n" +
37 | "\n" +
38 | "Tell user:\n" +
39 | "Could you please provide more information? Who is the customer we need to schedule a trap for and what type of trap are we talking about?\n",
40 | );
41 | expect(output).toBeDefined();
42 | expect(output.reasoning).toBe(
43 | "The user's request is vague and needs clarification. We need to understand what kind of trap they are referring to, for which customer this is for, and what the context of the scheduling is about.",
44 | );
45 | expect(output.plan).toBe(
46 | "- Ask the user for more information about the type of trap, the customer involved, and any other relevant details.",
47 | );
48 | expect(output.tellUser).toBe(
49 | "Could you please provide more information? Who is the customer we need to schedule a trap for and what type of trap are we talking about?",
50 | );
51 | expect(output.commands).toStrictEqual([]);
52 | expect(output.completed).toBe(true);
53 | });
54 | it("should not error no plan, no commands", () => {
55 | const output = parseOutput(
56 | "Reasoning: We have successfully retrieved the recent information about Mr. Nestor Alfaras's case.\n" +
57 | "\n" +
58 | "Tell user: The most recent update for Mr. Nestor Alfaras's case is an insurance note which has been completed. The subproject type was Plumbing and the details were passed on to WekLaw.\n",
59 | );
60 | expect(output).toBeDefined();
61 | expect(output.reasoning).toBe(
62 | "We have successfully retrieved the recent information about Mr. Nestor Alfaras's case.",
63 | );
64 | expect(output.plan).toBe("");
65 | expect(output.tellUser).toBe(
66 | "The most recent update for Mr. Nestor Alfaras's case is an insurance note which has been completed. The subproject type was Plumbing and the details were passed on to WekLaw.",
67 | );
68 | expect(output.commands).toStrictEqual([]);
69 | expect(output.completed).toBe(true);
70 | });
71 | it("should not error no plan, no commands", () => {
72 | const output = parseOutput(
73 | 'Reasoning: The search results show multiple individuals with the last name "Martinez". I need to clarify which Mr. Martinez the user is referring to.\n' +
74 | "\n" +
75 | "Plan:\n" +
76 | "- Ask the user to provide more information about Mr. Martinez so we can identify the correct person.\n" +
77 | "\n" +
78 | "Tell user: We have multiple customers with the last name Martinez. Could you please provide more information, such as a first name, to help identify the correct Mr. Martinez?",
79 | );
80 | expect(output).toBeDefined();
81 | expect(output.reasoning).toBe(
82 | 'The search results show multiple individuals with the last name "Martinez". I need to clarify which Mr. Martinez the user is referring to.',
83 | );
84 | expect(output.plan).toBe(
85 | "- Ask the user to provide more information about Mr. Martinez so we can identify the correct person.",
86 | );
87 | expect(output.tellUser).toBe(
88 | "We have multiple customers with the last name Martinez. Could you please provide more information, such as a first name, to help identify the correct Mr. Martinez?",
89 | );
90 | expect(output.commands).toStrictEqual([]);
91 | expect(output.completed).toBe(true);
92 | });
93 | it("should not output 'invalid input format:'", () => {
94 | const output = parseOutput(
95 | "Reasoning: The search results show multiple individuals with",
96 | );
97 | expect(output).toBeDefined();
98 | expect(output.reasoning).toBe(
99 | "The search results show multiple individuals with",
100 | );
101 | expect(output.plan).toBe("");
102 | expect(output.tellUser).toBe("");
103 | expect(output.commands).toStrictEqual([]);
104 | expect(output.completed).toBe(true);
105 | });
106 |
107 | it("tell user as command", () => {
108 | const output = parseOutput("Commands:\nTell user: i did a nice command");
109 | expect(output).toBeDefined();
110 | expect(output.reasoning).toBe("");
111 | expect(output.plan).toBe("");
112 | expect(output.tellUser).toBe("i did a nice command");
113 | expect(output.commands).toStrictEqual([]);
114 | expect(output.completed).toBe(true);
115 | });
116 |
117 | it("long output, parsing commands properly", () => {
118 | const gptOut =
119 | "Reasoning:\n" +
120 | "In order to generate a report showing the most active users in the last 30 days from the construction industry, we will need to create a segment for this specific group of users. Then, we will add necessary columns to this segment. After that, we can generate a report from this segment.\n" +
121 | "\n" +
122 | "Plan:\n" +
123 | "- Create a segment for users in the construction industry.\n" +
124 | "- Filter this segment to include only users who have been active in the last 30 days.\n" +
125 | "- Add necessary columns to this new segment (like user activity and user industry).\n" +
126 | "- Finally, create a report for this segment.\n" +
127 | "\n" +
128 | "Tell user:\n" +
129 | "I'm going to create a report that shows the most active users in the last 30 days from the construction industry. I'll start by creating and setting up a new segment for these users.\n" +
130 | "\n" +
131 | "Commands:\n" +
132 | 'create_segment(name="Active Construction Users", segmentType="user")\n' +
133 | 'create_report(reportName="Active Construction Users Report", description="Report showing most active construction industry users in last 30 days.", segmentId="{{id}}", timeframeDays=30, columns=[{"name": "User Activity","type": "number"},{"name": "User Industry","type": "string"}])';
134 | const output = parseOutput(gptOut);
135 | expect(output).toStrictEqual({
136 | reasoning:
137 | "In order to generate a report showing the most active users in the last 30 days from the construction industry, we will need to create a segment for this specific group of users. Then, we will add necessary columns to this segment. After that, we can generate a report from this segment.",
138 | plan:
139 | "- Create a segment for users in the construction industry.\n" +
140 | "- Filter this segment to include only users who have been active in the last 30 days.\n" +
141 | "- Add necessary columns to this new segment (like user activity and user industry).\n" +
142 | "- Finally, create a report for this segment.",
143 | tellUser:
144 | "I'm going to create a report that shows the most active users in the last 30 days from the construction industry. I'll start by creating and setting up a new segment for these users.",
145 | commands: [
146 | {
147 | name: "create_segment",
148 | args: {
149 | name: "Active Construction Users",
150 | segmentType: "user",
151 | },
152 | },
153 | {
154 | name: "create_report",
155 | args: {
156 | reportName: "Active Construction Users Report",
157 | description:
158 | "Report showing most active construction industry users in last 30 days.",
159 | segmentId: "{{id}}",
160 | timeframeDays: 30,
161 | columns: [
162 | {
163 | name: "User Activity",
164 | type: "number",
165 | },
166 | {
167 | name: "User Industry",
168 | type: "string",
169 | },
170 | ],
171 | },
172 | },
173 | ],
174 | completed: false,
175 | });
176 | });
177 | it("incorrectly-ordered real world output", () => {
178 | const gptOut =
179 | "Reasoning: To create a new account for the client, I will use the 'create_account' function. The required parameters are 'workflow' and 'data'. Under 'workflow', I will set the code to 'client.sub-account' as we are creating a sub-account for an existing client. Under 'data', I will provide the clientId (which in this case is 23030138) and a currency code as per ISO 4217.\n" +
180 | "\n" +
181 | "Tell user: Please provide the currency for the new account.\n" +
182 | "\n" +
183 | "Plan:\n" +
184 | '- Use create_account function with workflow code "client.sub-account" and data containing clientId and currency.';
185 | const output = parseOutput(gptOut);
186 | expect(output).toStrictEqual({
187 | reasoning:
188 | "To create a new account for the client, I will use the 'create_account' function. The required parameters are 'workflow' and 'data'. Under 'workflow', I will set the code to 'client.sub-account' as we are creating a sub-account for an existing client. Under 'data', I will provide the clientId (which in this case is 23030138) and a currency code as per ISO 4217.",
189 | plan: '- Use create_account function with workflow code "client.sub-account" and data containing clientId and currency.',
190 | tellUser: "Please provide the currency for the new account.",
191 | commands: [],
192 | completed: true,
193 | });
194 | });
195 | it("incomplete commands should not be tell user. Function ends in fullstop", () => {
196 | const output = parseOutput(
197 | "Reasoning: Some reasoning\n" +
198 | "\n" +
199 | "Plan:\n" +
200 | "- Inform the user about the retrieved information.\n" +
201 | "\n" +
202 | "Commands: function_call(arg1=1, arg2=2.",
203 | );
204 | expect(output).toBeDefined();
205 | expect(output.reasoning).toBe("Some reasoning");
206 | expect(output.plan).toBe(
207 | "- Inform the user about the retrieved information.",
208 | );
209 | expect(output.tellUser).toBe("");
210 | expect(output.commands).toStrictEqual([]);
211 | expect(output.completed).toBe(true);
212 | });
213 | it("incomplete commands should not be tell user. Function has no brackets yet", () => {
214 | const output = parseOutput(
215 | "Reasoning: Some reasoning\n" +
216 | "\n" +
217 | "Plan:\n" +
218 | "- Inform the user about the retrieved information.\n" +
219 | "\n" +
220 | "Commands: function_ca",
221 | );
222 | expect(output).toBeDefined();
223 | expect(output.reasoning).toBe("Some reasoning");
224 | expect(output.plan).toBe(
225 | "- Inform the user about the retrieved information.",
226 | );
227 | expect(output.tellUser).toBe("");
228 | expect(output.commands).toStrictEqual([
229 | {
230 | name: "function_ca",
231 | args: {},
232 | },
233 | ]);
234 | expect(output.completed).toBe(false);
235 | });
236 | it("tell user mistakenly put under commands", () => {
237 | const output = parseOutput(
238 | "Reasoning: Some reasoning\n" +
239 | "\n" +
240 | "Plan:\n" +
241 | "- Inform the user about the retrieved information.\n" +
242 | "\n" +
243 | "Commands: I have completed my job.",
244 | );
245 | expect(output).toBeDefined();
246 | expect(output.reasoning).toBe("Some reasoning");
247 | expect(output.plan).toBe(
248 | "- Inform the user about the retrieved information.",
249 | );
250 | expect(output.tellUser).toBe("I have completed my job.");
251 | expect(output.commands).toStrictEqual([]);
252 | expect(output.completed).toBe(true);
253 | });
254 | it("tell user mistakenly put under commands but tell user already exists", () => {
255 | const output = parseOutput(
256 | "Reasoning: Some reasoning\n" +
257 | "\n" +
258 | "Tell user: There's something i'd like to tell you\n" +
259 | "\n" +
260 | "Plan:\n" +
261 | "- Inform the user about the retrieved information.\n" +
262 | "\n" +
263 | "Commands: I have completed my job.",
264 | );
265 | expect(output).toBeDefined();
266 | expect(output.reasoning).toBe("Some reasoning");
267 | expect(output.plan).toBe(
268 | "- Inform the user about the retrieved information.",
269 | );
270 | expect(output.tellUser).toBe("There's something i'd like to tell you");
271 | expect(output.commands).toStrictEqual([]);
272 | expect(output.completed).toBe(true);
273 | });
274 | it("incomplete commands aren't put into tell user", () => {
275 | const output = parseOutput(
276 | "Reasoning: Some reasoning\n" +
277 | "\n" +
278 | "Tell user: There's something i'd like to tell you\n" +
279 | "\n" +
280 | "Plan:\n" +
281 | "- Inform the user about the retrieved information.\n" +
282 | "\n" +
283 | "Commands: function_call(a=1, ",
284 | );
285 | expect(output).toBeDefined();
286 | expect(output.reasoning).toBe("Some reasoning");
287 | expect(output.plan).toBe(
288 | "- Inform the user about the retrieved information.",
289 | );
290 | expect(output.tellUser).toBe("There's something i'd like to tell you");
291 | expect(output.commands).toStrictEqual([]);
292 | expect(output.completed).toBe(true);
293 | });
294 | it("Commands: None should be skipped", () => {
295 | const output = parseOutput(
296 | "Reasoning: Some reasoning\n" +
297 | "\n" +
298 | "Tell user: There's something i'd like to tell you\n" +
299 | "\n" +
300 | "Plan:\n" +
301 | "- Inform the user about the retrieved information.\n" +
302 | "\n" +
303 | "Commands:\n" +
304 | "None",
305 | );
306 | expect(output).toBeDefined();
307 | expect(output.reasoning).toBe("Some reasoning");
308 | expect(output.plan).toBe(
309 | "- Inform the user about the retrieved information.",
310 | );
311 | expect(output.tellUser).toBe("There's something i'd like to tell you");
312 | expect(output.commands).toStrictEqual([]);
313 | expect(output.completed).toBe(true);
314 | });
315 | it("When writing 'Reasoning:', it shouldn't count as Tell user", () => {
316 | const output = parseOutput("Reason");
317 | expect(output).toBeDefined();
318 | expect(output.reasoning).toBe("");
319 | expect(output.plan).toBe("");
320 | expect(output.tellUser).toBe("");
321 | expect(output.commands).toStrictEqual([]);
322 | expect(output.completed).toBe(true);
323 | });
324 | it("Bug found when required args with no choice are filled in", () => {
325 | const output = parseOutput(
326 | "Reasoning: \nTo break down the listings by the number of guests allowed, we need to fetch all the listings and then perform data analysis on them to count the number of listings that allow a certain number of guests.\n\nPlan:\n- Fetch all listings using get_listings function.\n- Perform data analysis using perform_data_analysis function to count the number of listings for each guest capacity.\n\nCommands:\nget_listings(limit=\"\", start=\"\")\nperform_data_analysis(instruction='Count the number of listings for each guest capacity', type='bar')",
327 | );
328 | expect(output).toBeDefined();
329 | expect(output.reasoning).toBe(
330 | "To break down the listings by the number of guests allowed, we need to fetch all the listings and then perform data analysis on them to count the number of listings that allow a certain number of guests.",
331 | );
332 | expect(output.plan).toBe(
333 | "- Fetch all listings using get_listings function.\n- Perform data analysis using perform_data_analysis function to count the number of listings for each guest capacity.",
334 | );
335 | expect(output.tellUser).toBe("");
336 | expect(output.commands).toStrictEqual([
337 | { name: "get_listings", args: { limit: "", start: "" } },
338 | {
339 | name: "perform_data_analysis",
340 | args: {
341 | instruction: "Count the number of listings for each guest capacity",
342 | type: "bar",
343 | },
344 | },
345 | ]);
346 | expect(output.completed).toBe(false);
347 | });
348 | it("Real world", () => {
349 | const text = `I've found a variety of healthy vegetarian recipes for different meals of the day. Here's a suggested meal plan:
350 |
351 | ### Breakfast
352 | - **Avocado Toast with Tomato and Poached Egg**: A simple yet nutritious start to the day, featuring ripe avocados, fresh tomatoes, and eggs on whole-grain bread.
353 | - **Green Smoothie Bowl**: Blend spinach, banana, almond milk, and chia seeds for a refreshing and filling breakfast bowl.
354 |
355 | ### Lunch
356 | - **Quinoa Salad with Mixed Vegetables**: A hearty salad with quinoa, cucumbers, tomatoes, bell peppers, and a lemon vinaigrette.
357 | - **Lentil Soup**: Rich in protein and fiber, this soup is both satisfying and healthy.
358 |
359 | ### Dinner
360 | - **Portobello and Poblano Enchiladas**: Stuffed flour tortillas with thinly-sliced portobellos and poblanos topped with cheddar and queso fresco. [Epicurious](URL11)
361 | - **Butternut Squash Risotto**: Creamy risotto with roasted butternut squash makes for a comforting dinner. [The Mediterranean Dish](URL12)
362 |
363 | ### Snacks
364 | - **Famous Tomato Dip**: A quick blend of canned tomatoes, almonds, garlic, and olive oil. [A Couple Cooks](URL16)
365 | - **Crispy Roasted Chickpeas**: Spiced chickpeas roasted until crunchy. [MOON and spoon and yum](URL20)
366 |
367 | This meal plan provides a balance of nutrients across different meals while keeping the dishes varied and interesting.
368 |
369 | Sources:
370 | [Epicurious](URL11)
371 | [The Mediterranean Dish](URL12)
372 | [A Couple Cooks](URL16)
373 | [MOON and spoon and yum](URL20)`;
374 | const out = parseOutput(text);
375 | expect(out).toEqual({
376 | plan: "",
377 | reasoning: "",
378 | commands: [],
379 | tellUser: text,
380 | completed: true,
381 | });
382 | });
383 | it("Real world with bad commands text", () => {
384 | const text = `I've found a variety of healthy vegetarian recipes for different meals of the day. Here's a suggested meal plan:
385 |
386 | ### Breakfast
387 | - **Avocado Toast with Tomato and Poached Egg**: A simple yet nutritious start to the day, featuring ripe avocados, fresh tomatoes, and eggs on whole-grain bread.
388 | - **Green Smoothie Bowl**: Blend spinach, banana, almond milk, and chia seeds for a refreshing and filling breakfast bowl.
389 |
390 | ### Lunch
391 | - **Quinoa Salad with Mixed Vegetables**: A hearty salad with quinoa, cucumbers, tomatoes, bell peppers, and a lemon vinaigrette.
392 | - **Lentil Soup**: Rich in protein and fiber, this soup is both satisfying and healthy.
393 |
394 | ### Dinner
395 | - **Portobello and Poblano Enchiladas**: Stuffed flour tortillas with thinly-sliced portobellos and poblanos topped with cheddar and queso fresco. [Epicurious](URL11)
396 | - **Butternut Squash Risotto**: Creamy risotto with roasted butternut squash makes for a comforting dinner. [The Mediterranean Dish](URL12)
397 |
398 | ### Snacks
399 | - **Famous Tomato Dip**: A quick blend of canned tomatoes, almonds, garlic, and olive oil. [A Couple Cooks](URL16)
400 | - **Crispy Roasted Chickpeas**: Spiced chickpeas roasted until crunchy. [MOON and spoon and yum](URL20)
401 |
402 | This meal plan provides a balance of nutrients across different meals while keeping the dishes varied and interesting.
403 |
404 | Sources:
405 | [Epicurious](URL11)
406 | [The Mediterranean Dish](URL12)
407 | [A Couple Cooks](URL16)
408 | [MOON and spoon and yum](URL20)
409 |
410 | Commands:
411 | None, I don't need to do anything here`;
412 | const out = parseOutput(text);
413 | expect(out).toEqual({
414 | plan: "",
415 | reasoning: "",
416 | commands: [],
417 | tellUser: text.split("Commands:")[0].trim(),
418 | completed: true,
419 | });
420 | });
421 | it("Real world with array of objects", () => {
422 | const text = `
423 | Reasoning:
424 | 1. The user wants to create a new active builder with specific parameters.
425 | 2. The create_builder function is used to create new builders in the ERP system.
426 | 3. The user has provided all necessary parameters for the function.
427 |
428 | Commands:
429 | create_builder(DbName="hello", Active=True, ModuleId="123", OwnerType=1, Fields=[{"Name": "bye", "Label": "bye", "Type": 1, "Required": True}], Name="hello")`;
430 | const out = parseOutput(text);
431 | expect(out).toEqual({
432 | plan: "",
433 | reasoning:
434 | "1. The user wants to create a new active builder with specific parameters.\n2. The create_builder function is used to create new builders in the ERP system.\n3. The user has provided all necessary parameters for the function.",
435 | commands: [
436 | {
437 | name: "create_builder",
438 | args: {
439 | DbName: "hello",
440 | Active: true,
441 | ModuleId: "123",
442 | OwnerType: 1,
443 | Fields: [{ Name: "bye", Label: "bye", Type: 1, Required: true }],
444 | Name: "hello",
445 | },
446 | },
447 | ],
448 | tellUser: "",
449 | completed: false,
450 | });
451 | });
452 | });
453 |
454 | describe("parseFunctionCall", () => {
455 | it("hyphenated argument name", () => {
456 | const str = `get_account(gtmhub-accountId="64b17ac6548041a751aaf2f6", id_team="64b17ac6548041a751aaf2f7")`;
457 | const output = parseFunctionCall(str);
458 | const expectedOutput = {
459 | name: "get_account",
460 | args: {
461 | "gtmhub-accountId": "64b17ac6548041a751aaf2f6",
462 | id_team: "64b17ac6548041a751aaf2f7",
463 | },
464 | };
465 | expect(output).toStrictEqual(expectedOutput);
466 | });
467 | it("argument name with dots in", () => {
468 | const str = `list_accounts(data.account.availableBalanceFrom="1000")`;
469 | const output = parseFunctionCall(str);
470 | const expectedOutput = {
471 | name: "list_accounts",
472 | args: {
473 | "data.account.availableBalanceFrom": "1000",
474 | },
475 | };
476 | expect(output).toStrictEqual(expectedOutput);
477 | });
478 | it("argument name with space in skipped", () => {
479 | const str = `list_accounts(data availableBalanceFrom="1000")`;
480 | const output = parseFunctionCall(str);
481 | const expectedOutput = {
482 | name: "list_accounts",
483 | args: {
484 | availableBalanceFrom: "1000",
485 | },
486 | };
487 | expect(output).toStrictEqual(expectedOutput);
488 | });
489 | it("object passed to function", () => {
490 | const str = `create_goal(gtmhub-accountId='64b94e50c1815107739582f9', goal={"title": "Close sales"}, ownerIds=['64b94e50c1815107739582fa'], sessionId='64b94e50c1815107739582fc')`;
491 | const output = parseFunctionCall(str);
492 | const expectedOutput = {
493 | name: "create_goal",
494 | args: {
495 | "gtmhub-accountId": "64b94e50c1815107739582f9",
496 | goal: { title: "Close sales" },
497 | ownerIds: ["64b94e50c1815107739582fa"],
498 | sessionId: "64b94e50c1815107739582fc",
499 | },
500 | };
501 | expect(output).toStrictEqual(expectedOutput);
502 | });
503 |
504 | it("correctly parses function with floating point argument", () => {
505 | const str = `set_coordinates(x=3.14, y=0.98)`;
506 | const output = parseFunctionCall(str);
507 | const expectedOutput = {
508 | name: "set_coordinates",
509 | args: { x: 3.14, y: 0.98 },
510 | };
511 | expect(output).toEqual(expectedOutput);
512 | });
513 | it("correctly parses function mixed argument types", () => {
514 | const str = `set_coordinates(x=3.14, placeName="The Moon", y=0.98)`;
515 | const output = parseFunctionCall(str);
516 | const expectedOutput = {
517 | name: "set_coordinates",
518 | args: { x: 3.14, y: 0.98, placeName: "The Moon" },
519 | };
520 | expect(output).toEqual(expectedOutput);
521 | });
522 | it("string has a comma in it", () => {
523 | const str = `set_coordinates(x=3.14, placeName="The Moon, the sun", y=0.98)`;
524 | const output = parseFunctionCall(str);
525 | const expectedOutput = {
526 | name: "set_coordinates",
527 | args: { x: 3.14, y: 0.98, placeName: "The Moon, the sun" },
528 | };
529 | expect(output).toEqual(expectedOutput);
530 | });
531 | it("string has a comma and single quotes in it", () => {
532 | const str = `set_coordinates(x=3.14, placeName="The Moon, 'very nice eh', the sun", y=0.98)`;
533 | const output = parseFunctionCall(str);
534 | const expectedOutput = {
535 | name: "set_coordinates",
536 | args: {
537 | x: 3.14,
538 | y: 0.98,
539 | placeName: "The Moon, 'very nice eh', the sun",
540 | },
541 | };
542 | expect(output).toEqual(expectedOutput);
543 | });
544 | it("string has escaped quote in it", () => {
545 | const str = `set_coordinates(x=3.14, placeName="The Moon,\\" sun ", y=0.98)`;
546 | const output = parseFunctionCall(str);
547 | const expectedOutput = {
548 | name: "set_coordinates",
549 | args: {
550 | x: 3.14,
551 | y: 0.98,
552 | placeName: 'The Moon," sun ',
553 | },
554 | };
555 | expect(output).toEqual(expectedOutput);
556 | });
557 | it("returns function with no arguments when none are provided", () => {
558 | const str = `do_something()`;
559 | const output = parseFunctionCall(str);
560 | const expectedOutput = { name: "do_something", args: {} };
561 | expect(output).toEqual(expectedOutput);
562 | });
563 | it("throws an error when function call format is invalid", () => {
564 | const str = `getAccount "64b17ac6548041a751aaf2f6" "64b17ac6548041a751aaf2f7"`;
565 | expect(() => parseFunctionCall(str)).toThrowError(
566 | "Invalid function call format: " + str,
567 | );
568 | });
569 | it("array of dictionaries", () => {
570 | const commandText =
571 | 'create_report(reportName="Active Construction Users Report", description="Report showing most active construction industry users in last 30 days.", segmentId="{{id}}", timeframeDays=30, columns=[{"name": "User Activity","type": "number"},{"name": "User Industry","type": "string"}])';
572 | const output = parseFunctionCall(commandText);
573 | const expectedOutput = {
574 | name: "create_report",
575 | args: {
576 | reportName: "Active Construction Users Report",
577 | description:
578 | "Report showing most active construction industry users in last 30 days.",
579 | segmentId: "{{id}}",
580 | timeframeDays: 30,
581 | columns: [
582 | {
583 | name: "User Activity",
584 | type: "number",
585 | },
586 | {
587 | name: "User Industry",
588 | type: "string",
589 | },
590 | ],
591 | },
592 | };
593 | expect(output).toEqual(expectedOutput);
594 | });
595 | it("nested dictionaries", () => {
596 | const commandText = `create_account(workflow={"code": "client.sub-account"}, data={"account": {"clientId": "09f42c3a-dcea-4468-a77a-40f1e6d456f1", "currency": "USD", "mainAccountId": "74ef55ef-a583-4a96-92f2-b3ad3b5c0682"}})`;
597 | const output = parseFunctionCall(commandText);
598 | const expectedOutput = {
599 | name: "create_account",
600 | args: {
601 | workflow: { code: "client.sub-account" },
602 | data: {
603 | account: {
604 | clientId: "09f42c3a-dcea-4468-a77a-40f1e6d456f1",
605 | currency: "USD",
606 | mainAccountId: "74ef55ef-a583-4a96-92f2-b3ad3b5c0682",
607 | },
608 | },
609 | },
610 | };
611 | expect(output).toEqual(expectedOutput);
612 | });
613 | it("parse escaped quotes properly", () => {
614 | const out = parseFunctionCall(
615 | `search_filings(query="formType:\\"S-4\\" AND NOT formType:(\\"4/A\\" OR \\"S-4 POS\\")", ticker="AAPL")`,
616 | );
617 | expect(out).toStrictEqual({
618 | name: "search_filings",
619 | args: {
620 | query: 'formType:"S-4" AND NOT formType:("4/A" OR "S-4 POS")',
621 | ticker: "AAPL",
622 | },
623 | });
624 | });
625 | it("parse escaped quotes properly - single quotes", () => {
626 | const out = parseFunctionCall(
627 | `search_filings(query='formType:"S-4" AND NOT formType:("4/A" OR "S-4 POS")', ticker="AAPL")`,
628 | );
629 | expect(out).toStrictEqual({
630 | name: "search_filings",
631 | args: {
632 | query: 'formType:"S-4" AND NOT formType:("4/A" OR "S-4 POS")',
633 | ticker: "AAPL",
634 | },
635 | });
636 | });
637 | it("parse escaped quotes properly - backslash", () => {
638 | const out = parseFunctionCall(
639 | `perform_data_analysis(instruction='Break down Lucas\\' closed deals in the last 6 months by value')`,
640 | );
641 | expect(out).toStrictEqual({
642 | name: "perform_data_analysis",
643 | args: {
644 | instruction:
645 | "Break down Lucas' closed deals in the last 6 months by value",
646 | },
647 | });
648 | });
649 | it("parse okay when brackets forgotten", () => {
650 | const out = parseFunctionCall(`list_users`);
651 | expect(out).toStrictEqual({
652 | name: "list_users",
653 | args: {},
654 | });
655 | });
656 | it("replace backslash underscore with underscore in fn name and arg names, but not string values", () => {
657 | const out = parseFunctionCall(
658 | `update\\_property(property\\_id="ID\\_1", bedrooms=4)`,
659 | );
660 | expect(out).toStrictEqual({
661 | name: "update_property",
662 | args: { property_id: "ID\\_1", bedrooms: 4 },
663 | });
664 | });
665 | it("True with capital T, False with capital F", () => {
666 | const out = parseFunctionCall(
667 | `update\\_property(expand=True, go_away=False)`,
668 | );
669 | expect(out).toStrictEqual({
670 | name: "update_property",
671 | args: { expand: true, go_away: false },
672 | });
673 | });
674 | it("Numbered command", () => {
675 | const out = parseFunctionCall(
676 | `1. instruct_coder(instruction="Find all deals that were closed in the past 6 months. Then, calculate the total revenue generated by each sales rep from these deals. Finally, identify and return the name of the sales rep with the highest total revenue.")`,
677 | );
678 | expect(out).toStrictEqual({
679 | name: "instruct_coder",
680 | args: {
681 | instruction:
682 | "Find all deals that were closed in the past 6 months. Then, calculate the total revenue generated by each sales rep from these deals. Finally, identify and return the name of the sales rep with the highest total revenue.",
683 | },
684 | });
685 | });
686 | it("Commas between commands", () => {
687 | const out = parseFunctionCall(`item_get(id=9),`);
688 | expect(out).toStrictEqual({
689 | name: "item_get",
690 | args: {
691 | id: 9,
692 | },
693 | });
694 | });
695 | });
696 |
697 | describe("makeDoubleExternalQuotes", () => {
698 | it("single quotes with escaped double quotes", () => {
699 | const out = makeDoubleExternalQuotes(`'hello \\"world\\"'`);
700 | expect(out).toBe(`"hello \\"world\\""`);
701 | });
702 | });
703 |
--------------------------------------------------------------------------------
/__tests__/processObjectForDisplay.test.ts:
--------------------------------------------------------------------------------
1 | import { describe, expect, it } from "@jest/globals";
2 | import { processObjectForDisplay } from "../src/lib/utils";
3 |
4 | describe("remove single key nodes", () => {
5 | it("Handles empty object", () => {
6 | const data = {};
7 | const expected = {};
8 |
9 | expect(processObjectForDisplay(data)).toEqual(expected);
10 | });
11 |
12 | it("array returns same array", () => {
13 | const data = [1, 2, 3];
14 | const expected = [1, 2, 3];
15 |
16 | const output = processObjectForDisplay(data);
17 | expect(output).toEqual(expected);
18 | });
19 |
20 | it("special case single array", () => {
21 | const data = { oldGregg: [1, 2, 3] };
22 | const expected = [1, 2, 3];
23 | const output = processObjectForDisplay(data);
24 | expect(output).toEqual(expected);
25 | });
26 | it("nested special case", () => {
27 | const data = { root: { branch: { leaf: [1, 2, 3] } } };
28 | const expected = [1, 2, 3];
29 |
30 | expect(processObjectForDisplay(data)).toEqual(expected);
31 | });
32 | it("more complex nested special case", () => {
33 | const data = {
34 | a: {
35 | b: [
36 | { nice: 1, nested: { boy: 2 } },
37 | { nice: 2, nested: { boy: 3 } },
38 | ],
39 | },
40 | };
41 |
42 | const expected = [
43 | { nice: 1, nested: { boy: 2 } },
44 | { nice: 2, nested: { boy: 3 } },
45 | ];
46 |
47 | const output = processObjectForDisplay(data);
48 | expect(output).toEqual(expected);
49 | });
50 |
51 | it("array of objects", () => {
52 | const data = [
53 | { a: 1, b: 2, c: 3 },
54 | { a: 4, b: 5, c: 6 },
55 | ];
56 | const output = processObjectForDisplay(data);
57 | expect(output).toEqual(data);
58 | });
59 |
60 | it("single node key nested inside complex object", () => {
61 | const data = {
62 | umbrella: {
63 | responses: { data: [1, 2, 3] },
64 | theHitcher: "put you in the picture",
65 | tony: { harrison: "outrage" },
66 | },
67 | };
68 |
69 | const expected = {
70 | "umbrella -> responses -> data": [1, 2, 3],
71 | "umbrella -> theHitcher": "put you in the picture",
72 | "umbrella -> tony -> harrison": "outrage",
73 | };
74 | const output = processObjectForDisplay(data);
75 | expect(output).toEqual(expected);
76 | });
77 |
78 | it("Does not lose data for multiple nested single key", () => {
79 | const data = {
80 | outer: {
81 | middle: {
82 | inner: "value",
83 | },
84 | middle2: "value2",
85 | },
86 | };
87 |
88 | const expected = {
89 | "outer -> middle -> inner": "value",
90 | "outer -> middle2": "value2",
91 | };
92 |
93 | expect(processObjectForDisplay(data)).toEqual(expected);
94 | });
95 |
96 | it("Does not lose data for deeply nested structures", () => {
97 | const data = {
98 | first: {
99 | second: {
100 | third: {
101 | fourth: { fifth: "minor fall, major lift" },
102 | },
103 | other: "value2",
104 | },
105 | third: {
106 | fifth: [
107 | "i",
108 | "remember",
109 | "you",
110 | "well",
111 | "in",
112 | "the",
113 | "chelsea",
114 | "hotel",
115 | ],
116 | },
117 | },
118 | };
119 |
120 | const expected = {
121 | "first -> second -> third -> fourth -> fifth": "minor fall, major lift",
122 | "first -> second -> other": "value2",
123 | "first -> third -> fifth": [
124 | "i",
125 | "remember",
126 | "you",
127 | "well",
128 | "in",
129 | "the",
130 | "chelsea",
131 | "hotel",
132 | ],
133 | };
134 |
135 | expect(processObjectForDisplay(data)).toEqual(expected);
136 | });
137 |
138 | it("doesnt mutate original data", () => {
139 | const data = {
140 | first: {
141 | second: {
142 | third: {
143 | fourth: "value",
144 | },
145 | other: "value2",
146 | },
147 | third: {
148 | fifth: "value3",
149 | },
150 | },
151 | };
152 |
153 | const originalData = JSON.parse(JSON.stringify(data));
154 |
155 | const result = processObjectForDisplay(data);
156 | expect(data).toEqual(originalData);
157 | expect(result).not.toBe(data);
158 | });
159 |
160 | it("Array of single key not changed", () => {
161 | const data = [
162 | { make: "Alfa Romeo" },
163 | { make: "Ferrari" },
164 | { make: "Dodge" },
165 | { make: "Subaru" },
166 | { make: "Toyota" },
167 | { make: "Volkswagen" },
168 | { make: "Volvo" },
169 | { make: "Audi" },
170 | ];
171 |
172 | const result = processObjectForDisplay(data);
173 | expect(result).toEqual(data);
174 | });
175 | });
176 |
--------------------------------------------------------------------------------
/__tests__/removeUUIDs.test.ts:
--------------------------------------------------------------------------------
1 | import { removeUUIDs } from "../src/lib/utils";
2 |
3 | describe("removeUUIDs", () => {
4 | it("empty object", () => {
5 | expect(removeUUIDs({})).toEqual({});
6 | });
7 |
8 | it("simple object with no UUIDs", () => {
9 | expect(removeUUIDs({ a: "abc", b: "def" })).toEqual({ a: "abc", b: "def" });
10 | });
11 |
12 | it("simple object with UUIDs", () => {
13 | expect(
14 | removeUUIDs({ a: "abc", b: "3b241101-e2bb-4255-8caf-4136c566a964" }),
15 | ).toEqual({ a: "abc" });
16 | });
17 |
18 | it("nested object with UUIDs", () => {
19 | expect(
20 | removeUUIDs({
21 | a: "abc",
22 | b: { c: "3b241101-e2bb-4255-8caf-4136c566a964" },
23 | }),
24 | ).toEqual({ a: "abc", b: {} });
25 | });
26 |
27 | it("simple array with no UUIDs", () => {
28 | expect(removeUUIDs(["abc", "def"])).toEqual(["abc", "def"]);
29 | });
30 |
31 | it("simple array with UUIDs", () => {
32 | expect(
33 | removeUUIDs(["abc", "3b241101-e2bb-4255-8caf-4136c566a964"]),
34 | ).toEqual(["abc"]);
35 | });
36 |
37 | it("nested array with UUIDs", () => {
38 | expect(
39 | removeUUIDs([
40 | "abc",
41 | ["3b241101-e2bb-4255-8caf-4136c566a964", "cheese is a kind of meat"],
42 | ]),
43 | ).toEqual(["abc", ["cheese is a kind of meat"]]);
44 | });
45 |
46 | it("array of objects with UUIDs", () => {
47 | expect(
48 | removeUUIDs([{ a: "abc", b: "3b241101-e2bb-4255-8caf-4136c566a964" }]),
49 | ).toEqual([{ a: "abc" }]);
50 | });
51 |
52 | it("complex object and array with UUIDs", () => {
53 | expect(
54 | removeUUIDs({
55 | a: "abc",
56 | b: "3b241101-e2bb-4255-8caf-4136c566a964",
57 | c: ["def", "3b241101-e2bb-4255-8caf-4136c566a964"],
58 | }),
59 | ).toEqual({ a: "abc", c: ["def"] });
60 | });
61 |
62 | it("null object", () => {
63 | expect(removeUUIDs(null)).toEqual(null);
64 | });
65 |
66 | it("very nested object with UUIDs", () => {
67 | const input = {
68 | a: "abc",
69 | b: {
70 | c: "3b241101-e2bb-4255-8caf-4136c566a964",
71 | d: {
72 | e: "123",
73 | f: {
74 | g: "3b241101-e2bb-4255-8caf-4136c566a964",
75 | h: "456",
76 | },
77 | },
78 | },
79 | i: "def",
80 | };
81 | const expectedOutput = {
82 | a: "abc",
83 | b: { d: { e: "123", f: { h: "456" } } },
84 | i: "def",
85 | };
86 | expect(removeUUIDs(input)).toEqual(expectedOutput);
87 | });
88 |
89 | it("very nested array with UUIDs", () => {
90 | const input = [
91 | "abc",
92 | [
93 | "def",
94 | ["ghi", ["3b241101-e2bb-4255-8caf-4136c566a964", "jkl"], "mno"],
95 | "pqr",
96 | ],
97 | "stu",
98 | ];
99 | const expectedOutput = [
100 | "abc",
101 | ["def", ["ghi", ["jkl"], "mno"], "pqr"],
102 | "stu",
103 | ];
104 | expect(removeUUIDs(input)).toEqual(expectedOutput);
105 | });
106 | });
107 |
--------------------------------------------------------------------------------
/build.sh:
--------------------------------------------------------------------------------
1 | sed_command="sed -i"
2 |
3 | if [ "$(uname)" == "Darwin" ]; then
4 | # macOS
5 | sed_command="sed -i ''"
6 | fi
7 |
8 | rollup -c
9 | mv dist/src/index.d.ts dist/index.d.ts
10 | $sed_command 's/.\/components/.\/src\/components/g' dist/index.d.ts
11 | $sed_command 's/.\/lib/.\/src\/lib/g' dist/index.d.ts
--------------------------------------------------------------------------------
/examples/angular/.editorconfig:
--------------------------------------------------------------------------------
1 | # Editor configuration, see https://editorconfig.org
2 | root = true
3 |
4 | [*]
5 | charset = utf-8
6 | indent_style = space
7 | indent_size = 2
8 | insert_final_newline = true
9 | trim_trailing_whitespace = true
10 |
11 | [*.ts]
12 | quote_type = single
13 |
14 | [*.md]
15 | max_line_length = off
16 | trim_trailing_whitespace = false
17 |
--------------------------------------------------------------------------------
/examples/angular/.gitignore:
--------------------------------------------------------------------------------
1 | # See http://help.github.com/ignore-files/ for more about ignoring files.
2 |
3 | # Compiled output
4 | /dist
5 | /tmp
6 | /out-tsc
7 | /bazel-out
8 |
9 | # Node
10 | /node_modules
11 | npm-debug.log
12 | yarn-error.log
13 |
14 | # IDEs and editors
15 | .idea/
16 | .project
17 | .classpath
18 | .c9/
19 | *.launch
20 | .settings/
21 | *.sublime-workspace
22 |
23 | # Visual Studio Code
24 | .vscode/*
25 | !.vscode/settings.json
26 | !.vscode/tasks.json
27 | !.vscode/launch.json
28 | !.vscode/extensions.json
29 | .history/*
30 |
31 | # Miscellaneous
32 | /.angular/cache
33 | .sass-cache/
34 | /connect.lock
35 | /coverage
36 | /libpeerconnection.log
37 | testem.log
38 | /typings
39 |
40 | # System files
41 | .DS_Store
42 | Thumbs.db
43 |
--------------------------------------------------------------------------------
/examples/angular/README.md:
--------------------------------------------------------------------------------
1 | # Superflows-in-Angular Example
2 |
3 |
4 | [This commit has](https://github.com/Superflows-AI/chat-ui/pull/43/commits/38c0b52dcbd5bc533d24ff1fc0a83828e02acf5b) the full list of changes to add the `SuperflowsModal` to the project.
5 |
6 | To use this for real you'll need to change the `superflowsApiKey` to your in `src/app/chatUI.component.ts`. You can get an API key [here](https://dashboard.superflows.ai/api-settings) by signing up for a free account.
7 |
8 | ## Development server
9 |
10 | Run `ng serve` for a dev server. Navigate to `http://localhost:4200/`. The application will automatically reload if you change any of the source files.
11 |
12 | ## Code scaffolding
13 |
14 | Run `ng generate component component-name` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module`.
15 |
16 | ## Build
17 |
18 | Run `ng build` to build the project. The build artifacts will be stored in the `dist/` directory.
19 |
20 | ## Running unit tests
21 |
22 | Run `ng test` to execute the unit tests via [Karma](https://karma-runner.github.io).
23 |
24 | Note: This project was generated with [Angular CLI](https://github.com/angular/angular-cli) version 16.2.6.
25 |
--------------------------------------------------------------------------------
/examples/angular/angular.json:
--------------------------------------------------------------------------------
1 | {
2 | "$schema": "./node_modules/@angular/cli/lib/config/schema.json",
3 | "version": 1,
4 | "newProjectRoot": "projects",
5 | "projects": {
6 | "my-angular-app": {
7 | "projectType": "application",
8 | "schematics": {},
9 | "root": "",
10 | "sourceRoot": "src",
11 | "prefix": "app",
12 | "architect": {
13 | "build": {
14 | "builder": "@angular-devkit/build-angular:browser",
15 | "options": {
16 | "outputPath": "dist/my-angular-app",
17 | "index": "src/index.html",
18 | "main": "src/main.ts",
19 | "polyfills": [
20 | "zone.js"
21 | ],
22 | "tsConfig": "tsconfig.app.json",
23 | "assets": [
24 | "src/favicon.ico",
25 | "src/assets"
26 | ],
27 | "styles": [
28 | "src/styles.css"
29 | ],
30 | "scripts": []
31 | },
32 | "configurations": {
33 | "production": {
34 | "budgets": [
35 | {
36 | "type": "initial",
37 | "maximumWarning": "500kb",
38 | "maximumError": "1mb"
39 | },
40 | {
41 | "type": "anyComponentStyle",
42 | "maximumWarning": "2kb",
43 | "maximumError": "4kb"
44 | }
45 | ],
46 | "outputHashing": "all"
47 | },
48 | "development": {
49 | "buildOptimizer": false,
50 | "optimization": false,
51 | "vendorChunk": true,
52 | "extractLicenses": false,
53 | "sourceMap": true,
54 | "namedChunks": true
55 | }
56 | },
57 | "defaultConfiguration": "production"
58 | },
59 | "serve": {
60 | "builder": "@angular-devkit/build-angular:dev-server",
61 | "configurations": {
62 | "production": {
63 | "browserTarget": "my-angular-app:build:production"
64 | },
65 | "development": {
66 | "browserTarget": "my-angular-app:build:development"
67 | }
68 | },
69 | "defaultConfiguration": "development"
70 | },
71 | "extract-i18n": {
72 | "builder": "@angular-devkit/build-angular:extract-i18n",
73 | "options": {
74 | "browserTarget": "my-angular-app:build"
75 | }
76 | },
77 | "test": {
78 | "builder": "@angular-devkit/build-angular:karma",
79 | "options": {
80 | "polyfills": [
81 | "zone.js",
82 | "zone.js/testing"
83 | ],
84 | "tsConfig": "tsconfig.spec.json",
85 | "assets": [
86 | "src/favicon.ico",
87 | "src/assets"
88 | ],
89 | "styles": [
90 | "src/styles.css"
91 | ],
92 | "scripts": []
93 | }
94 | }
95 | }
96 | }
97 | }
98 | }
99 |
--------------------------------------------------------------------------------
/examples/angular/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "my-angular-app",
3 | "version": "0.0.0",
4 | "scripts": {
5 | "ng": "ng",
6 | "start": "ng serve",
7 | "build": "ng build",
8 | "watch": "ng build --watch --configuration development",
9 | "test": "ng test"
10 | },
11 | "private": true,
12 | "dependencies": {
13 | "@angular/animations": "^16.2.0",
14 | "@angular/common": "^16.2.0",
15 | "@angular/compiler": "^16.2.0",
16 | "@angular/core": "^16.2.0",
17 | "@angular/forms": "^16.2.0",
18 | "@angular/platform-browser": "^16.2.0",
19 | "@angular/platform-browser-dynamic": "^16.2.0",
20 | "@angular/router": "^16.2.0",
21 | "@superflows/chat-ui-react": "^1.2.61",
22 | "react-dom": "^18.2.0",
23 | "rxjs": "~7.8.0",
24 | "tslib": "^2.3.0",
25 | "zone.js": "~0.13.0"
26 | },
27 | "devDependencies": {
28 | "@angular-devkit/build-angular": "^16.2.6",
29 | "@angular/cli": "^16.2.6",
30 | "@angular/compiler-cli": "^16.2.0",
31 | "@types/jasmine": "~4.3.0",
32 | "@types/react-dom": "^18.2.13",
33 | "jasmine-core": "~4.6.0",
34 | "karma": "~6.4.0",
35 | "karma-chrome-launcher": "~3.2.0",
36 | "karma-coverage": "~2.2.0",
37 | "karma-jasmine": "~5.1.0",
38 | "karma-jasmine-html-reporter": "~2.1.0",
39 | "typescript": "~5.1.3"
40 | }
41 | }
42 |
--------------------------------------------------------------------------------
/examples/angular/src/app/app-routing.module.ts:
--------------------------------------------------------------------------------
1 | import { NgModule } from '@angular/core';
2 | import { RouterModule, Routes } from '@angular/router';
3 | import { ReactComponentWrapperComponent } from './chatUI.component';
4 |
5 | const routes: Routes = [
6 | { path: '', component: ReactComponentWrapperComponent },
7 | ];
8 |
9 | @NgModule({
10 | imports: [RouterModule.forRoot(routes)],
11 | exports: [RouterModule],
12 | })
13 | export class AppRoutingModule {}
14 |
--------------------------------------------------------------------------------
/examples/angular/src/app/app.component.css:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Superflows-AI/chat-ui/81005fd7622af9c2489fb638b1ba1af0b2d73277/examples/angular/src/app/app.component.css
--------------------------------------------------------------------------------
/examples/angular/src/app/app.component.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
304 |
305 |
306 | 
312 |
332 |
333 |
343 |
344 | {{ title }} app is running!
345 |
346 |
350 |
351 |
352 |
353 |
354 | Resources
355 |Here are some links to help you get started:
356 | 357 |
358 |
359 |
360 | Learn Angular
361 |
362 |
363 |
364 |
365 | CLI Documentation
366 |
367 |
368 |
369 |
370 |
371 | Angular Material
372 |
373 |
374 |
375 |
376 |
377 | Angular Blog
378 |
379 |
380 |
381 |
382 |
383 | Angular DevTools
384 |
385 |
386 |
387 |
388 |
389 |
390 | Next Steps
391 |What do you want to do next with your app?
392 | 393 | 394 | 395 |
396 |
400 |
401 |
405 |
406 |
410 |
411 |
415 |
416 |
420 |
421 |
425 |
426 |
427 |
428 |
429 |
436 |
437 |
438 | ng generate component xyz430 |
ng add @angular/material431 |
ng add @angular/pwa432 |
ng add _____433 |
ng test434 |
ng build435 |
439 |
440 |
444 |
445 |
446 |
447 |
452 |
453 |
454 |
455 |
456 |
468 |
469 |
473 |
474 |