@lobehub/lobehub 2.0.0-next.32 → 2.0.0-next.33

package/packages/conversation-flow/src/__tests__/fixtures/inputs/branch/assistant-branch.json

@@ -0,0 +1,96 @@
+[
+  {
+    "id": "msg-401",
+    "role": "user",
+    "content": "Can you help me write a function to calculate fibonacci?",
+    "parentId": null,
+    "createdAt": 1704067200000,
+    "updatedAt": 1704067200000,
+    "meta": {}
+  },
+  {
+    "id": "msg-402",
+    "role": "assistant",
+    "content": "I'll help you write a fibonacci function.",
+    "parentId": "msg-401",
+    "createdAt": 1704067202000,
+    "updatedAt": 1704067202000,
+    "meta": {},
+    "metadata": {
+      "totalInputTokens": 15,
+      "totalOutputTokens": 12,
+      "totalTokens": 27,
+      "cost": 0.00008,
+      "activeBranchIndex": 1
+    }
+  },
+  {
+    "id": "msg-403",
+    "role": "assistant",
+    "content": "Here's a recursive implementation:\n\n```python\ndef fibonacci(n):\n    if n <= 1:\n        return n\n    return fibonacci(n-1) + fibonacci(n-2)\n```",
+    "parentId": "msg-402",
+    "createdAt": 1704067205000,
+    "updatedAt": 1704067205000,
+    "meta": {},
+    "metadata": {
+      "totalInputTokens": 30,
+      "totalOutputTokens": 45,
+      "totalTokens": 75,
+      "cost": 0.00022
+    }
+  },
+  {
+    "id": "msg-404",
+    "role": "assistant",
+    "content": "Here's an iterative approach which is more efficient:\n\n```python\ndef fibonacci(n):\n    if n <= 1:\n        return n\n    a, b = 0, 1\n    for _ in range(2, n + 1):\n        a, b = b, a + b\n    return b\n```",
+    "parentId": "msg-402",
+    "createdAt": 1704067205100,
+    "updatedAt": 1704067205100,
+    "meta": {},
+    "metadata": {
+      "totalInputTokens": 30,
+      "totalOutputTokens": 52,
+      "totalTokens": 82,
+      "cost": 0.00025
+    }
+  },
+  {
+    "id": "msg-405",
+    "role": "assistant",
+    "content": "Let me show you a dynamic programming solution:\n\n```python\ndef fibonacci(n):\n    if n <= 1:\n        return n\n    dp = [0, 1]\n    for i in range(2, n + 1):\n        dp.append(dp[i-1] + dp[i-2])\n    return dp[n]\n```",
+    "parentId": "msg-402",
+    "createdAt": 1704067205200,
+    "updatedAt": 1704067205200,
+    "meta": {},
+    "metadata": {
+      "totalInputTokens": 30,
+      "totalOutputTokens": 58,
+      "totalTokens": 88,
+      "cost": 0.00026
+    }
+  },
+  {
+    "id": "msg-406",
+    "role": "user",
+    "content": "The iterative approach looks good! Can you add some comments?",
+    "parentId": "msg-404",
+    "createdAt": 1704067215000,
+    "updatedAt": 1704067215000,
+    "meta": {}
+  },
+  {
+    "id": "msg-407",
+    "role": "assistant",
+    "content": "Sure! Here's the commented version:\n\n```python\ndef fibonacci(n):\n    # Base cases\n    if n <= 1:\n        return n\n    \n    # Initialize first two fibonacci numbers\n    a, b = 0, 1\n    \n    # Iterate from 2 to n\n    for _ in range(2, n + 1):\n        # Calculate next fibonacci number\n        a, b = b, a + b\n    \n    return b\n```",
+    "parentId": "msg-406",
+    "createdAt": 1704067217000,
+    "updatedAt": 1704067217000,
+    "meta": {},
+    "metadata": {
+      "totalInputTokens": 95,
+      "totalOutputTokens": 78,
+      "totalTokens": 173,
+      "cost": 0.00052
+    }
+  }
+]

package/packages/conversation-flow/src/__tests__/fixtures/inputs/branch/assistant-user-branch.json

@@ -0,0 +1,123 @@
+[
+  {
+    "id": "msg-501",
+    "role": "user",
+    "content": "What's the difference between map and forEach in JavaScript?",
+    "parentId": null,
+    "createdAt": 1704067200000,
+    "updatedAt": 1704067200000,
+    "meta": {}
+  },
+  {
+    "id": "msg-502",
+    "role": "assistant",
+    "content": "The main difference is that `map()` returns a new array with transformed elements, while `forEach()` just iterates and returns undefined. Map is better for transformations, forEach is better for side effects.",
+    "parentId": "msg-501",
+    "createdAt": 1704067202000,
+    "updatedAt": 1704067202000,
+    "meta": {},
+    "metadata": {
+      "totalInputTokens": 18,
+      "totalOutputTokens": 42,
+      "totalTokens": 60,
+      "cost": 0.00018,
+      "activeBranchIndex": 1
+    }
+  },
+  {
+    "id": "msg-503",
+    "role": "user",
+    "content": "Can you show me a practical example?",
+    "parentId": "msg-502",
+    "createdAt": 1704067210000,
+    "updatedAt": 1704067210000,
+    "meta": {}
+  },
+  {
+    "id": "msg-504",
+    "role": "assistant",
+    "content": "Sure! Here's a practical example:\n\n```javascript\nconst numbers = [1, 2, 3, 4, 5];\n\n// Using map - creates new array\nconst doubled = numbers.map(n => n * 2);\nconsole.log(doubled); // [2, 4, 6, 8, 10]\n\n// Using forEach - just iterates\nnumbers.forEach(n => console.log(n * 2));\n// Prints: 2, 4, 6, 8, 10\n```",
+    "parentId": "msg-503",
+    "createdAt": 1704067212000,
+    "updatedAt": 1704067212000,
+    "meta": {},
+    "metadata": {
+      "totalInputTokens": 68,
+      "totalOutputTokens": 95,
+      "totalTokens": 163,
+      "cost": 0.00049
+    }
+  },
+  {
+    "id": "msg-505",
+    "role": "user",
+    "content": "Thanks! What about performance differences?",
+    "parentId": "msg-504",
+    "createdAt": 1704067220000,
+    "updatedAt": 1704067220000,
+    "meta": {}
+  },
+  {
+    "id": "msg-506",
+    "role": "assistant",
+    "content": "Performance-wise, forEach is slightly faster because it doesn't create a new array. However, the difference is negligible for most use cases. Choose based on functionality: use map when you need the transformed array, use forEach when you just need to iterate.",
+    "parentId": "msg-505",
+    "createdAt": 1704067222000,
+    "updatedAt": 1704067222000,
+    "meta": {},
+    "metadata": {
+      "totalInputTokens": 175,
+      "totalOutputTokens": 58,
+      "totalTokens": 233,
+      "cost": 0.0007
+    }
+  },
+  {
+    "id": "msg-507",
+    "role": "user",
+    "content": "Can you explain the technical implementation details?",
+    "parentId": "msg-502",
+    "createdAt": 1704067210100,
+    "updatedAt": 1704067210100,
+    "meta": {}
+  },
+  {
+    "id": "msg-508",
+    "role": "assistant",
+    "content": "Certainly! From a technical perspective:\n\n**map():**\n- Allocates a new array in memory\n- Iterates through each element\n- Applies the callback function\n- Stores the result in the new array\n- Returns the new array\n\n**forEach():**\n- Iterates through each element\n- Applies the callback function\n- Discards the return value\n- Returns undefined",
+    "parentId": "msg-507",
+    "createdAt": 1704067212100,
+    "updatedAt": 1704067212100,
+    "meta": {},
+    "metadata": {
+      "totalInputTokens": 68,
+      "totalOutputTokens": 82,
+      "totalTokens": 150,
+      "cost": 0.00045
+    }
+  },
+  {
+    "id": "msg-509",
+    "role": "user",
+    "content": "What about memory usage?",
+    "parentId": "msg-508",
+    "createdAt": 1704067220100,
+    "updatedAt": 1704067220100,
+    "meta": {}
+  },
+  {
+    "id": "msg-510",
+    "role": "assistant",
+    "content": "Great question! Map uses more memory because it creates a new array. If you have a large dataset (millions of items) and don't need the result array, forEach is more memory-efficient. However, if you're doing functional programming and need immutability, the memory overhead of map is usually worth it.",
+    "parentId": "msg-509",
+    "createdAt": 1704067222100,
+    "updatedAt": 1704067222100,
+    "meta": {},
+    "metadata": {
+      "totalInputTokens": 160,
+      "totalOutputTokens": 68,
+      "totalTokens": 228,
+      "cost": 0.00068
+    }
+  }
+]

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

@@ -0,0 +1,128 @@
+[
+  {
+    "id": "msg-201",
+    "role": "user",
+    "content": "Write a haiku about programming",
+    "parentId": null,
+    "createdAt": 1704067200000,
+    "updatedAt": 1704067200000,
+    "meta": {}
+  },
+  {
+    "id": "msg-202",
+    "role": "assistant",
+    "content": "Code flows like water,\nBugs hide in silent shadows,\nDebug brings the light.",
+    "parentId": "msg-201",
+    "createdAt": 1704067203000,
+    "updatedAt": 1704067203000,
+    "meta": {},
+    "metadata": {
+      "totalInputTokens": 12,
+      "totalOutputTokens": 28,
+      "totalTokens": 40,
+      "cost": 0.00012
+    }
+  },
+  {
+    "id": "msg-203",
+    "role": "assistant",
+    "content": "Functions compile,\nVariables dance in memory,\nAlgorithm sings.",
+    "parentId": "msg-201",
+    "createdAt": 1704067203100,
+    "updatedAt": 1704067203100,
+    "meta": {},
+    "metadata": {
+      "totalInputTokens": 12,
+      "totalOutputTokens": 24,
+      "totalTokens": 36,
+      "cost": 0.000108
+    }
+  },
+  {
+    "id": "msg-204",
+    "role": "assistant",
+    "content": "Lines of logic flow,\nErrors break the peaceful code,\nTests restore the calm.",
+    "parentId": "msg-201",
+    "createdAt": 1704067203200,
+    "updatedAt": 1704067203200,
+    "meta": {},
+    "metadata": {
+      "totalInputTokens": 12,
+      "totalOutputTokens": 26,
+      "totalTokens": 38,
+      "cost": 0.000114
+    }
+  },
+  {
+    "id": "msg-205",
+    "role": "user",
+    "content": "I like the first one best!",
+    "parentId": "msg-202",
+    "createdAt": 1704067220000,
+    "updatedAt": 1704067220000,
+    "meta": {}
+  },
+  {
+    "id": "msg-206",
+    "role": "assistant",
+    "content": "Thank you! I'm glad you enjoyed it. The metaphor of light revealing hidden bugs is one of my favorites. Would you like me to write more haikus on different programming topics?",
+    "parentId": "msg-205",
+    "createdAt": 1704067222000,
+    "updatedAt": 1704067222000,
+    "meta": {},
+    "metadata": {
+      "totalInputTokens": 52,
+      "totalOutputTokens": 48,
+      "totalTokens": 100,
+      "cost": 0.0003
+    }
+  },
+  {
+    "id": "msg-207",
+    "role": "user",
+    "content": "Actually, I prefer the second one with the dancing variables.",
+    "parentId": "msg-203",
+    "createdAt": 1704067225000,
+    "updatedAt": 1704067225000,
+    "meta": {}
+  },
+  {
+    "id": "msg-208",
+    "role": "assistant",
+    "content": "I appreciate your feedback! The imagery of variables dancing in memory really captures the dynamic nature of programming. Would you like me to explore more haikus with that kind of vivid metaphor?",
+    "parentId": "msg-207",
+    "createdAt": 1704067227000,
+    "updatedAt": 1704067227000,
+    "meta": {},
+    "metadata": {
+      "totalInputTokens": 48,
+      "totalOutputTokens": 52,
+      "totalTokens": 100,
+      "cost": 0.0003
+    }
+  },
+  {
+    "id": "msg-209",
+    "role": "user",
+    "content": "Yes, please write one more about debugging!",
+    "parentId": "msg-206",
+    "createdAt": 1704067230000,
+    "updatedAt": 1704067230000,
+    "meta": {}
+  },
+  {
+    "id": "msg-210",
+    "role": "assistant",
+    "content": "Console logs cascade,\nBreakpoints pause the racing code,\nTruth emerges clear.",
+    "parentId": "msg-209",
+    "createdAt": 1704067232000,
+    "updatedAt": 1704067232000,
+    "meta": {},
+    "metadata": {
+      "totalInputTokens": 78,
+      "totalOutputTokens": 24,
+      "totalTokens": 102,
+      "cost": 0.000306
+    }
+  }
+]

package/packages/conversation-flow/src/__tests__/fixtures/inputs/branch/index.ts

@@ -0,0 +1,14 @@
+import type { Message } from '../../../../types';
+import activeIndex1 from './active-index-1.json';
+import assistantBranch from './assistant-branch.json';
+import assistantUserBranch from './assistant-user-branch.json';
+import conversation from './conversation.json';
+import nested from './nested.json';
+
+export const branch = {
+  activeIndex1: activeIndex1 as Message[],
+  assistantBranch: assistantBranch as Message[],
+  assistantUserBranch: assistantUserBranch as Message[],
+  conversation: conversation as Message[],
+  nested: nested as Message[],
+};

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

@@ -0,0 +1,179 @@
+[
+  {
+    "id": "msg-301",
+    "role": "user",
+    "content": "What's your favorite programming paradigm?",
+    "parentId": null,
+    "createdAt": 1704067200000,
+    "updatedAt": 1704067200000,
+    "meta": {}
+  },
+  {
+    "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-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
+    }
+  },
+  {
+    "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
+    }
+  },
+  {
+    "id": "msg-305",
+    "role": "user",
+    "content": "Can you explain more about functional programming?",
+    "parentId": "msg-302",
+    "createdAt": 1704067210000,
+    "updatedAt": 1704067210000,
+    "meta": {},
+    "metadata": {
+      "activeBranchIndex": 1
+    }
+  },
+  {
+    "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
+    }
+  },
+  {
+    "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": {}
+  },
+  {
+    "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-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
+    }
+  },
+  {
+    "id": "msg-314",
+    "role": "user",
+    "content": "Can you give me an example?",
+    "parentId": "msg-311",
+    "createdAt": 1704067230000,
+    "updatedAt": 1704067230000,
+    "meta": {},
+    "metadata": {
+      "activeBranchIndex": 1
+    }
+  },
+  {
+    "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
+    }
+  },
+  {
+    "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/inputs/compare/index.ts

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

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

@@ -0,0 +1,85 @@
+[
+  {
+    "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
+    }
+  },
+  {
+    "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.0,
+      "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.0,
+      "ttft": 298,
+      "duration": 3098,
+      "latency": 3396,
+      "activeColumn": true
+    }
+  },
+  {
+    "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.0,
+      "ttft": 345,
+      "duration": 3479,
+      "latency": 3824
+    }
+  }
+]