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

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

@@ -0,0 +1,208 @@
+{
+  "contextTree": [
+    {
+      "id": "msg-401",
+      "type": "message"
+    },
+    {
+      "id": "msg-402",
+      "type": "message"
+    },
+    {
+      "activeBranchIndex": 1,
+      "branches": [
+        [
+          {
+            "id": "msg-403",
+            "type": "message"
+          }
+        ],
+        [
+          {
+            "id": "msg-404",
+            "type": "message"
+          },
+          {
+            "id": "msg-406",
+            "type": "message"
+          },
+          {
+            "id": "msg-407",
+            "type": "message"
+          }
+        ],
+        [
+          {
+            "id": "msg-405",
+            "type": "message"
+          }
+        ]
+      ],
+      "id": "branch-msg-402-0",
+      "parentMessageId": "msg-402",
+      "type": "branch"
+    }
+  ],
+  "flatList": [
+    {
+      "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-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-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
+      }
+    }
+  ],
+  "messageMap": {
+    "msg-401": {
+      "id": "msg-401",
+      "role": "user",
+      "content": "Can you help me write a function to calculate fibonacci?",
+      "parentId": null,
+      "createdAt": 1704067200000,
+      "updatedAt": 1704067200000,
+      "meta": {}
+    },
+    "msg-402": {
+      "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
+      }
+    },
+    "msg-403": {
+      "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
+      }
+    },
+    "msg-404": {
+      "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
+      }
+    },
+    "msg-405": {
+      "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
+      }
+    },
+    "msg-406": {
+      "id": "msg-406",
+      "role": "user",
+      "content": "The iterative approach looks good! Can you add some comments?",
+      "parentId": "msg-404",
+      "createdAt": 1704067215000,
+      "updatedAt": 1704067215000,
+      "meta": {}
+    },
+    "msg-407": {
+      "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/outputs/branch/assistant-user-branch.json

@@ -0,0 +1,254 @@
+{
+  "contextTree": [
+    {
+      "id": "msg-501",
+      "type": "message"
+    },
+    {
+      "id": "msg-502",
+      "type": "message"
+    },
+    {
+      "activeBranchIndex": 1,
+      "branches": [
+        [
+          {
+            "id": "msg-503",
+            "type": "message"
+          },
+          {
+            "id": "msg-504",
+            "type": "message"
+          },
+          {
+            "id": "msg-505",
+            "type": "message"
+          },
+          {
+            "id": "msg-506",
+            "type": "message"
+          }
+        ],
+        [
+          {
+            "id": "msg-507",
+            "type": "message"
+          },
+          {
+            "id": "msg-508",
+            "type": "message"
+          },
+          {
+            "id": "msg-509",
+            "type": "message"
+          },
+          {
+            "id": "msg-510",
+            "type": "message"
+          }
+        ]
+      ],
+      "id": "branch-msg-502-0",
+      "parentMessageId": "msg-502",
+      "type": "branch"
+    }
+  ],
+  "flatList": [
+    {
+      "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-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
+      }
+    }
+  ],
+  "messageMap": {
+    "msg-501": {
+      "id": "msg-501",
+      "role": "user",
+      "content": "What's the difference between map and forEach in JavaScript?",
+      "parentId": null,
+      "createdAt": 1704067200000,
+      "updatedAt": 1704067200000,
+      "meta": {}
+    },
+    "msg-502": {
+      "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
+      }
+    },
+    "msg-503": {
+      "id": "msg-503",
+      "role": "user",
+      "content": "Can you show me a practical example?",
+      "parentId": "msg-502",
+      "createdAt": 1704067210000,
+      "updatedAt": 1704067210000,
+      "meta": {}
+    },
+    "msg-504": {
+      "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
+      }
+    },
+    "msg-505": {
+      "id": "msg-505",
+      "role": "user",
+      "content": "Thanks! What about performance differences?",
+      "parentId": "msg-504",
+      "createdAt": 1704067220000,
+      "updatedAt": 1704067220000,
+      "meta": {}
+    },
+    "msg-506": {
+      "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
+      }
+    },
+    "msg-507": {
+      "id": "msg-507",
+      "role": "user",
+      "content": "Can you explain the technical implementation details?",
+      "parentId": "msg-502",
+      "createdAt": 1704067210100,
+      "updatedAt": 1704067210100,
+      "meta": {}
+    },
+    "msg-508": {
+      "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
+      }
+    },
+    "msg-509": {
+      "id": "msg-509",
+      "role": "user",
+      "content": "What about memory usage?",
+      "parentId": "msg-508",
+      "createdAt": 1704067220100,
+      "updatedAt": 1704067220100,
+      "meta": {}
+    },
+    "msg-510": {
+      "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
+      }
+    }
+  }
+}