@lobehub/lobehub 2.0.0-next.17 → 2.0.0-next.171

package/packages/conversation-flow/src/__tests__/fixtures/outputs/branch/nested.json

@@ -0,0 +1,405 @@
+{
+  "contextTree": [
+    {
+      "id": "msg-301",
+      "type": "message"
+    },
+    {
+      "activeBranchIndex": 0,
+      "branches": [
+        [
+          {
+            "id": "msg-302",
+            "type": "message"
+          },
+          {
+            "id": "msg-305",
+            "type": "message"
+          },
+          {
+            "activeBranchIndex": 1,
+            "branches": [
+              [
+                {
+                  "id": "msg-306",
+                  "type": "message"
+                }
+              ],
+              [
+                {
+                  "id": "msg-307",
+                  "type": "message"
+                },
+                {
+                  "id": "msg-310",
+                  "type": "message"
+                },
+                {
+                  "activeBranchIndex": 0,
+                  "branches": [
+                    [
+                      {
+                        "id": "msg-311",
+                        "type": "message"
+                      },
+                      {
+                        "id": "msg-314",
+                        "type": "message"
+                      },
+                      {
+                        "activeBranchIndex": 1,
+                        "branches": [
+                          [
+                            {
+                              "id": "msg-315",
+                              "type": "message"
+                            }
+                          ],
+                          [
+                            {
+                              "id": "msg-316",
+                              "type": "message"
+                            }
+                          ]
+                        ],
+                        "id": "branch-msg-314-0",
+                        "parentMessageId": "msg-314",
+                        "type": "branch"
+                      }
+                    ],
+                    [
+                      {
+                        "id": "msg-312",
+                        "type": "message"
+                      }
+                    ]
+                  ],
+                  "id": "branch-msg-310-1",
+                  "parentMessageId": "msg-310",
+                  "type": "branch"
+                }
+              ]
+            ],
+            "id": "branch-msg-305-2",
+            "parentMessageId": "msg-305",
+            "type": "branch"
+          }
+        ],
+        [
+          {
+            "id": "msg-303",
+            "type": "message"
+          }
+        ],
+        [
+          {
+            "id": "msg-304",
+            "type": "message"
+          }
+        ]
+      ],
+      "id": "branch-msg-301-3",
+      "parentMessageId": "msg-301",
+      "type": "branch"
+    }
+  ],
+  "flatList": [
+    {
+      "id": "msg-301",
+      "role": "user",
+      "content": "What's your favorite programming paradigm?",
+      "parentId": null,
+      "createdAt": 1704067200000,
+      "updatedAt": 1704067200000,
+      "meta": {},
+      "branch": {
+        "activeBranchIndex": 0,
+        "count": 3
+      }
+    },
+    {
+      "id": "msg-302",
+      "role": "assistant",
+      "content": "I appreciate functional programming for its elegance.",
+      "parentId": "msg-301",
+      "createdAt": 1704067202000,
+      "updatedAt": 1704067202000,
+      "meta": {},
+      "metadata": {
+        "totalInputTokens": 10,
+        "totalOutputTokens": 15,
+        "totalTokens": 25,
+        "cost": 0.00008
+      }
+    },
+    {
+      "id": "msg-305",
+      "role": "user",
+      "content": "Can you explain more about functional programming?",
+      "parentId": "msg-302",
+      "createdAt": 1704067210000,
+      "updatedAt": 1704067210000,
+      "meta": {},
+      "metadata": {
+        "activeBranchIndex": 1
+      },
+      "branch": {
+        "activeBranchIndex": 1,
+        "count": 2
+      }
+    },
+    {
+      "id": "msg-307",
+      "role": "assistant",
+      "content": "In functional programming, functions are first-class citizens and side effects are minimized.",
+      "parentId": "msg-305",
+      "createdAt": 1704067212100,
+      "updatedAt": 1704067212100,
+      "meta": {},
+      "metadata": {
+        "totalInputTokens": 30,
+        "totalOutputTokens": 22,
+        "totalTokens": 52,
+        "cost": 0.00016
+      }
+    },
+    {
+      "id": "msg-310",
+      "role": "user",
+      "content": "What are some benefits of immutability?",
+      "parentId": "msg-307",
+      "createdAt": 1704067220000,
+      "updatedAt": 1704067220000,
+      "meta": {},
+      "branch": {
+        "activeBranchIndex": 0,
+        "count": 2
+      }
+    },
+    {
+      "id": "msg-311",
+      "role": "assistant",
+      "content": "Immutability prevents bugs from unexpected data changes.",
+      "parentId": "msg-310",
+      "createdAt": 1704067222000,
+      "updatedAt": 1704067222000,
+      "meta": {},
+      "metadata": {
+        "totalInputTokens": 55,
+        "totalOutputTokens": 16,
+        "totalTokens": 71,
+        "cost": 0.00021
+      }
+    },
+    {
+      "id": "msg-314",
+      "role": "user",
+      "content": "Can you give me an example?",
+      "parentId": "msg-311",
+      "createdAt": 1704067230000,
+      "updatedAt": 1704067230000,
+      "meta": {},
+      "metadata": {
+        "activeBranchIndex": 1
+      },
+      "branch": {
+        "activeBranchIndex": 1,
+        "count": 2
+      }
+    },
+    {
+      "id": "msg-316",
+      "role": "assistant",
+      "content": "Here's a better example: Instead of mutating an array with push(), functional programming uses methods like concat() or the spread operator to create new arrays.",
+      "parentId": "msg-314",
+      "createdAt": 1704067232100,
+      "updatedAt": 1704067232100,
+      "meta": {},
+      "metadata": {
+        "totalInputTokens": 75,
+        "totalOutputTokens": 42,
+        "totalTokens": 117,
+        "cost": 0.00035
+      }
+    }
+  ],
+  "messageMap": {
+    "msg-301": {
+      "id": "msg-301",
+      "role": "user",
+      "content": "What's your favorite programming paradigm?",
+      "parentId": null,
+      "createdAt": 1704067200000,
+      "updatedAt": 1704067200000,
+      "meta": {}
+    },
+    "msg-302": {
+      "id": "msg-302",
+      "role": "assistant",
+      "content": "I appreciate functional programming for its elegance.",
+      "parentId": "msg-301",
+      "createdAt": 1704067202000,
+      "updatedAt": 1704067202000,
+      "meta": {},
+      "metadata": {
+        "totalInputTokens": 10,
+        "totalOutputTokens": 15,
+        "totalTokens": 25,
+        "cost": 0.00008
+      }
+    },
+    "msg-303": {
+      "id": "msg-303",
+      "role": "assistant",
+      "content": "Object-oriented programming offers great structure.",
+      "parentId": "msg-301",
+      "createdAt": 1704067202100,
+      "updatedAt": 1704067202100,
+      "meta": {},
+      "metadata": {
+        "totalInputTokens": 10,
+        "totalOutputTokens": 12,
+        "totalTokens": 22,
+        "cost": 0.00007
+      }
+    },
+    "msg-304": {
+      "id": "msg-304",
+      "role": "assistant",
+      "content": "Procedural programming is straightforward and efficient.",
+      "parentId": "msg-301",
+      "createdAt": 1704067202200,
+      "updatedAt": 1704067202200,
+      "meta": {},
+      "metadata": {
+        "totalInputTokens": 10,
+        "totalOutputTokens": 13,
+        "totalTokens": 23,
+        "cost": 0.000069
+      }
+    },
+    "msg-305": {
+      "id": "msg-305",
+      "role": "user",
+      "content": "Can you explain more about functional programming?",
+      "parentId": "msg-302",
+      "createdAt": 1704067210000,
+      "updatedAt": 1704067210000,
+      "meta": {},
+      "metadata": {
+        "activeBranchIndex": 1
+      }
+    },
+    "msg-306": {
+      "id": "msg-306",
+      "role": "assistant",
+      "content": "Functional programming focuses on pure functions and immutability.",
+      "parentId": "msg-305",
+      "createdAt": 1704067212000,
+      "updatedAt": 1704067212000,
+      "meta": {},
+      "metadata": {
+        "totalInputTokens": 30,
+        "totalOutputTokens": 18,
+        "totalTokens": 48,
+        "cost": 0.00014
+      }
+    },
+    "msg-307": {
+      "id": "msg-307",
+      "role": "assistant",
+      "content": "In functional programming, functions are first-class citizens and side effects are minimized.",
+      "parentId": "msg-305",
+      "createdAt": 1704067212100,
+      "updatedAt": 1704067212100,
+      "meta": {},
+      "metadata": {
+        "totalInputTokens": 30,
+        "totalOutputTokens": 22,
+        "totalTokens": 52,
+        "cost": 0.00016
+      }
+    },
+    "msg-310": {
+      "id": "msg-310",
+      "role": "user",
+      "content": "What are some benefits of immutability?",
+      "parentId": "msg-307",
+      "createdAt": 1704067220000,
+      "updatedAt": 1704067220000,
+      "meta": {}
+    },
+    "msg-311": {
+      "id": "msg-311",
+      "role": "assistant",
+      "content": "Immutability prevents bugs from unexpected data changes.",
+      "parentId": "msg-310",
+      "createdAt": 1704067222000,
+      "updatedAt": 1704067222000,
+      "meta": {},
+      "metadata": {
+        "totalInputTokens": 55,
+        "totalOutputTokens": 16,
+        "totalTokens": 71,
+        "cost": 0.00021
+      }
+    },
+    "msg-312": {
+      "id": "msg-312",
+      "role": "assistant",
+      "content": "It makes code easier to reason about and test.",
+      "parentId": "msg-310",
+      "createdAt": 1704067222100,
+      "updatedAt": 1704067222100,
+      "meta": {},
+      "metadata": {
+        "totalInputTokens": 55,
+        "totalOutputTokens": 14,
+        "totalTokens": 69,
+        "cost": 0.0002
+      }
+    },
+    "msg-314": {
+      "id": "msg-314",
+      "role": "user",
+      "content": "Can you give me an example?",
+      "parentId": "msg-311",
+      "createdAt": 1704067230000,
+      "updatedAt": 1704067230000,
+      "meta": {},
+      "metadata": {
+        "activeBranchIndex": 1
+      }
+    },
+    "msg-315": {
+      "id": "msg-315",
+      "role": "assistant",
+      "content": "Sure! In JavaScript, using `const` with arrays means you can't reassign the variable, but you can still modify the array with push/pop.",
+      "parentId": "msg-314",
+      "createdAt": 1704067232000,
+      "updatedAt": 1704067232000,
+      "meta": {},
+      "metadata": {
+        "totalInputTokens": 75,
+        "totalOutputTokens": 35,
+        "totalTokens": 110,
+        "cost": 0.00033
+      }
+    },
+    "msg-316": {
+      "id": "msg-316",
+      "role": "assistant",
+      "content": "Here's a better example: Instead of mutating an array with push(), functional programming uses methods like concat() or the spread operator to create new arrays.",
+      "parentId": "msg-314",
+      "createdAt": 1704067232100,
+      "updatedAt": 1704067232100,
+      "meta": {},
+      "metadata": {
+        "totalInputTokens": 75,
+        "totalOutputTokens": 42,
+        "totalTokens": 117,
+        "cost": 0.00035
+      }
+    }
+  }
+}

package/packages/conversation-flow/src/__tests__/fixtures/outputs/compare/index.ts

@@ -0,0 +1,8 @@
+import type { SerializedParseResult } from '../..';
+import simple from './simple.json';
+import withTools from './with-tools.json';
+
+export const compare = {
+  simple: simple as unknown as SerializedParseResult,
+  withTools: withTools as unknown as SerializedParseResult,
+};

package/packages/conversation-flow/src/__tests__/fixtures/outputs/compare/simple.json

@@ -0,0 +1,224 @@
+{
+  "contextTree": [
+    {
+      "id": "msg-601",
+      "type": "message"
+    },
+    {
+      "activeColumnId": "msg-603",
+      "columns": [
+        [
+          {
+            "id": "msg-602",
+            "type": "message"
+          }
+        ],
+        [
+          {
+            "id": "msg-603",
+            "type": "message"
+          }
+        ]
+      ],
+      "id": "compare-msg-601-msg-602-msg-603",
+      "messageId": "msg-601",
+      "type": "compare"
+    },
+    {
+      "id": "msg-604",
+      "type": "message"
+    },
+    {
+      "id": "msg-605",
+      "type": "message"
+    }
+  ],
+  "flatList": [
+    {
+      "id": "msg-601",
+      "role": "user",
+      "content": "Should I use REST or GraphQL for my API?",
+      "parentId": null,
+      "createdAt": 1704067200000,
+      "updatedAt": 1704067200000,
+      "meta": {},
+      "metadata": {
+        "compare": true
+      }
+    },
+    {
+      "activeColumnId": "msg-603",
+      "columns": [
+        [
+          {
+            "id": "msg-602",
+            "role": "assistant",
+            "content": "**REST is a great choice:**\n\nREST is simple, well-understood, and has excellent caching support. It's perfect for:\n\n- CRUD operations\n- Public APIs\n- Mobile apps with limited bandwidth\n- Teams familiar with HTTP conventions\n\n**Advantages:**\n- HTTP caching works out of the box\n- Stateless architecture\n- Wide tooling support\n- Easy to learn\n\n**Trade-offs:**\n- Over-fetching/under-fetching data\n- Multiple endpoints to maintain\n- Versioning can be complex",
+            "parentId": "msg-601",
+            "model": "gpt-4",
+            "provider": "openai",
+            "createdAt": 1704067205000,
+            "updatedAt": 1704067205000,
+            "meta": {},
+            "metadata": {
+              "totalInputTokens": 12,
+              "totalOutputTokens": 145,
+              "totalTokens": 157,
+              "cost": 0.00471,
+              "tps": 42,
+              "ttft": 387,
+              "duration": 3452,
+              "latency": 3839
+            }
+          }
+        ],
+        [
+          {
+            "id": "msg-603",
+            "role": "assistant",
+            "content": "**GraphQL offers more flexibility:**\n\nGraphQL provides a powerful query language that lets clients request exactly what they need. It's ideal for:\n\n- Complex data relationships\n- Multiple client types (web, mobile, desktop)\n- Rapidly evolving requirements\n- Real-time applications\n\n**Advantages:**\n- Single endpoint\n- No over-fetching\n- Strong typing with schema\n- Powerful developer tools\n\n**Trade-offs:**\n- Steeper learning curve\n- More complex server setup\n- Caching requires extra effort\n- Can be overkill for simple APIs",
+            "parentId": "msg-601",
+            "model": "claude-3-5-sonnet-20241022",
+            "provider": "anthropic",
+            "createdAt": 1704067205100,
+            "updatedAt": 1704067205100,
+            "meta": {},
+            "metadata": {
+              "totalInputTokens": 12,
+              "totalOutputTokens": 158,
+              "totalTokens": 170,
+              "cost": 0.00085,
+              "tps": 51,
+              "ttft": 298,
+              "duration": 3098,
+              "latency": 3396,
+              "activeColumn": true
+            }
+          }
+        ]
+      ],
+      "content": "",
+      "createdAt": 1704067205000,
+      "extra": {
+        "parentMessageId": "msg-601"
+      },
+      "id": "compare-msg-601-msg-602-msg-603",
+      "meta": {},
+      "role": "compare",
+      "updatedAt": 1704067205100
+    },
+    {
+      "id": "msg-604",
+      "role": "user",
+      "content": "What about performance differences?",
+      "parentId": "msg-603",
+      "createdAt": 1704067215000,
+      "updatedAt": 1704067215000,
+      "meta": {}
+    },
+    {
+      "id": "msg-605",
+      "role": "assistant",
+      "content": "Performance-wise, both can be highly performant when implemented correctly:\n\n**REST Performance:**\n- Leverages HTTP caching (CDNs, browser cache)\n- Simpler server logic = faster response times\n- Can over-fetch data, wasting bandwidth\n\n**GraphQL Performance:**\n- Eliminates over-fetching, reducing payload size\n- Single request vs. multiple REST calls\n- Requires query complexity analysis to prevent abuse\n- DataLoader pattern helps with N+1 queries\n\n**Recommendation:** For your use case, if you're building a simple CRUD API, REST will likely perform better with less effort. If you need flexible data fetching across multiple clients, GraphQL's efficiency gains will outweigh the setup complexity.",
+      "parentId": "msg-604",
+      "createdAt": 1704067217000,
+      "updatedAt": 1704067217000,
+      "meta": {},
+      "metadata": {
+        "totalInputTokens": 182,
+        "totalOutputTokens": 167,
+        "totalTokens": 349,
+        "cost": 0.001745,
+        "tps": 48,
+        "ttft": 345,
+        "duration": 3479,
+        "latency": 3824
+      }
+    }
+  ],
+  "messageMap": {
+    "msg-601": {
+      "id": "msg-601",
+      "role": "user",
+      "content": "Should I use REST or GraphQL for my API?",
+      "parentId": null,
+      "createdAt": 1704067200000,
+      "updatedAt": 1704067200000,
+      "meta": {},
+      "metadata": {
+        "compare": true
+      }
+    },
+    "msg-602": {
+      "id": "msg-602",
+      "role": "assistant",
+      "content": "**REST is a great choice:**\n\nREST is simple, well-understood, and has excellent caching support. It's perfect for:\n\n- CRUD operations\n- Public APIs\n- Mobile apps with limited bandwidth\n- Teams familiar with HTTP conventions\n\n**Advantages:**\n- HTTP caching works out of the box\n- Stateless architecture\n- Wide tooling support\n- Easy to learn\n\n**Trade-offs:**\n- Over-fetching/under-fetching data\n- Multiple endpoints to maintain\n- Versioning can be complex",
+      "parentId": "msg-601",
+      "model": "gpt-4",
+      "provider": "openai",
+      "createdAt": 1704067205000,
+      "updatedAt": 1704067205000,
+      "meta": {},
+      "metadata": {
+        "totalInputTokens": 12,
+        "totalOutputTokens": 145,
+        "totalTokens": 157,
+        "cost": 0.00471,
+        "tps": 42,
+        "ttft": 387,
+        "duration": 3452,
+        "latency": 3839
+      }
+    },
+    "msg-603": {
+      "id": "msg-603",
+      "role": "assistant",
+      "content": "**GraphQL offers more flexibility:**\n\nGraphQL provides a powerful query language that lets clients request exactly what they need. It's ideal for:\n\n- Complex data relationships\n- Multiple client types (web, mobile, desktop)\n- Rapidly evolving requirements\n- Real-time applications\n\n**Advantages:**\n- Single endpoint\n- No over-fetching\n- Strong typing with schema\n- Powerful developer tools\n\n**Trade-offs:**\n- Steeper learning curve\n- More complex server setup\n- Caching requires extra effort\n- Can be overkill for simple APIs",
+      "parentId": "msg-601",
+      "model": "claude-3-5-sonnet-20241022",
+      "provider": "anthropic",
+      "createdAt": 1704067205100,
+      "updatedAt": 1704067205100,
+      "meta": {},
+      "metadata": {
+        "totalInputTokens": 12,
+        "totalOutputTokens": 158,
+        "totalTokens": 170,
+        "cost": 0.00085,
+        "tps": 51,
+        "ttft": 298,
+        "duration": 3098,
+        "latency": 3396,
+        "activeColumn": true
+      }
+    },
+    "msg-604": {
+      "id": "msg-604",
+      "role": "user",
+      "content": "What about performance differences?",
+      "parentId": "msg-603",
+      "createdAt": 1704067215000,
+      "updatedAt": 1704067215000,
+      "meta": {}
+    },
+    "msg-605": {
+      "id": "msg-605",
+      "role": "assistant",
+      "content": "Performance-wise, both can be highly performant when implemented correctly:\n\n**REST Performance:**\n- Leverages HTTP caching (CDNs, browser cache)\n- Simpler server logic = faster response times\n- Can over-fetch data, wasting bandwidth\n\n**GraphQL Performance:**\n- Eliminates over-fetching, reducing payload size\n- Single request vs. multiple REST calls\n- Requires query complexity analysis to prevent abuse\n- DataLoader pattern helps with N+1 queries\n\n**Recommendation:** For your use case, if you're building a simple CRUD API, REST will likely perform better with less effort. If you need flexible data fetching across multiple clients, GraphQL's efficiency gains will outweigh the setup complexity.",
+      "parentId": "msg-604",
+      "createdAt": 1704067217000,
+      "updatedAt": 1704067217000,
+      "meta": {},
+      "metadata": {
+        "totalInputTokens": 182,
+        "totalOutputTokens": 167,
+        "totalTokens": 349,
+        "cost": 0.001745,
+        "tps": 48,
+        "ttft": 345,
+        "duration": 3479,
+        "latency": 3824
+      }
+    }
+  }
+}