Upload folder via script

.gitignore

@@ -222,3 +222,4 @@ __marimo__/
 .DS_Store
 llm_context.txt
 generate_txt.py
+.nicegui

dataflow/codecs.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
+
 from typing import Any
 
+from .connection import Connection
 from .nodes_base import NodeInstance
 from .ports import PortSchema
 
@@ -28,6 +30,22 @@ def node_to_vueflow(n: NodeInstance, data_extra: dict[str, Any] | None = None) -
     }
 
 
+def connection_to_vueflow_edge(c: Connection) -> dict[str, Any]:
+    """Convert a Connection object to a Vue Flow edge dict."""
+    source_handle = f"{c.start_node.node_id}:{c.start_port.name}"
+    target_handle = f"{c.end_node.node_id}:{c.end_port.name}"
+
+    edge_id = f"{c.start_node.node_id}:{c.start_port.name}->{c.end_node.node_id}:{c.end_port.name}"
+
+    return {
+        "id": edge_id,
+        "source": c.start_node.node_id,
+        "target": c.end_node.node_id,
+        "sourceHandle": source_handle,
+        "targetHandle": target_handle,
+    }
+
+
 def _schema_json(p: PortSchema) -> dict[str, Any]:
     return {
         "name": p.name,
@@ -35,4 +53,5 @@ def _schema_json(p: PortSchema) -> dict[str, Any]:
         "direction": p.direction.value,
         "multiplicity": p.multiplicity.value,
         "capacity": p.capacity,
+        "color": p.dtype.color,
     }

dataflow/enums.py

@@ -25,4 +25,5 @@ class DataTypeId(Enum):
 
 class NodeKind(Enum):
     TEXT_DATA = "TextDataNode"
+    IMAGE_DATA = "ImageDataNode"
     TEXT_TO_IMAGE = "TextToImageNode"

dataflow/graph.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
+
 from dataclasses import dataclass, field
 from typing import Iterable
-from .nodes_base import NodeInstance
+
 from .connection import Connection
-from .enums import DataPortState
+from .enums import DataPortState, ConnectMultiplicity
+from .nodes_base import NodeInstance
 
 
 @dataclass(slots=True)
@@ -32,24 +34,50 @@ class DataGraph:
             if c.start_node is node:
                 yield c
 
-    def execute(self, node: NodeInstance | None = None) -> None:
+    async def execute(self, node: NodeInstance | None = None) -> None:
         if node is None:
             for n in list(self.nodes.values()):
-                self.execute(n)
+                await self.execute(n)
             return
 
-        # ensure inputs are up to date
+        # Identify incoming connections
+        incoming_conns = list(self.upstream_of(node))
+
+        # Recursively execute upstream if dirty
+        for c in incoming_conns:
+            if c.start_port.state == DataPortState.DIRTY:
+                await self.execute(c.start_node)
+
+        # Pull values from upstream to inputs
         for inp in node.all_inputs():
-            for c in self.upstream_of(node):
-                if c.end_port is inp and c.start_port.state is DataPortState.DIRTY:
-                    self.execute(c.start_node)
+            # Find all connections feeding this port
+            feeds = [c for c in incoming_conns if c.end_port is inp]
+
+            if not feeds:
+                continue
+
+            if inp.schema.multiplicity == ConnectMultiplicity.MULTIPLE:
+                # Collect all values
+                values = []
+                for c in feeds:
+                    if c.start_port.value is not None:
+                        values.append(c.start_port.value)
+                inp.value = values
+            else:
+                # Single connection (take the last one if multiple defined by mistake)
+                if feeds:
+                    inp.value = feeds[-1].start_port.value
+
+            inp.state = DataPortState.CLEAN
+
+        # Process
+        await node.process()
 
-        node.process()
         for outp in node.all_outputs():
             outp.state = DataPortState.CLEAN
 
         for c in self.downstream_of(node):
-            c.end_port.value = c.start_port.value
+            # We just mark downstream as dirty; the next execute call will pull the data
             c.end_port.state = DataPortState.DIRTY
             if c.end_node.auto_process:
-                self.execute(c.end_node)
+                await self.execute(c.end_node)

dataflow/nodes_base.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
+
 from dataclasses import dataclass, field
 from typing import Iterable, Callable
-from .ports import PortSchema, PortState
+
 from .enums import NodeKind, DataPortState
+from .ports import PortSchema, PortState
 
 
 @dataclass(slots=True)
@@ -42,8 +44,13 @@ class NodeInstance:
         for p in self.all_outputs():
             p.state = DataPortState.DIRTY
 
-    def process(self) -> None:
+    async def process(self) -> None:
         if self.on_process:
-            self.on_process(self)
+            # check if on_process is async
+            import inspect
+            if inspect.iscoroutinefunction(self.on_process):
+                await self.on_process(self)
+            else:
+                self.on_process(self)
         else:
-            raise NotImplementedError(f"No process callback for {self.node_type.kind.value}")
+            pass

dataflow/types.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
+
 from dataclasses import dataclass
 from typing import Generic, TypeVar, Type, Callable, Any
+
 from .enums import DataTypeId
 
 T = TypeVar("T")
@@ -21,3 +23,4 @@ class DataType(Generic[T]):
     py_type: Type[T]
     encode: Callable[[T], Any] | None = None
     decode: Callable[[Any], T] | None = None
+    color: str = "#888888"

dataflow/ui/vueflow_canvas.vue

@@ -14,6 +14,7 @@
           v-model:edges="edges"
           :fit-view-on-init="fitOnInit"
           :connection-mode="connectionMode"
+          :connection-radius="connectionRadius"
           :snap-to-grid="snapToGrid"
           :edges-updatable="allowUserEdit"
           :nodes-draggable="allowUserEdit"
@@ -32,19 +33,20 @@
           @edges-delete="onEdgesDelete"
           @nodes-delete="onNodesDelete"
       >
-        <!-- generic base node with left right handles and field based UI -->
+        <!-- generic base node with left/right handles and field based UI -->
         <template #node-base="nodeProps">
-          <div class="vf-node">
+          <div class="vf-node" :class="{ 'vf-node-selected': nodeProps.selected }">
             <!-- input handles on the left -->
             <div class="vf-node-handles vf-node-handles-left" v-if="Handle">
               <component
-                  v-for="inp in (nodeProps.data.inputs || [])"
+                  v-for="(inp, index) in (nodeProps.data.inputs || [])"
                   :key="inp.name"
                   :is="Handle"
                   type="target"
                   position="left"
                   :id="nodeProps.id + ':' + inp.name"
                   class="vf-handle vf-handle-left"
+                  :style="getHandleStyle('left', index, nodeProps.data.inputs, inp)"
               />
             </div>
 
@@ -54,15 +56,58 @@
                 <div class="vf-node-title">
                   {{ nodeProps.data.title || nodeProps.id }}
                 </div>
-                <button
-                    v-if="nodeProps.data.executable"
-                    class="vf-exec-button"
-                    :disabled="nodeProps.data.processing"
-                    @click.stop="onExecuteClick(nodeProps)"
-                >
-                  <span v-if="nodeProps.data.processing" class="vf-spinner"></span>
-                  <span v-else>Run</span>
-                </button>
+                <div class="vf-node-header-actions">
+                  <a
+                      v-if="getImageResultValue(nodeProps)"
+                      :href="normalizeImageSrc(getImageResultValue(nodeProps))"
+                      download="generated.png"
+                      class="vf-exec-button vf-download-header"
+                      @click.stop
+                  >
+                    Download
+                  </a>
+                  <button
+                      v-if="nodeProps.data.executable"
+                      class="vf-exec-button"
+                      :disabled="nodeProps.data.processing"
+                      @click.stop="onExecuteClick(nodeProps)"
+                  >
+                    <span v-if="nodeProps.data.processing" class="vf-spinner"></span>
+                    <span v-else>Run</span>
+                  </button>
+
+                  <!-- simple dropdown for node actions -->
+                  <div class="vf-node-menu" @click.stop>
+                    <button
+                        type="button"
+                        class="vf-node-menu-button"
+                        @click.stop="toggleNodeMenu(nodeProps.id)"
+                    >
+                      <span class="vf-node-menu-dot"></span>
+                      <span class="vf-node-menu-dot"></span>
+                      <span class="vf-node-menu-dot"></span>
+                    </button>
+                    <div v-if="isNodeMenuOpen(nodeProps.id)" class="vf-node-menu-items">
+                      <button
+                          type="button"
+                          class="vf-node-menu-item"
+                          @click.stop="onNodeMenuAction(nodeProps.id, 'delete')"
+                      >
+                        Delete node
+                      </button>
+                    </div>
+                  </div>
+                </div>
+              </div>
+
+              <!-- node level error -->
+              <div v-if="nodeProps.data.values && nodeProps.data.values.error" class="vf-node-error">
+                {{ nodeProps.data.values.error }}
+              </div>
+
+              <!-- processing progress bar -->
+              <div v-if="nodeProps.data.processing" class="vf-node-progress">
+                <div class="vf-node-progress-bar"></div>
               </div>
 
               <div class="vf-node-content">
@@ -83,7 +128,63 @@
                       />
                     </div>
 
-                    <!-- image preview with optional url/base64 input -->
+                    <!-- textarea field -->
+                    <div v-else-if="field.kind === 'textarea'">
+                          <textarea
+                              class="vf-node-textarea"
+                              rows="5"
+                              v-model="nodeProps.data.values[field.name]"
+                              @blur="onFieldBlur(nodeProps, field)"
+                              :placeholder="field.placeholder || ''"
+                          ></textarea>
+                    </div>
+
+                    <!-- image upload field -->
+                    <div v-else-if="field.kind === 'image_upload'">
+                      <div class="vf-image-upload-controls">
+                        <label class="vf-exec-button vf-upload-header-btn">
+                          Upload
+                          <input
+                              type="file"
+                              accept="image/*"
+                              @change="onImageUpload($event, nodeProps, field)"
+                              style="display:none"
+                          />
+                        </label>
+                        <button
+                            type="button"
+                            class="vf-exec-button vf-upload-header-btn-secondary"
+                            @click="onImageClipboard(nodeProps, field)"
+                        >
+                          Paste
+                        </button>
+                      </div>
+                      <div class="vf-image-preview-wrapper"
+                           v-if="nodeProps.data.values && nodeProps.data.values[field.name]">
+                        <img :src="normalizeImageSrc(nodeProps.data.values[field.name])"/>
+                      </div>
+                      <div class="vf-image-placeholder" v-else>No image</div>
+                    </div>
+
+                    <!-- image result (download is in header) -->
+                    <div v-else-if="field.kind === 'image_result'">
+                      <div class="vf-image-preview-wrapper">
+                        <div
+                            v-if="nodeProps.data.values && nodeProps.data.values[field.name]"
+                            class="vf-image-preview"
+                        >
+                          <img
+                              :src="normalizeImageSrc(nodeProps.data.values[field.name])"
+                              alt="node image"
+                          />
+                        </div>
+                        <div v-else class="vf-image-placeholder">
+                          {{ field.placeholder || 'No image' }}
+                        </div>
+                      </div>
+                    </div>
+
+                    <!-- legacy image preview with optional url/base64 input -->
                     <div v-else-if="field.kind === 'image'">
                       <div class="vf-image-preview-wrapper">
                         <div
@@ -127,13 +228,14 @@
             <!-- output handles on the right -->
             <div class="vf-node-handles vf-node-handles-right" v-if="Handle">
               <component
-                  v-for="out in (nodeProps.data.outputs || [])"
+                  v-for="(out, index) in (nodeProps.data.outputs || [])"
                   :key="out.name"
                   :is="Handle"
                   type="source"
                   position="right"
                   :id="nodeProps.id + ':' + out.name"
                   class="vf-handle vf-handle-right"
+                  :style="getHandleStyle('right', index, nodeProps.data.outputs, out)"
               />
             </div>
           </div>
@@ -200,6 +302,7 @@ export default {
     snapToGrid: {type: Boolean, default: true},
     connectionMode: {type: String, default: "loose"},
     allowUserEdit: {type: Boolean, default: true},
+    connectionRadius: {type: Number, default: 30},
 
     // CDN versions
     coreVersion: {type: String, default: "1.47.0"},
@@ -207,12 +310,14 @@ export default {
 
     // optional initial graph
     initialNodes: {
-      type: Array, default: function () {
+      type: Array,
+      default: function () {
         return [];
       }
     },
     initialEdges: {
-      type: Array, default: function () {
+      type: Array,
+      default: function () {
         return [];
       }
     },
@@ -246,7 +351,10 @@ export default {
       contextMenuVisible: false,
       contextMenuFlowPosition: null,
 
-      windowKeyHandler: null
+      windowKeyHandler: null,
+
+      // which node menu is open
+      nodeMenuFor: null
     };
   },
 
@@ -295,6 +403,7 @@ export default {
     this.pendingGraph = null;
     this.contextMenuVisible = false;
     this.contextMenuFlowPosition = null;
+    this.nodeMenuFor = null;
 
     if (this.windowKeyHandler) {
       window.removeEventListener("keydown", this.windowKeyHandler);
@@ -303,6 +412,21 @@ export default {
   },
 
   methods: {
+    // node menu helpers
+
+    toggleNodeMenu(id) {
+      this.nodeMenuFor = this.nodeMenuFor === id ? null : id;
+    },
+
+    isNodeMenuOpen(id) {
+      return this.nodeMenuFor === id;
+    },
+
+    onNodeMenuAction(id, action) {
+      this.nodeMenuFor = null;
+      this.emitEvent("node_menu_action", {id: id, action: action});
+    },
+
     // public API for Python
 
     setGraph(payload) {
@@ -377,6 +501,21 @@ export default {
       }
     },
 
+    clearGraph() {
+      var ok = window.confirm("Clear the entire graph? This cannot be undone.");
+      if (!ok) return;
+
+      this.nodes = [];
+      this.edges = [];
+
+      if (this.vf_api) {
+        if (this.vf_api.setNodes) this.vf_api.setNodes([]);
+        if (this.vf_api.setEdges) this.vf_api.setEdges([]);
+      }
+
+      this.emitEvent("graph_cleared", {cleared: true});
+    },
+
     setNodeProcessing(payload) {
       if (!payload || !payload.id) return;
       var id = payload.id;
@@ -461,6 +600,48 @@ export default {
       });
     },
 
+    onImageUpload(event, nodeProps, field) {
+      const file = event.target.files[0];
+      if (!file) return;
+      const reader = new FileReader();
+      reader.onload = (e) => {
+        const res = e.target.result;
+        if (!nodeProps.data.values) nodeProps.data.values = {};
+        nodeProps.data.values[field.name] = res;
+        this.onFieldBlur(nodeProps, field);
+      };
+      reader.readAsDataURL(file);
+    },
+
+    async onImageClipboard(nodeProps, field) {
+      try {
+        const items = await navigator.clipboard.read();
+        for (const item of items) {
+          if (item.types.some(function (t) {
+            return t.startsWith("image/");
+          })) {
+            const type = item.types.find(function (t) {
+              return t.startsWith("image/");
+            });
+            const blob = await item.getType(type);
+            const reader = new FileReader();
+            reader.onload = (e) => {
+              const res = e.target.result;
+              if (!nodeProps.data.values) nodeProps.data.values = {};
+              nodeProps.data.values[field.name] = res;
+              this.onFieldBlur(nodeProps, field);
+            };
+            reader.readAsDataURL(blob);
+            return;
+          }
+        }
+        alert("No image found on clipboard");
+      } catch (err) {
+        console.error(err);
+        alert("Failed to read clipboard");
+      }
+    },
+
     normalizeImageSrc(src) {
       if (!src) return "";
       if (typeof src !== "string") {
@@ -483,6 +664,32 @@ export default {
       return "data:image/png;base64," + trimmed;
     },
 
+    getImageResultValue(nodeProps) {
+      if (!nodeProps || !nodeProps.data) return null;
+      var fields = Array.isArray(nodeProps.data.fields) ? nodeProps.data.fields : [];
+      var values = nodeProps.data.values || {};
+      for (var i = 0; i < fields.length; i++) {
+        var f = fields[i];
+        if (f && f.kind === "image_result" && values[f.name]) {
+          return values[f.name];
+        }
+      }
+      return null;
+    },
+
+    getHandleStyle(side, index, list, port) {
+      var len = Array.isArray(list) ? list.length : 1;
+      var step = 100 / (len + 1);
+      var top = step * (index + 1);
+      var style = {
+        top: top + "%"
+      };
+      if (port && port.color) {
+        style.backgroundColor = port.color;
+      }
+      return style;
+    },
+
     isValidConnection(conn) {
       if (!conn) return false;
       var nodes = this.nodes || [];
@@ -570,11 +777,13 @@ export default {
     openCreateNodeMenu(flowPos) {
       this.contextMenuFlowPosition = flowPos || null;
       this.contextMenuVisible = true;
+      this.nodeMenuFor = null;
     },
 
     hideContextMenu() {
       this.contextMenuVisible = false;
       this.contextMenuFlowPosition = null;
+      this.nodeMenuFor = null;
     },
 
     onCreateNodeClick(entry) {
@@ -919,7 +1128,7 @@ export default {
   font-size: 13px;
 }
 
-/* custom node layout with left right handles */
+/* custom node layout with left/right handles */
 .vf-node {
   display: flex;
   align-items: stretch;
@@ -930,13 +1139,28 @@ export default {
   font-size: 12px;
   box-shadow: 0 1px 2px rgba(15, 23, 42, 0.18);
   min-width: 180px;
+  position: relative;
+}
+
+.vf-node-selected {
+  border-color: #3b82f6;
+  box-shadow: 0 0 0 1px rgba(59, 130, 246, 0.7), 0 4px 10px rgba(37, 99, 235, 0.25);
+}
+
+.vf-node-error {
+  color: #b91c1c;
+  background-color: #fecaca;
+  padding: 4px 8px;
+  border-radius: 4px;
+  margin-bottom: 4px;
+  font-size: 11px;
 }
 
 .vf-node-handles {
   display: flex;
   flex-direction: column;
   justify-content: center;
-  gap: 8px;
+  pointer-events: none;
 }
 
 .vf-node-handles-left {
@@ -947,6 +1171,10 @@ export default {
   margin-left: 4px;
 }
 
+.vf-handle {
+  pointer-events: auto;
+}
+
 .vf-node-body {
   flex: 1 1 auto;
   padding: 6px 8px 8px 8px;
@@ -965,6 +1193,12 @@ export default {
   font-weight: 600;
 }
 
+.vf-node-header-actions {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+}
+
 .vf-node-content {
   display: flex;
   flex-direction: column;
@@ -986,6 +1220,22 @@ export default {
   box-shadow: 0 0 0 1px rgba(59, 130, 246, 0.35);
 }
 
+.vf-node-textarea {
+  width: 100%;
+  box-sizing: border-box;
+  border-radius: 4px;
+  border: 1px solid rgba(148, 163, 184, 0.9);
+  padding: 3px 5px;
+  font-size: 12px;
+  resize: none;
+}
+
+.vf-node-textarea:focus {
+  outline: none;
+  border-color: #3b82f6;
+  box-shadow: 0 0 0 1px rgba(59, 130, 246, 0.35);
+}
+
 .vf-exec-button {
   border: none;
   background: #3b82f6;
@@ -997,6 +1247,7 @@ export default {
   display: inline-flex;
   align-items: center;
   justify-content: center;
+  white-space: nowrap;
 }
 
 .vf-exec-button[disabled] {
@@ -1004,6 +1255,10 @@ export default {
   cursor: default;
 }
 
+.vf-download-header {
+  background: #2563eb;
+}
+
 .vf-spinner {
   width: 12px;
   height: 12px;
@@ -1022,6 +1277,35 @@ export default {
   }
 }
 
+/* processing progress bar */
+.vf-node-progress {
+  position: relative;
+  height: 4px;
+  border-radius: 999px;
+  overflow: hidden;
+  background: #e5e7eb;
+  margin-bottom: 4px;
+}
+
+.vf-node-progress-bar {
+  position: absolute;
+  left: -40%;
+  top: 0;
+  bottom: 0;
+  width: 40%;
+  background: #3b82f6;
+  animation: vf-progress 1s linear infinite;
+}
+
+@keyframes vf-progress {
+  from {
+    transform: translateX(0);
+  }
+  to {
+    transform: translateX(260%);
+  }
+}
+
 .vf-image-preview-wrapper {
   width: 160px;
   height: 100px;
@@ -1053,9 +1337,76 @@ export default {
   height: 100%;
 }
 
-.vf-node-generic {
+/* upload controls - now small blue buttons like header */
+.vf-image-upload-controls {
+  display: flex;
+  gap: 4px;
+  margin-bottom: 4px;
+}
+
+.vf-upload-header-btn {
+  padding: 2px 8px;
   font-size: 11px;
-  color: #6b7280;
+}
+
+.vf-upload-header-btn-secondary {
+  padding: 2px 8px;
+  font-size: 11px;
+  background: #e5f0ff;
+  color: #1d4ed8;
+  border-radius: 4px;
+  border: 1px solid #bfdbfe;
+}
+
+/* simple node menu */
+
+.vf-node-menu {
+  position: relative;
+}
+
+.vf-node-menu-button {
+  border: none;
+  background: transparent;
+  padding: 2px;
+  display: inline-flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  gap: 1px;
+  cursor: pointer;
+}
+
+.vf-node-menu-dot {
+  width: 2px;
+  height: 2px;
+  border-radius: 999px;
+  background: #6b7280;
+}
+
+.vf-node-menu-items {
+  position: absolute;
+  right: 0;
+  margin-top: 4px;
+  min-width: 120px;
+  border-radius: 4px;
+  background: #ffffff;
+  box-shadow: 0 4px 10px rgba(15, 23, 42, 0.15);
+  padding: 4px 0;
+  z-index: 30;
+}
+
+.vf-node-menu-item {
+  width: 100%;
+  padding: 4px 8px;
+  background: transparent;
+  border: none;
+  text-align: left;
+  font-size: 11px;
+  cursor: pointer;
+}
+
+.vf-node-menu-item:hover {
+  background: #eff6ff;
 }
 
 /* dialog styling */

main.py

@@ -1,153 +1,141 @@
 from __future__ import annotations
 
-import itertools
 import os
 
+import uvicorn
 from fastapi import FastAPI
-from nicegui import ui, Client
+from nicegui import ui, Client, app
 
-from dataflow.enums import NodeKind
-from dataflow.graph import DataGraph
-from dataflow.registry import Registry
 from dataflow.ui.vueflow_canvas import VueFlowCanvas
-from nodes.controller import GraphController
-from nodes.runtime import GraphRuntime
-from nodes.text_data import TextDataNodeType, TextDataNode
-from nodes.text_to_image import TextToImageNodeType, TextToImageNode
-from nodes.vue_nodes import VueNodeRenderer
+from nodes.session import GraphSession
 
 fastapi_app = FastAPI()
-ui.run_with(fastapi_app)
+ui.run_with(fastapi_app, storage_secret="velai-storage-secret")
 
-registry = Registry()
-registry.register_node_type(TextDataNodeType, lambda node_id: TextDataNode(node_id, TextDataNodeType))
-registry.register_node_type(TextToImageNodeType, lambda node_id: TextToImageNode(node_id, TextToImageNodeType))
-
-graph = DataGraph()
-renderer = VueNodeRenderer()
-controller = GraphController(graph=graph)
-
-# which node types the user can create from the UI
-creatable_node_types = [
-    {
-        "kind": NodeKind.TEXT_DATA.value,
-        "title": TextDataNodeType.display_name,
-    },
-    {
-        "kind": NodeKind.TEXT_TO_IMAGE.value,
-        "title": TextToImageNodeType.display_name,
-    },
-]
-
-# simple id generator for nodes created from the UI
-_node_id_counter = itertools.count(1)
-
-
-def next_ui_node_id() -> str:
-    return f"u{next(_node_id_counter)}"
-
-
-# create by NodeType object
-text_node = registry.create(TextDataNodeType, "t1")
-text_node2 = registry.create(TextDataNodeType, "t2")
-text2img_node = registry.create(TextToImageNodeType, "n2")
-
-text_node.x, text_node.y = 100, 100
-text2img_node.x, text2img_node.y = 420, 140
-
-graph.add_node(text_node)
-graph.add_node(text_node2)
-graph.add_node(text2img_node)
-
-initial_nodes = [
-    renderer.to_vue_node(text_node),
-    renderer.to_vue_node(text_node2),
-    renderer.to_vue_node(text2img_node),
-]
-initial_edges: list[dict] = []
+APP_PASSWORD = os.getenv("VELAI_PASSWORD") or ""
 
 
 @ui.page("/")
-def main(client: Client):
+async def main(client: Client) -> None:
+    ui.page_title("velai")
     ui.query(".nicegui-content").classes("p-0")
 
-    with ui.row().classes("w-full h-screen no-wrap"):
-        canvas = VueFlowCanvas(
-            creatable_node_types=creatable_node_types,
-        ).classes("w-full h-full flex-1")
-        runtime = GraphRuntime(graph=graph, canvas=canvas)
-
-        async def handle_event(e) -> None:
-            event = e.args
-            print(f"graph event: {event}")
-            event_type = event.get("type")
-            payload = event.get("payload")
-
-            if event_type == "execute_node":
-                payload_dict = payload or {}
-                node_id = payload_dict.get("id")
-                if node_id:
-                    await runtime.execute_node(node_id)
-
-            elif event_type == "create_node":
-                payload_dict = payload or {}
-                kind_value = payload_dict.get("kind")
-                position = payload_dict.get("position") or {}
-
-                if not kind_value:
-                    return
-
-                # map string back to NodeKind
-                try:
-                    kind = NodeKind(kind_value)
-                except Exception:
-                    # fallback lookup by display name or kind string
-                    kind = None
-                    if isinstance(kind_value, str):
-                        for k, node_type in registry.node_types.items():
-                            if k.value == kind_value or node_type.display_name == kind_value:
-                                kind = k
-                                break
-                    if kind is None:
-                        return
-
-                node_id = next_ui_node_id()
-                try:
-                    node_obj = registry.create(kind, node_id)
-                except KeyError:
-                    return
-
-                x = position.get("x")
-                y = position.get("y")
-                if x is not None:
-                    try:
-                        node_obj.x = float(x)
-                    except (TypeError, ValueError):
-                        pass
-                if y is not None:
-                    try:
-                        node_obj.y = float(y)
-                    except (TypeError, ValueError):
-                        pass
-
-                graph.add_node(node_obj)
-                vue_node = renderer.to_vue_node(node_obj)
+    await client.connected()
+
+    # password gate: require once per user while APP_PASSWORD stays the same
+    password_required = False
+    if APP_PASSWORD:
+        auth = app.storage.user.get("auth") or {}
+        if not (auth.get("ok") and auth.get("password_version") == APP_PASSWORD):
+            password_required = True
+
+    # one GraphSession per browser tab
+    if "graph_session" not in app.storage.tab:
+        app.storage.tab["graph_session"] = GraphSession.create_default()
+    session: GraphSession = app.storage.tab["graph_session"]
+
+    initial_nodes = session.initial_vue_nodes()
+    initial_edges = session.initial_vue_edges()
+
+    with ui.column().classes("w-full h-screen no-wrap"):
+        # header
+        with ui.row().classes(
+                "w-full items-center justify-between px-4 py-2 bg-grey-2"
+        ):
+            ui.label("velai").classes("text-lg font-bold")
+
+            with ui.row().classes("items-center gap-2"):
+                with ui.dropdown_button("Add Node", auto_close=True):
+                    kinds = session.creatable_node_types
+                    for k in kinds:
+                        ui.menu_item(k["title"], on_click=lambda _, kind=k["kind"]: add_node_action(kind))
+
+                with ui.dropdown_button("Graph", auto_close=True):
+                    ui.menu_item("Export JSON", on_click=lambda: export_action())
+                    ui.menu_item("Import JSON", on_click=lambda: import_action())
+
+                clear_button = ui.button("Clear graph").props("flat color='negative'")
+
+        # canvas area fills the remaining height
+        with ui.row().classes("w-full flex-1 no-wrap"):
+            canvas = VueFlowCanvas(
+                creatable_node_types=session.creatable_node_types,
+            ).classes("w-full h-full flex-1")
+
+            session.attach_canvas(canvas)
+
+            async def handle_event(e) -> None:
+                await session.handle_ui_event(e.args, canvas)
+
+            canvas.on("vf_event", handle_event)
+            canvas.set_graph(initial_nodes, initial_edges)
+
+        # wire header actions now that canvas exists
+        def add_node_action(kind_value: str) -> None:
+            import random
+            vue_node = session.create_node(kind_value, position={"x": 100 + random.randint(0, 50),
+                                                                 "y": 100 + random.randint(0, 50)})
+            if vue_node is not None:
                 canvas.add_node(vue_node)
 
-            else:
-                controller.handle_event(event)
-
-        canvas.on("vf_event", handle_event)
-        canvas.set_graph(initial_nodes, initial_edges)
+        def clear_graph_action() -> None:
+            session.clear_graph()
+            canvas.set_graph([], [])
+
+        async def export_action() -> None:
+            json_str = session.to_json()
+            ui.download(json_str.encode("utf-8"), "graph.json")
+
+        async def import_action() -> None:
+            with ui.dialog() as dialog, ui.card():
+                ui.label("Upload Graph JSON")
+                ui.upload(on_upload=lambda e: [load_file(e), dialog.close()], auto_upload=True, max_files=1)
+            dialog.open()
+
+        def load_file(e) -> None:
+            content = e.content.read().decode("utf-8")
+            session.load_from_json(content)
+            nodes = session.initial_vue_nodes()
+            edges = session.initial_vue_edges()
+            canvas.set_graph(nodes, edges)
+
+        clear_button.on_click(clear_graph_action)
+
+    # password dialog on top of everything if required
+    if password_required:
+        with ui.dialog() as dialog, ui.card():
+            await dialog.props("persistent")
+            ui.label("Enter password").classes("text-md font-bold mb-2")
+            pwd_input = ui.input(label="Password").props('type="password"')
+            error_label = ui.label("").style(
+                "color: red; font-size: 0.8rem; min-height: 1rem"
+            )
+
+            def submit() -> None:
+                value = pwd_input.value or ""
+                if value == APP_PASSWORD:
+                    app.storage.user["auth"] = {
+                        "ok": True,
+                        "password_version": APP_PASSWORD,
+                    }
+                    error_label.text = ""
+                    dialog.close()
+                else:
+                    error_label.text = "Wrong password"
+
+            pwd_input.on("keydown.enter", lambda _: submit())
+
+            with ui.row().classes("mt-2 items-center justify-end gap-2"):
+                ui.button("Enter", on_click=submit).props("color='primary'")
+
+        dialog.open()
 
 
 if __name__ in {"__main__", "__mp_main__"}:
-    import uvicorn
-
     uvicorn.run(
         "main:fastapi_app",
         host="0.0.0.0",
         port=int(os.getenv("PORT", "7860")),
         proxy_headers=True,
-        forwarded_allow_ips="*"
+        forwarded_allow_ips="*",
     )

nodes/data_types.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from PIL import Image
+
+from dataflow.enums import DataTypeId
+from dataflow.types import DataType
+from nodes import utils
+
+TextType = DataType[str](
+    id=DataTypeId.TEXT,
+    name="Text",
+    py_type=str,
+    color="#eab308",
+)
+
+ImageType = DataType(
+    id=DataTypeId.IMAGE,
+    name="Image",
+    py_type=Image.Image,
+    encode=utils.encode_image_png,
+    decode=utils.decode_image_png,
+    color="#a855f7",
+)

nodes/image_data.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from dataflow.enums import NodeKind, PortDirection
+from dataflow.nodes_base import NodeType, NodeInstance
+from dataflow.ports import PortSchema
+from nodes.data_types import ImageType
+from nodes.vue_nodes import VueNodeRenderable, VueNodeData
+
+ImageDataNodeType = NodeType(
+    kind=NodeKind.IMAGE_DATA,
+    display_name="Image",
+    inputs=[],
+    outputs=[PortSchema(name="image", dtype=ImageType, direction=PortDirection.OUTPUT)],
+)
+
+
+@dataclass(slots=True)
+class ImageDataNode(NodeInstance):
+    """Node that exposes a constant image value via its output port.
+
+    The text is stored on the "text" output port and edited through the UI.
+    """
+
+    async def process(self) -> None:
+        """Data nodes do not compute anything, they just expose their current value.
+
+        The UI writes into the "text" output port. Here we simply ensure the port
+        exists and treat the current value as the result.
+        """
+        port = self.outputs.get("image") if self.outputs is not None else None
+        if port is None:
+            return
+        # nothing to compute, but this method must exist so graph.execute
+        # can safely walk upstream without raising
+        return
+
+
+class ImageDataNodeRenderable(VueNodeRenderable[ImageDataNode]):
+    def to_vue_node_data(self, node: ImageDataNode) -> VueNodeData:
+        data = VueNodeData()
+
+        data.fields.append(
+            {
+                "name": "image",
+                "kind": "image_upload",
+                "label": "Image",
+                "placeholder": "Upload or paste image...",
+            }
+        )
+
+        port = node.outputs.get("image") if node.outputs is not None else None
+        data.values["image"] = "" if port is None or port.value is None else str(port.value)
+
+        data.executable = False
+        return data

nodes/runtime.py

@@ -5,7 +5,6 @@ from dataclasses import dataclass
 from dataflow.graph import DataGraph
 from dataflow.nodes_base import NodeInstance
 from dataflow.ui.vueflow_canvas import VueFlowCanvas
-
 from .text_to_image import TextToImageNode
 
 
@@ -34,8 +33,13 @@ class GraphRuntime:
         self.canvas.set_node_processing(node_id, True)
         try:
             # run the dataflow execution chain (this will also execute upstream nodes)
-            self.graph.execute(node_obj)
+            print(f"Runtime: Executing {node_id}...")
+            await self.graph.execute(node_obj)
             await self._sync_node_to_ui(node_obj)
+        except Exception as e:
+            print(f"Runtime execution failed: {e}")
+            import traceback
+            traceback.print_exc()
         finally:
             # hide spinner
             self.canvas.set_node_processing(node_id, False)
@@ -44,4 +48,7 @@ class GraphRuntime:
         """Push relevant node state back to the Vue nodes."""
         if isinstance(node, TextToImageNode):
             image_src = "" if node.image_src is None else str(node.image_src)
-            self.canvas.update_node_values(node.node_id, {"image": image_src})
+            values = {"image": image_src}
+            if node.error:
+                values["error"] = node.error
+            self.canvas.update_node_values(node.node_id, values)

nodes/session.py

@@ -0,0 +1,280 @@
+from __future__ import annotations
+
+import itertools
+import json
+from dataclasses import dataclass, field
+from typing import Any
+
+from dataflow.codecs import connection_to_vueflow_edge
+from dataflow.connection import Connection
+from dataflow.enums import NodeKind
+from dataflow.graph import DataGraph
+from dataflow.registry import Registry
+from dataflow.ui.vueflow_canvas import VueFlowCanvas
+from .controller import GraphController
+from .image_data import ImageDataNodeType, ImageDataNode, ImageDataNodeRenderable
+from .runtime import GraphRuntime
+from .text_data import TextDataNodeType, TextDataNode, TextDataNodeRenderable
+from .text_to_image import TextToImageNodeType, TextToImageNode, TextToImageNodeRenderable
+from .vue_nodes import VueNodeRenderer
+
+
+@dataclass(slots=True)
+class GraphSession:
+    """Per browser tab graph session."""
+
+    registry: Registry
+    graph: DataGraph
+    renderer: VueNodeRenderer
+    controller: GraphController
+    runtime: GraphRuntime | None = None
+    _node_id_counter: itertools.count = field(
+        default_factory=lambda: itertools.count(1)
+    )
+
+    @classmethod
+    def create_default(cls) -> "GraphSession":
+        """Create a new session with default node types and starter graph."""
+        # Register new node types here
+        registry = Registry()
+        registry.register_node_type(
+            TextDataNodeType, lambda node_id: TextDataNode(node_id, TextDataNodeType)
+        )
+        registry.register_node_type(
+            ImageDataNodeType, lambda node_id: ImageDataNode(node_id, ImageDataNodeType)
+        )
+        registry.register_node_type(
+            TextToImageNodeType,
+            lambda node_id: TextToImageNode(node_id, TextToImageNodeType),
+        )
+
+        graph = DataGraph()
+        controller = GraphController(graph=graph)
+
+        renderer = VueNodeRenderer()
+
+        # Register new node renderables here!
+        renderer.register(TextDataNode, TextDataNodeRenderable())
+        renderer.register(ImageDataNode, ImageDataNodeRenderable())
+        renderer.register(TextToImageNode, TextToImageNodeRenderable())
+
+        session = cls(
+            registry=registry,
+            graph=graph,
+            renderer=renderer,
+            controller=controller,
+        )
+        session._build_initial_graph()
+        return session
+
+    def _build_initial_graph(self) -> None:
+        """Add starter nodes to a fresh graph."""
+        text_node = self.registry.create(TextDataNodeType, "t1")
+        text2img_node = self.registry.create(TextToImageNodeType, "n2")
+
+        text_node.x, text_node.y = 100, 100
+        text2img_node.x, text2img_node.y = 420, 100
+
+        self.graph.add_node(text_node)
+        self.graph.add_node(text2img_node)
+
+        edge = Connection(text_node, text_node.outputs["text"],
+                          text2img_node, text2img_node.inputs["text"])
+
+        self.graph.add_connection(edge)
+
+    @property
+    def creatable_node_types(self) -> list[dict[str, str]]:
+        """Metadata for the node types the UI may create."""
+        return [
+            {
+                "kind": TextDataNodeType.kind.value,
+                "title": TextDataNodeType.display_name,
+            },
+            {
+                "kind": ImageDataNodeType.kind.value,
+                "title": ImageDataNodeType.display_name,
+            },
+            {
+                "kind": TextToImageNodeType.kind.value,
+                "title": TextToImageNodeType.display_name,
+            },
+        ]
+
+    def attach_canvas(self, canvas: VueFlowCanvas) -> None:
+        """Attach a VueFlowCanvas to this session."""
+        self.runtime = GraphRuntime(graph=self.graph, canvas=canvas)
+
+    def initial_vue_nodes(self) -> list[dict[str, Any]]:
+        """Serialize current graph nodes to Vue Flow node dicts with UI metadata."""
+        return [self.renderer.to_vue_node(n) for n in self.graph.nodes.values()]
+
+    def initial_vue_edges(self) -> list[dict[str, Any]]:
+        """Serialize current graph connections to Vue Flow edge dicts."""
+        return [connection_to_vueflow_edge(c) for c in self.graph.connections]
+
+    def to_json(self) -> str:
+        """Export graph to JSON."""
+        nodes_data = []
+        for node in self.graph.nodes.values():
+            # Extract UI values using the renderer logic
+            vue_data = self.renderer.to_vue_node(node)["data"].get("values", {})
+
+            nodes_data.append({
+                "id": node.node_id,
+                "kind": node.node_type.kind.value,
+                "x": node.x,
+                "y": node.y,
+                "values": vue_data
+            })
+
+        edges_data = []
+        for c in self.graph.connections:
+            edges_data.append({
+                "source": c.start_node.node_id,
+                "sourceHandle": c.start_port.name,
+                "target": c.end_node.node_id,
+                "targetHandle": c.end_port.name
+            })
+
+        return json.dumps({"nodes": nodes_data, "edges": edges_data}, indent=2)
+
+    def load_from_json(self, json_str: str) -> None:
+        """Import graph from JSON."""
+        try:
+            data = json.loads(json_str)
+        except Exception:
+            return
+
+        self.clear_graph()
+
+        # Recreate nodes
+        for n_data in data.get("nodes", []):
+            kind_val = n_data.get("kind")
+            node_id = n_data.get("id")
+
+            kind = self._node_kind_from_value(kind_val)
+            if not kind or not node_id:
+                continue
+
+            node = self.registry.create(kind, node_id)
+            node.x = n_data.get("x", 0)
+            node.y = n_data.get("y", 0)
+
+            # Apply values via controller to ensure side-effects (like updating port values) run
+            values = n_data.get("values", {})
+            self.graph.add_node(node)  # Add first so controller finds it
+
+            for field, value in values.items():
+                self.controller._on_node_field_changed({"id": node_id, "field": field, "value": value})
+
+            # Update id counter to avoid collisions with new nodes
+            if node_id.startswith("u"):
+                try:
+                    num = int(node_id[1:])
+                    if num >= next(self._node_id_counter) - 1:
+                        self._node_id_counter = itertools.count(num + 1)
+                except:
+                    pass
+
+        # Recreate edges
+        from dataflow.connection import Connection
+        for e_data in data.get("edges", []):
+            src_node = self.graph.nodes.get(e_data.get("source"))
+            tgt_node = self.graph.nodes.get(e_data.get("target"))
+            if src_node and tgt_node:
+                src_port = src_node.outputs.get(e_data.get("sourceHandle"))
+                tgt_port = tgt_node.inputs.get(e_data.get("targetHandle"))
+
+                if src_port and tgt_port:
+                    try:
+                        conn = Connection(src_node, src_port, tgt_node, tgt_port)
+                        self.graph.add_connection(conn)
+                    except ValueError:
+                        pass
+
+    def next_ui_node_id(self) -> str:
+        return f"u{next(self._node_id_counter)}"
+
+    def clear_graph(self) -> None:
+        """Remove all nodes and connections."""
+        self.graph.nodes.clear()
+        self.graph.connections.clear()
+        self._node_id_counter = itertools.count(1)
+
+    def _node_kind_from_value(self, kind_value: str | None) -> NodeKind | None:
+        if not kind_value:
+            return None
+
+        try:
+            return NodeKind(kind_value)
+        except Exception:
+            pass
+
+        for kind, node_type in self.registry.node_types.items():
+            if kind.value == kind_value or node_type.display_name == kind_value:
+                return kind
+
+        return None
+
+    def create_node(
+            self, kind_value: str | None, position: dict[str, Any] | None = None
+    ) -> dict[str, Any] | None:
+        """Create a new node in the graph and return its Vue node dict."""
+        kind = self._node_kind_from_value(kind_value)
+        if kind is None:
+            return None
+
+        node_id = self.next_ui_node_id()
+        try:
+            node_obj = self.registry.create(kind, node_id)
+        except KeyError:
+            return None
+
+        if position:
+            x = position.get("x")
+            y = position.get("y")
+            if x is not None:
+                try:
+                    node_obj.x = float(x)
+                except (TypeError, ValueError):
+                    pass
+            if y is not None:
+                try:
+                    node_obj.y = float(y)
+                except (TypeError, ValueError):
+                    pass
+
+        self.graph.add_node(node_obj)
+        return self.renderer.to_vue_node(node_obj)
+
+    async def handle_ui_event(
+            self, event: dict[str, Any], canvas: VueFlowCanvas
+    ) -> None:
+        """Central handler for all Vue Flow events from this tab."""
+        event_type = event.get("type")
+        payload = event.get("payload")
+
+        if event_type == "execute_node":
+            payload_dict = payload or {}
+            node_id = payload_dict.get("id")
+            if not node_id:
+                return
+
+            if self.runtime is None:
+                self.attach_canvas(canvas)
+            else:
+                self.runtime.canvas = canvas
+
+            await self.runtime.execute_node(node_id)
+
+        elif event_type == "create_node":
+            payload_dict = payload or {}
+            kind_value = payload_dict.get("kind")
+            position = payload_dict.get("position") or {}
+            vue_node = self.create_node(kind_value, position)
+            if vue_node is not None:
+                canvas.add_node(vue_node)
+
+        else:
+            self.controller.handle_event(event)

nodes/text_data.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
+
 from dataclasses import dataclass
 
 from dataflow.enums import NodeKind, PortDirection
 from dataflow.nodes_base import NodeType, NodeInstance
 from dataflow.ports import PortSchema
-from .text_shared import TextType
-
+from nodes.data_types import TextType
+from nodes.vue_nodes import VueNodeRenderable, VueNodeData
 
 TextDataNodeType = NodeType(
     kind=NodeKind.TEXT_DATA,
@@ -22,7 +23,7 @@ class TextDataNode(NodeInstance):
     The text is stored on the "text" output port and edited through the UI.
     """
 
-    def process(self) -> None:
+    async def process(self) -> None:
         """Data nodes do not compute anything, they just expose their current value.
 
         The UI writes into the "text" output port. Here we simply ensure the port
@@ -34,3 +35,23 @@ class TextDataNode(NodeInstance):
         # nothing to compute, but this method must exist so graph.execute
         # can safely walk upstream without raising
         return
+
+
+class TextDataNodeRenderable(VueNodeRenderable[TextDataNode]):
+    def to_vue_node_data(self, node: TextDataNode) -> VueNodeData:
+        data = VueNodeData()
+
+        data.fields.append(
+            {
+                "name": "text",
+                "kind": "textarea",
+                "label": "Text",
+                "placeholder": "Enter text...",
+            }
+        )
+
+        port = node.outputs.get("text") if node.outputs is not None else None
+        data.values["text"] = "" if port is None or port.value is None else str(port.value)
+
+        data.executable = False
+        return data

nodes/text_to_image.py

@@ -1,29 +1,30 @@
 from __future__ import annotations
-from dataclasses import dataclass
 
-import numpy as np
+import typing
+from dataclasses import dataclass
 
-from dataflow.enums import DataTypeId, PortDirection, NodeKind
+from dataflow.enums import PortDirection, NodeKind, ConnectMultiplicity
 from dataflow.nodes_base import NodeType, NodeInstance
 from dataflow.ports import PortSchema
-from dataflow.types import DataType
-from .text_shared import TextType
-
-
-ImageType = DataType[np.ndarray](
-    id=DataTypeId.IMAGE,
-    name="Image",
-    py_type=np.ndarray,
-    encode=lambda a: a.tolist(),
-    decode=lambda a: np.array(a),
-)
-
+from services.image.ImageGenerator import ImageGenerator
+from services.registry import get_registry
+from services.services import TaskType
+from . import utils
+from .data_types import ImageType, TextType
+from .vue_nodes import VueNodeRenderable, VueNodeData
 
 TextToImageNodeType = NodeType(
     kind=NodeKind.TEXT_TO_IMAGE,
-    display_name="Text to Image",
-    inputs=[PortSchema(name="text", dtype=TextType, direction=PortDirection.INPUT, capacity=5)],
-    outputs=[PortSchema(name="image", dtype=ImageType, direction=PortDirection.OUTPUT)],
+    display_name="Image Generation",
+    inputs=[
+        PortSchema(name="text", dtype=TextType, direction=PortDirection.INPUT,
+                   multiplicity=ConnectMultiplicity.MULTIPLE, capacity=3),
+        PortSchema(name="image", dtype=ImageType, direction=PortDirection.INPUT,
+                   multiplicity=ConnectMultiplicity.MULTIPLE, capacity=3)
+    ],
+    outputs=[
+        PortSchema(name="image", dtype=ImageType, direction=PortDirection.OUTPUT)
+    ],
 )
 
 
@@ -31,14 +32,77 @@ TextToImageNodeType = NodeType(
 class TextToImageNode(NodeInstance):
     # string that UI can bind to; may be url or base64 data
     image_src: str | None = None
+    error: str | None = None
+
+    async def process(self) -> None:
+        self.error = None
+
+        text_input = self.inputs["text"]
+        image_input = self.inputs["image"]
+        image_output = self.outputs["image"]
+
+        # Handle multiple inputs (concatenation)
+        prompt = ""
+        if isinstance(text_input.value, list):
+            prompt = "\n\n".join([str(v) for v in text_input.value if v])
+        elif text_input.value:
+            prompt = str(text_input.value)
+
+        if not prompt or prompt.strip() == "":
+            self.error = "Could not generate image! No text input."
+            return
+
+        # optional image inputs
+        images = None
+        if isinstance(image_input.value, list):
+            images = image_input.value
+
+        registry = get_registry()
+        image_service = typing.cast(ImageGenerator, registry.create(TaskType.IMAGE, "google_gemini_image"))
+
+        def on_progress(value: float, message: str | None):
+            # In a fuller implementation, we would emit events to UI here
+            pass
+
+        try:
+            import asyncio
+            from functools import partial
+
+            # Run non-blocking
+            loop = asyncio.get_running_loop()
+            result = await loop.run_in_executor(
+                None,
+                partial(image_service.generate, prompt, images=images, progress=on_progress)
+            )
+
+            url = utils.encode_image_png(result.image)
+            self.image_src = url
+
+            image_output.value = result.image
+        except Exception as e:
+            self.error = f"Error: {str(e)}"
+            self.image_src = None
+
+
+class TextToImageNodeRenderable(VueNodeRenderable[TextToImageNode]):
+    def to_vue_node_data(self, node: TextToImageNode) -> VueNodeData:
+        data = VueNodeData()
+
+        data.fields.append(
+            {
+                "name": "image",
+                "kind": "image_result",
+                "label": "Image",
+                "editable": False,
+                "placeholder": "No image yet",
+            }
+        )
 
-    def process(self) -> str:
-        # in a real implementation, you would read the text prompt and generate an image
-        prompt = self.inputs["text"].value or ""
-        url = "https://picsum.photos/200"
-        self.image_src = url
+        data.values["image"] = "" if node.image_src is None else str(node.image_src)
+        if node.error:
+            data.values["error"] = node.error
 
-        # placeholder: we do not construct a real image array here
-        self.outputs["image"].value = None
+        data.executable = True
+        data.processing = False
 
-        return url
+        return data

nodes/utils.py

@@ -0,0 +1,21 @@
+import base64
+import io
+
+from PIL import Image
+
+
+def encode_image_png(img: Image.Image) -> str:
+    buffer = io.BytesIO()
+    img.save(buffer, format="PNG")
+    raw = buffer.getvalue()
+    b64 = base64.b64encode(raw).decode("ascii")
+    return f"data:image/png;base64,{b64}"
+
+
+def decode_image_png(data: str) -> Image.Image:
+    prefix = "data:image/png;base64,"
+    if data.startswith(prefix):
+        data = data[len(prefix):]
+    raw = base64.b64decode(data.encode("ascii"))
+    buffer = io.BytesIO(raw)
+    return Image.open(buffer)

nodes/vue_nodes.py

@@ -1,12 +1,48 @@
 from __future__ import annotations
-from dataclasses import dataclass
-from typing import Any
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Any, TypeVar, Generic
 
 from dataflow.codecs import node_to_vueflow
 from dataflow.nodes_base import NodeInstance
 
-from .text_data import TextDataNode
-from .text_to_image import TextToImageNode
+T_Node = TypeVar("T_Node", bound=NodeInstance)
+
+
+@dataclass(slots=True)
+class VueNodeData:
+    """Structured data that describes how a node should be rendered in Vue Flow."""
+
+    # High level behavior flags
+    executable: bool | None = None
+    processing: bool | None = None
+
+    # Form like content
+    fields: list[dict[str, Any]] = field(default_factory=list)
+    values: dict[str, Any] = field(default_factory=dict)
+
+    def to_extra_dict(self) -> dict[str, Any]:
+        """Convert to the data_extra dict expected by node_to_vueflow."""
+        data: dict[str, Any] = {}
+
+        if self.executable is not None:
+            data["executable"] = self.executable
+        if self.processing is not None:
+            data["processing"] = self.processing
+        if self.fields:
+            data["fields"] = self.fields
+        if self.values:
+            data["values"] = self.values
+
+        return data
+
+
+class VueNodeRenderable(Generic[T_Node], ABC):
+    @abstractmethod
+    def to_vue_node_data(self, node: T_Node) -> VueNodeData:
+        """Create VueNodeData for a given NodeInstance."""
+        raise NotImplementedError
 
 
 @dataclass(slots=True)
@@ -16,42 +52,33 @@ class VueNodeRenderer:
     App specific node UI details live here, not in the core dataflow package.
     """
 
+    _registry: dict[type[NodeInstance], VueNodeRenderable[Any]] = field(default_factory=dict)
+
+    def register(self, node_type: type[T_Node], renderer: VueNodeRenderable[T_Node]) -> None:
+        """Register a renderer for a given node type."""
+        self._registry[node_type] = renderer  # type: ignore[assignment]
+
+    def _get_renderer_for_node(self, node: NodeInstance) -> VueNodeRenderable[Any] | None:
+        """Find the best matching renderer for the node type, considering its MRO."""
+        node_type = type(node)
+
+        renderer = self._registry.get(node_type)
+        if renderer is not None:
+            return renderer
+
+        for base in node_type.mro()[1:]:
+            if not issubclass(base, NodeInstance):
+                continue
+            renderer = self._registry.get(base)  # type: ignore[arg-type]
+            if renderer is not None:
+                return renderer
+
+        return None
+
     def to_vue_node(self, node: NodeInstance) -> dict[str, Any]:
-        data_extra: dict[str, Any] = {}
-        fields: list[dict[str, Any]] = []
-        values: dict[str, Any] = {}
-
-        if isinstance(node, TextDataNode):
-            fields.append(
-                {
-                    "name": "text",
-                    "kind": "text",
-                    "label": "Text",
-                    "placeholder": "Enter text...",
-                }
-            )
-            port = node.outputs.get("text") if node.outputs is not None else None
-            values["text"] = "" if port is None or port.value is None else str(port.value)
-            data_extra["executable"] = False
-
-        elif isinstance(node, TextToImageNode):
-            # processing node: show image preview and an execute button
-            fields.append(
-                {
-                    "name": "image",
-                    "kind": "image",
-                    "label": "Image",
-                    "editable": False,
-                    "placeholder": "No image yet",
-                }
-            )
-            values["image"] = "" if node.image_src is None else str(node.image_src)
-            data_extra["executable"] = True
-            data_extra["processing"] = False
-
-        if fields:
-            data_extra["fields"] = fields
-        if values:
-            data_extra["values"] = values
-
-        return node_to_vueflow(node, data_extra=data_extra)
+        renderer = self._get_renderer_for_node(node)
+        if renderer is None:
+            return node_to_vueflow(node)
+
+        node_data = renderer.to_vue_node_data(node)  # type: ignore[arg-type]
+        return node_to_vueflow(node, data_extra=node_data.to_extra_dict())

pyproject.toml

@@ -4,8 +4,11 @@ version = "0.1.0"
 description = "Add your description here"
 requires-python = ">=3.12"
 dependencies = [
+    "google-genai>=1.51.0",
     "nicegui>=3",
-    "numpy>=2.3.4",
+    "pillow>=12.0.0",
+    "requests>=2.32.5",
+    "uvicorn<=0.35.0",
 ]
 
 [dependency-groups]

services/__init__.py

@@ -0,0 +1 @@
+from . import image, text

services/exceptions.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+
+class GenerationError(RuntimeError):
+    """Base exception raised when a generation backend fails."""

services/image/DummyImageGenerator.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import io
+import random
+from collections.abc import Sequence
+
+import requests
+from PIL import Image
+
+from services.exceptions import GenerationError
+from services.image.ImageGenerationResult import ImageGenerationResult
+from services.image.ImageGenerator import ImageGenerator
+from services.progress import ProgressCallback, call_progress
+from services.registry import register_service
+
+
+@register_service
+class DummyImageGenerator(ImageGenerator):
+    """Dummy image generator backed by picsum.photos."""
+    service_id = "dummy_image"
+
+    @classmethod
+    def default_model_name(cls) -> str:
+        return "picsum"
+
+    def close(self) -> None:
+        return
+
+    def generate(
+            self,
+            prompt: str,
+            images: Sequence[Image.Image] | None = None,
+            *,
+            progress: ProgressCallback | None = None,
+    ) -> ImageGenerationResult:
+        call_progress(progress, 0.1, "Starting dummy image request")
+
+        # Let the prompt slightly influence the size to make results somewhat varied
+        base_size = 512
+        jitter = random.randint(-64, 64)
+        size = max(128, base_size + jitter)
+        url = f"https://picsum.photos/{size}/{size}"
+
+        call_progress(progress, 0.4, f"Fetching random image from {url}")
+
+        try:
+            response = requests.get(url, timeout=10)
+        except requests.RequestException as exc:
+            raise GenerationError("Failed to fetch dummy image from picsum.photos.") from exc
+
+        if response.status_code != 200:
+            raise GenerationError(
+                f"picsum.photos returned unexpected status code {response.status_code}."
+            )
+
+        call_progress(progress, 0.7, "Decoding dummy image")
+
+        try:
+            image = Image.open(io.BytesIO(response.content)).convert("RGB")
+        except OSError as exc:
+            raise GenerationError("Received invalid image data from picsum.photos.") from exc
+
+        image.load()
+
+        call_progress(progress, 0.95, "Preparing dummy image result")
+
+        return ImageGenerationResult(
+            provider="dummy",
+            model=self.model_name,
+            images=[image],
+            raw_response={"url": response.url},
+        )

services/image/GoogleImageGenerator.py

@@ -0,0 +1,119 @@
+import io
+from typing import Any, Sequence, List
+
+from PIL import Image
+
+from services.exceptions import GenerationError
+from services.image.ImageGenerationResult import ImageGenerationResult
+from services.image.ImageGenerator import ImageGenerator
+from services.progress import ProgressCallback, call_progress
+from services.registry import register_service
+from services.utils.google_service import DEFAULT_GEMINI_IMAGE_MODEL, \
+    iter_response_parts
+
+
+@register_service
+class GoogleImageGenerator(ImageGenerator):
+    """Image generator backed by the Google Gemini API."""
+    service_id = "google_gemini_image"
+
+    def __init__(self, model_name: str | None = None, api_key: str | None = None) -> None:
+        super().__init__(model_name=model_name)
+        try:
+            from google import genai  # type: ignore[import-not-found]
+        except ModuleNotFoundError as exc:
+            raise GenerationError(
+                "The 'google-genai' package is required to use the Google image backend."
+            ) from exc
+
+        client_kwargs: dict[str, Any] = {}
+        if api_key is not None:
+            client_kwargs["api_key"] = api_key
+
+        # If api_key is omitted, the client will read GOOGLE_API_KEY from the environment
+        self._client = genai.Client(**client_kwargs)
+
+    @classmethod
+    def default_model_name(cls) -> str:
+        return DEFAULT_GEMINI_IMAGE_MODEL
+
+    def close(self) -> None:
+        # The google client does not expose an explicit close method currently
+        return
+
+    def generate(
+            self,
+            prompt: str,
+            images: Sequence[Image.Image] | None = None,
+            *,
+            progress: ProgressCallback | None = None,
+    ) -> ImageGenerationResult:
+        from google.genai import types  # type: ignore[import-not-found]
+
+        call_progress(progress, 0.1, "Encoding inputs")
+
+        request_parts: List[object] = [prompt]
+        images = images or []
+
+        for image in images:
+            buffer = io.BytesIO()
+            image.save(buffer, format="PNG")
+            image_bytes = buffer.getvalue()
+
+            part: Any | None = None
+
+            part_class = getattr(types, "Part", None)
+            from_bytes = getattr(part_class, "from_bytes", None)
+            if callable(from_bytes):
+                part = from_bytes(data=image_bytes, mime_type="image/png")
+
+            if part is None:
+                input_image_class = getattr(types, "InputImage", None)
+                if input_image_class is not None:
+                    part = input_image_class(mime_type="image/png", data=image_bytes)
+
+            if part is None:
+                raise GenerationError(
+                    "The installed google-genai client does not support image inputs."
+                )
+
+            request_parts.append(part)
+
+        call_progress(progress, 0.4, "Calling Google Gemini image model")
+
+        response = self._client.models.generate_content(
+            model=self.model_name,
+            contents=request_parts,
+        )
+
+        call_progress(progress, 0.7, "Decoding image")
+
+        generated_images: List[Image.Image] = []
+        for part in iter_response_parts(response):
+            inline_data = getattr(part, "inline_data", None)
+            if inline_data is None:
+                continue
+
+            data: bytes | None = getattr(inline_data, "data", None)
+            if data is None:
+                continue
+
+            buffer = io.BytesIO(data)
+            try:
+                img = Image.open(buffer).convert("RGBA")
+            except OSError as exc:
+                raise GenerationError("Received invalid image data from Gemini.") from exc
+            img.load()
+            generated_images.append(img)
+
+        if not generated_images:
+            raise GenerationError("The Google image model did not return any image data.")
+
+        call_progress(progress, 0.95, "Preparing image result")
+
+        return ImageGenerationResult(
+            provider="google",
+            model=self.model_name,
+            images=generated_images,
+            raw_response=response,
+        )

services/image/ImageGenerationResult.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass, field
+
+from PIL import Image
+
+from services.results import GenerationResult
+
+
+@dataclass(slots=True)
+class ImageGenerationResult(GenerationResult):
+    """Result of an image generation call.
+
+    Multiple images are supported. The first one is exposed as a convenience
+    property "image".
+    """
+    images: list[Image.Image] = field(default_factory=list)
+
+    @property
+    def image(self) -> Image.Image | None:
+        if not self.images:
+            return None
+        return self.images[0]

services/image/ImageGenerator.py

@@ -0,0 +1,25 @@
+from abc import ABC, abstractmethod
+from typing import Sequence
+
+from PIL import Image
+
+from services.image.ImageGenerationResult import ImageGenerationResult
+from services.progress import ProgressCallback
+from services.services import GenerationService, TaskType
+
+
+class ImageGenerator(GenerationService, ABC):
+    """Base class for image generation backends."""
+
+    task_type = TaskType.IMAGE
+
+    @abstractmethod
+    def generate(
+            self,
+            prompt: str,
+            images: Sequence[Image.Image] | None = None,
+            *,
+            progress: ProgressCallback | None = None,
+    ) -> ImageGenerationResult:
+        """Generate images from a prompt and optional images."""
+        raise NotImplementedError

services/image/__init__.py

@@ -0,0 +1,2 @@
+from services.image.DummyImageGenerator import DummyImageGenerator
+from services.image.GoogleImageGenerator import GoogleImageGenerator

services/progress.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from typing import Callable
+
+ProgressCallback = Callable[[float, str | None], None]
+
+
+def call_progress(progress: ProgressCallback | None, value: float, description: str | None = None) -> None:
+    """Safely invoke a progress callback if it is provided."""
+    if progress is None:
+        return
+    try:
+        progress(value, description)
+    except Exception:
+        # Progress callbacks should not break generation
+        return

services/registry.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Iterable, List, MutableMapping, Type
+
+from services.services import TaskType, GenerationService, TService
+
+
+@dataclass
+class ServiceRegistry:
+    """Registry for generation services, grouped by task type."""
+    _services: MutableMapping[TaskType, MutableMapping[str, Type[GenerationService]]] = field(
+        default_factory=dict
+    )
+
+    def register(self, service_cls: Type[GenerationService]) -> None:
+        task_type = service_cls.task_type
+        service_id = getattr(service_cls, "service_id", service_cls.__name__)
+        bucket = self._services.setdefault(task_type, {})
+        if service_id in bucket:
+            raise ValueError(
+                f"Service id {service_id!r} already registered for task type {task_type}."
+            )
+        bucket[service_id] = service_cls
+
+    def get(self, task_type: TaskType, service_id: str) -> Type[GenerationService]:
+        bucket = self._services.get(task_type)
+        if bucket is None or service_id not in bucket:
+            raise KeyError(
+                f"No service registered for type {task_type} with id {service_id!r}."
+            )
+        return bucket[service_id]
+
+    def create(self, task_type: TaskType, service_id: str, **kwargs) -> GenerationService:
+        service_cls = self.get(task_type, service_id)
+        return service_cls(**kwargs)
+
+    def list_ids(self, task_type: TaskType) -> List[str]:
+        bucket = self._services.get(task_type, {})
+        return sorted(bucket.keys())
+
+    def iter_services(self, task_type: TaskType) -> Iterable[Type[GenerationService]]:
+        bucket = self._services.get(task_type, {})
+        return bucket.values()
+
+
+_default_registry = ServiceRegistry()
+
+
+def register_service(service_cls: Type[TService]) -> Type[TService]:
+    """Class decorator to register a service in the default registry."""
+    _default_registry.register(service_cls)
+    return service_cls
+
+
+def get_registry() -> ServiceRegistry:
+    return _default_registry

services/results.py

@@ -0,0 +1,15 @@
+# filename: results.py
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(slots=True)
+class GenerationResult:
+    """Common metadata for any generation result."""
+    provider: str = ""
+    model: str = ""
+
+    # For debugging or advanced usage
+    raw_response: Any | None = None

services/services.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from enum import StrEnum
+from typing import TypeVar
+
+
+class TaskType(StrEnum):
+    TEXT = "text_generation"
+    IMAGE = "image_generation"
+
+
+class GenerationService(ABC):
+    """Base class for any generation backend."""
+
+    # Must be overridden in subclasses
+    service_id: str
+    task_type: TaskType
+
+    def __init__(self, model_name: str | None = None) -> None:
+        # Uses subclass default model if not provided
+        self.model_name = model_name or self.default_model_name()
+
+    @classmethod
+    @abstractmethod
+    def default_model_name(cls) -> str:
+        """Return the default model name for this service."""
+        raise NotImplementedError
+
+    @property
+    def name(self) -> str:
+        """Human readable name, by default the service id."""
+        return self.service_id
+
+    @abstractmethod
+    def close(self) -> None:
+        """Release any resources held by the service."""
+        raise NotImplementedError
+
+
+TService = TypeVar("TService", bound=GenerationService)

services/text/DummyTextGenerator.py

@@ -0,0 +1,48 @@
+from typing import Sequence
+
+from PIL import Image
+
+from services.progress import ProgressCallback, call_progress
+from services.registry import register_service
+from services.text.TextGenerationResult import TextGenerationResult
+from services.text.TextGenerator import TextGenerator
+
+
+@register_service
+class DummyTextGenerator(TextGenerator):
+    """Dummy text generator that simply echoes the prompt."""
+    service_id = "dummy_text"
+
+    @classmethod
+    def default_model_name(cls) -> str:
+        return "echo"
+
+    def close(self) -> None:
+        return
+
+    def generate(
+            self,
+            prompt: str,
+            images: Sequence[Image.Image] | None = None,
+            *,
+            progress: ProgressCallback | None = None,
+    ) -> TextGenerationResult:
+        call_progress(progress, 0.1, "Starting dummy text generation")
+
+        images = images or []
+        image_info = ""
+        if images:
+            image_info = f" (with {len(images)} image inputs)"
+
+        call_progress(progress, 0.6, "Building dummy text response")
+
+        text = f"[dummy-text]{image_info}: {prompt}"
+
+        call_progress(progress, 0.95, "Preparing dummy text result")
+
+        return TextGenerationResult(
+            provider="dummy",
+            model=self.model_name,
+            text=text,
+            raw_response=None,
+        )

services/text/GoogleTextGenerator.py

@@ -0,0 +1,131 @@
+import io
+from typing import Any, Sequence
+
+from PIL import Image
+
+from services.exceptions import GenerationError
+from services.progress import call_progress, ProgressCallback
+from services.registry import register_service
+from services.text.TextGenerationResult import TextGenerationResult
+from services.text.TextGenerator import TextGenerator
+from services.utils.google_service import DEFAULT_GEMINI_TEXT_MODEL, iter_response_parts, extract_usage_tokens
+
+
+@register_service
+class GoogleTextGenerator(TextGenerator):
+    """Text generator backed by the Google Gemini API."""
+    service_id = "google_gemini_text"
+
+    def __init__(self, model_name: str | None = None, api_key: str | None = None) -> None:
+        super().__init__(model_name=model_name)
+        try:
+            from google import genai  # type: ignore[import-not-found]
+        except ModuleNotFoundError as exc:
+            raise GenerationError(
+                "The 'google-genai' package is required to use the Google text backend."
+            ) from exc
+
+        client_kwargs: dict[str, Any] = {}
+        if api_key is not None:
+            client_kwargs["api_key"] = api_key
+
+        self._client = genai.Client(**client_kwargs)
+
+    @classmethod
+    def default_model_name(cls) -> str:
+        return DEFAULT_GEMINI_TEXT_MODEL
+
+    def close(self) -> None:
+        # The google client does not expose an explicit close method currently
+        return
+
+    @staticmethod
+    def _extract_text(response: Any) -> str:
+        text = getattr(response, "text", None)
+        if isinstance(text, str) and text.strip():
+            return text
+
+        parts_text: list[str] = []
+        for part in iter_response_parts(response):
+            value = getattr(part, "text", None)
+            if isinstance(value, str):
+                parts_text.append(value)
+
+        if parts_text:
+            return "".join(parts_text)
+
+        candidates = getattr(response, "candidates", None)
+        if candidates:
+            for candidate in candidates:
+                content = getattr(candidate, "content", None)
+                if content is None:
+                    continue
+                content_parts = getattr(content, "parts", None) or []
+                for part in content_parts:
+                    value = getattr(part, "text", None)
+                    if isinstance(value, str):
+                        parts_text.append(value)
+            if parts_text:
+                return "".join(parts_text)
+
+        raise GenerationError("The Google text model did not return any text output.")
+
+    def generate(
+            self,
+            prompt: str,
+            images: Sequence[Image.Image] | None = None,
+            *,
+            progress: ProgressCallback | None = None,
+    ) -> TextGenerationResult:
+        from google.genai import types  # type: ignore[import-not-found]
+
+        call_progress(progress, 0.1, "Encoding inputs")
+
+        request_parts: list[object] = [prompt]
+        images = images or []
+
+        for image in images:
+            buffer = io.BytesIO()
+            image.save(buffer, format="PNG")
+            image_bytes = buffer.getvalue()
+
+            part: Any | None = None
+
+            part_class = getattr(types, "Part", None)
+            from_bytes = getattr(part_class, "from_bytes", None)
+            if callable(from_bytes):
+                part = from_bytes(data=image_bytes, mime_type="image/png")
+
+            if part is None:
+                input_image_class = getattr(types, "InputImage", None)
+                if input_image_class is not None:
+                    part = input_image_class(mime_type="image/png", data=image_bytes)
+
+            if part is None:
+                raise GenerationError(
+                    "The installed google-genai client does not support image inputs."
+                )
+
+            request_parts.append(part)
+
+        call_progress(progress, 0.4, "Calling Google Gemini text model")
+
+        response = self._client.models.generate_content(
+            model=self.model_name,
+            contents=request_parts,
+        )
+
+        call_progress(progress, 0.7, "Decoding text")
+
+        output_text = self._extract_text(response)
+
+        input_tokens, output_tokens = extract_usage_tokens(response)
+
+        call_progress(progress, 0.95, "Preparing text result")
+
+        return TextGenerationResult(
+            provider="google",
+            model=self.model_name,
+            text=output_text,
+            raw_response=response,
+        )

services/text/TextGenerationResult.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+
+from services.results import GenerationResult
+
+
+@dataclass(slots=True)
+class TextGenerationResult(GenerationResult):
+    """Result of a text generation call."""
+    text: str = ""

services/text/TextGenerator.py

@@ -0,0 +1,25 @@
+from abc import ABC, abstractmethod
+from typing import Sequence
+
+from PIL import Image
+
+from services.progress import ProgressCallback
+from services.services import TaskType, GenerationService
+from services.text.TextGenerationResult import TextGenerationResult
+
+
+class TextGenerator(GenerationService, ABC):
+    """Base class for text generation backends."""
+
+    task_type = TaskType.TEXT
+
+    @abstractmethod
+    def generate(
+            self,
+            prompt: str,
+            images: Sequence[Image.Image] | None = None,
+            *,
+            progress: ProgressCallback | None = None,
+    ) -> TextGenerationResult:
+        """Generate text from a prompt and optional images."""
+        raise NotImplementedError

services/text/__init__.py

@@ -0,0 +1,2 @@
+from services.text.DummyTextGenerator import DummyTextGenerator
+from services.text.GoogleTextGenerator import GoogleTextGenerator

services/utils/google_service.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import os
+from typing import Any, Optional
+
+DEFAULT_GEMINI_TEXT_MODEL = os.getenv("GEMINI_TEXT_MODEL", "gemini-2.5-flash-lite-preview-09-2025")
+DEFAULT_GEMINI_IMAGE_MODEL = os.getenv("GEMINI_IMAGE_MODEL", "gemini-2.5-flash-image-preview")
+
+
+def iter_response_parts(response: Any):
+    """Yield parts from a Gemini response, supporting multiple shapes."""
+    parts = getattr(response, "parts", None)
+    if parts:
+        for part in parts:
+            yield part
+        return
+
+    candidates = getattr(response, "candidates", None)
+    if candidates:
+        for candidate in candidates:
+            content = getattr(candidate, "content", None)
+            if content is not None:
+                content_parts = getattr(content, "parts", None)
+                if content_parts:
+                    for part in content_parts:
+                        yield part
+
+
+def extract_usage_tokens(response: Any) -> tuple[Optional[int], Optional[int]]:
+    usage_metadata = getattr(response, "usage_metadata", None)
+    if usage_metadata is None:
+        return None, None
+
+    input_tokens: Optional[int] = getattr(usage_metadata, "prompt_token_count", None)
+    if not isinstance(input_tokens, int):
+        input_tokens = getattr(usage_metadata, "input_token_count", None)
+
+    output_tokens: Optional[int] = getattr(usage_metadata, "candidates_token_count", None)
+    if not isinstance(output_tokens, int):
+        output_tokens = getattr(usage_metadata, "output_token_count", None)
+
+    return input_tokens, output_tokens

uv.lock

@@ -168,6 +168,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/99/37/e8730c3587a65eb5645d4aba2d27aae48e8003614d6aaf15dda67f702f1f/bidict-0.23.1-py3-none-any.whl", hash = "sha256:5dae8d4d79b552a71cbabc7deb25dfe8ce710b17ff41711e13010ead2abfc3e5", size = 32764, upload-time = "2024-02-18T19:09:04.156Z" },
 ]
 
+[[package]]
+name = "cachetools"
+version = "6.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fb/44/ca1675be2a83aeee1886ab745b28cda92093066590233cc501890eb8417a/cachetools-6.2.2.tar.gz", hash = "sha256:8e6d266b25e539df852251cfd6f990b4bc3a141db73b939058d809ebd2590fc6", size = 31571, upload-time = "2025-11-13T17:42:51.465Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e6/46/eb6eca305c77a4489affe1c5d8f4cae82f285d9addd8de4ec084a7184221/cachetools-6.2.2-py3-none-any.whl", hash = "sha256:6c09c98183bf58560c97b2abfcedcbaf6a896a490f534b031b661d3723b45ace", size = 11503, upload-time = "2025-11-13T17:42:50.232Z" },
+]
+
 [[package]]
 name = "certifi"
 version = "2025.10.5"
@@ -177,6 +186,63 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e4/37/af0d2ef3967ac0d6113837b44a4f0bfe1328c2b9763bd5b1744520e5cfed/certifi-2025.10.5-py3-none-any.whl", hash = "sha256:0f212c2744a9bb6de0c56639a6f68afe01ecd92d91f14ae897c4fe7bbeeef0de", size = 163286, upload-time = "2025-10-05T04:12:14.03Z" },
 ]
 
+[[package]]
+name = "charset-normalizer"
+version = "3.4.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418, upload-time = "2025-10-14T04:42:32.879Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f3/85/1637cd4af66fa687396e757dec650f28025f2a2f5a5531a3208dc0ec43f2/charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394", size = 208425, upload-time = "2025-10-14T04:40:53.353Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/6a/04130023fef2a0d9c62d0bae2649b69f7b7d8d24ea5536feef50551029df/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25", size = 148162, upload-time = "2025-10-14T04:40:54.558Z" },
+    { url = "https://files.pythonhosted.org/packages/78/29/62328d79aa60da22c9e0b9a66539feae06ca0f5a4171ac4f7dc285b83688/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef", size = 144558, upload-time = "2025-10-14T04:40:55.677Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bb/b32194a4bf15b88403537c2e120b817c61cd4ecffa9b6876e941c3ee38fe/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d", size = 161497, upload-time = "2025-10-14T04:40:57.217Z" },
+    { url = "https://files.pythonhosted.org/packages/19/89/a54c82b253d5b9b111dc74aca196ba5ccfcca8242d0fb64146d4d3183ff1/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8", size = 159240, upload-time = "2025-10-14T04:40:58.358Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/10/d20b513afe03acc89ec33948320a5544d31f21b05368436d580dec4e234d/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86", size = 153471, upload-time = "2025-10-14T04:40:59.468Z" },
+    { url = "https://files.pythonhosted.org/packages/61/fa/fbf177b55bdd727010f9c0a3c49eefa1d10f960e5f09d1d887bf93c2e698/charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a", size = 150864, upload-time = "2025-10-14T04:41:00.623Z" },
+    { url = "https://files.pythonhosted.org/packages/05/12/9fbc6a4d39c0198adeebbde20b619790e9236557ca59fc40e0e3cebe6f40/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f", size = 150647, upload-time = "2025-10-14T04:41:01.754Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/1f/6a9a593d52e3e8c5d2b167daf8c6b968808efb57ef4c210acb907c365bc4/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc", size = 145110, upload-time = "2025-10-14T04:41:03.231Z" },
+    { url = "https://files.pythonhosted.org/packages/30/42/9a52c609e72471b0fc54386dc63c3781a387bb4fe61c20231a4ebcd58bdd/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf", size = 162839, upload-time = "2025-10-14T04:41:04.715Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/5b/c0682bbf9f11597073052628ddd38344a3d673fda35a36773f7d19344b23/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15", size = 150667, upload-time = "2025-10-14T04:41:05.827Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/24/a41afeab6f990cf2daf6cb8c67419b63b48cf518e4f56022230840c9bfb2/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9", size = 160535, upload-time = "2025-10-14T04:41:06.938Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/e5/6a4ce77ed243c4a50a1fecca6aaaab419628c818a49434be428fe24c9957/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0", size = 154816, upload-time = "2025-10-14T04:41:08.101Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/ef/89297262b8092b312d29cdb2517cb1237e51db8ecef2e9af5edbe7b683b1/charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26", size = 99694, upload-time = "2025-10-14T04:41:09.23Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/2d/1e5ed9dd3b3803994c155cd9aacb60c82c331bad84daf75bcb9c91b3295e/charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525", size = 107131, upload-time = "2025-10-14T04:41:10.467Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/d9/0ed4c7098a861482a7b6a95603edce4c0d9db2311af23da1fb2b75ec26fc/charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3", size = 100390, upload-time = "2025-10-14T04:41:11.915Z" },
+    { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091, upload-time = "2025-10-14T04:41:13.346Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936, upload-time = "2025-10-14T04:41:14.461Z" },
+    { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180, upload-time = "2025-10-14T04:41:15.588Z" },
+    { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346, upload-time = "2025-10-14T04:41:16.738Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874, upload-time = "2025-10-14T04:41:17.923Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076, upload-time = "2025-10-14T04:41:19.106Z" },
+    { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601, upload-time = "2025-10-14T04:41:20.245Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376, upload-time = "2025-10-14T04:41:21.398Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825, upload-time = "2025-10-14T04:41:22.583Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583, upload-time = "2025-10-14T04:41:23.754Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366, upload-time = "2025-10-14T04:41:25.27Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300, upload-time = "2025-10-14T04:41:26.725Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465, upload-time = "2025-10-14T04:41:28.322Z" },
+    { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404, upload-time = "2025-10-14T04:41:29.95Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092, upload-time = "2025-10-14T04:41:31.188Z" },
+    { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408, upload-time = "2025-10-14T04:41:32.624Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746, upload-time = "2025-10-14T04:41:33.773Z" },
+    { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889, upload-time = "2025-10-14T04:41:34.897Z" },
+    { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641, upload-time = "2025-10-14T04:41:36.116Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779, upload-time = "2025-10-14T04:41:37.229Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035, upload-time = "2025-10-14T04:41:38.368Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542, upload-time = "2025-10-14T04:41:39.862Z" },
+    { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524, upload-time = "2025-10-14T04:41:41.319Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395, upload-time = "2025-10-14T04:41:42.539Z" },
+    { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680, upload-time = "2025-10-14T04:41:43.661Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045, upload-time = "2025-10-14T04:41:44.821Z" },
+    { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687, upload-time = "2025-10-14T04:41:46.442Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014, upload-time = "2025-10-14T04:41:47.631Z" },
+    { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044, upload-time = "2025-10-14T04:41:48.81Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940, upload-time = "2025-10-14T04:41:49.946Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104, upload-time = "2025-10-14T04:41:51.051Z" },
+    { url = "https://files.pythonhosted.org/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743, upload-time = "2025-10-14T04:41:52.122Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402, upload-time = "2025-10-14T04:42:31.76Z" },
+]
+
 [[package]]
 name = "click"
 version = "8.3.0"
@@ -329,6 +395,39 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/eb/02/a6b21098b1d5d6249b7c5ab69dde30108a71e4e819d4a9778f1de1d5b70d/fsspec-2025.10.0-py3-none-any.whl", hash = "sha256:7c7712353ae7d875407f97715f0e1ffcc21e33d5b24556cb1e090ae9409ec61d", size = 200966, upload-time = "2025-10-30T14:58:42.53Z" },
 ]
 
+[[package]]
+name = "google-auth"
+version = "2.43.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cachetools" },
+    { name = "pyasn1-modules" },
+    { name = "rsa" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ff/ef/66d14cf0e01b08d2d51ffc3c20410c4e134a1548fc246a6081eae585a4fe/google_auth-2.43.0.tar.gz", hash = "sha256:88228eee5fc21b62a1b5fe773ca15e67778cb07dc8363adcb4a8827b52d81483", size = 296359, upload-time = "2025-11-06T00:13:36.587Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6f/d1/385110a9ae86d91cc14c5282c61fe9f4dc41c0b9f7d423c6ad77038c4448/google_auth-2.43.0-py2.py3-none-any.whl", hash = "sha256:af628ba6fa493f75c7e9dbe9373d148ca9f4399b5ea29976519e0a3848eddd16", size = 223114, upload-time = "2025-11-06T00:13:35.209Z" },
+]
+
+[[package]]
+name = "google-genai"
+version = "1.51.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "google-auth" },
+    { name = "httpx" },
+    { name = "pydantic" },
+    { name = "requests" },
+    { name = "tenacity" },
+    { name = "typing-extensions" },
+    { name = "websockets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c3/1c/29245699c7c274ed5709b33b6a5192af2d57da5da3d2f189f222d1895336/google_genai-1.51.0.tar.gz", hash = "sha256:596c1ec964b70fec17a6ccfe6ee4edede31022584e8b1d33371d93037c4001b1", size = 258060, upload-time = "2025-11-18T05:32:47.068Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c6/28/0185dcda66f1994171067cfdb0e44a166450239d5b11b3a8a281dd2da459/google_genai-1.51.0-py3-none-any.whl", hash = "sha256:bfb7d0c6ba48ba9bda539f0d5e69dad827d8735a8b1e4703bafa0a2945d293e1", size = 260483, upload-time = "2025-11-18T05:32:45.938Z" },
+]
+
 [[package]]
 name = "h11"
 version = "0.16.0"
@@ -691,8 +790,11 @@ name = "nicegui-graph"
 version = "0.1.0"
 source = { virtual = "." }
 dependencies = [
+    { name = "google-genai" },
     { name = "nicegui" },
-    { name = "numpy" },
+    { name = "pillow" },
+    { name = "requests" },
+    { name = "uvicorn" },
 ]
 
 [package.dev-dependencies]
@@ -702,76 +804,16 @@ dev = [
 
 [package.metadata]
 requires-dist = [
+    { name = "google-genai", specifier = ">=1.51.0" },
     { name = "nicegui", specifier = ">=3" },
-    { name = "numpy", specifier = ">=2.3.4" },
+    { name = "pillow", specifier = ">=12.0.0" },
+    { name = "requests", specifier = ">=2.32.5" },
+    { name = "uvicorn", specifier = "<=0.35.0" },
 ]
 
 [package.metadata.requires-dev]
 dev = [{ name = "huggingface-hub", extras = ["cli"], specifier = ">=1.1.4" }]
 
-[[package]]
-name = "numpy"
-version = "2.3.4"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b5/f4/098d2270d52b41f1bd7db9fc288aaa0400cb48c2a3e2af6fa365d9720947/numpy-2.3.4.tar.gz", hash = "sha256:a7d018bfedb375a8d979ac758b120ba846a7fe764911a64465fd87b8729f4a6a", size = 20582187, upload-time = "2025-10-15T16:18:11.77Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/96/7a/02420400b736f84317e759291b8edaeee9dc921f72b045475a9cbdb26b17/numpy-2.3.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ef1b5a3e808bc40827b5fa2c8196151a4c5abe110e1726949d7abddfe5c7ae11", size = 20957727, upload-time = "2025-10-15T16:15:44.9Z" },
-    { url = "https://files.pythonhosted.org/packages/18/90/a014805d627aa5750f6f0e878172afb6454552da929144b3c07fcae1bb13/numpy-2.3.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c2f91f496a87235c6aaf6d3f3d89b17dba64996abadccb289f48456cff931ca9", size = 14187262, upload-time = "2025-10-15T16:15:47.761Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/e4/0a94b09abe89e500dc748e7515f21a13e30c5c3fe3396e6d4ac108c25fca/numpy-2.3.4-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:f77e5b3d3da652b474cc80a14084927a5e86a5eccf54ca8ca5cbd697bf7f2667", size = 5115992, upload-time = "2025-10-15T16:15:50.144Z" },
-    { url = "https://files.pythonhosted.org/packages/88/dd/db77c75b055c6157cbd4f9c92c4458daef0dd9cbe6d8d2fe7f803cb64c37/numpy-2.3.4-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:8ab1c5f5ee40d6e01cbe96de5863e39b215a4d24e7d007cad56c7184fdf4aeef", size = 6648672, upload-time = "2025-10-15T16:15:52.442Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/e6/e31b0d713719610e406c0ea3ae0d90760465b086da8783e2fd835ad59027/numpy-2.3.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:77b84453f3adcb994ddbd0d1c5d11db2d6bda1a2b7fd5ac5bd4649d6f5dc682e", size = 14284156, upload-time = "2025-10-15T16:15:54.351Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/58/30a85127bfee6f108282107caf8e06a1f0cc997cb6b52cdee699276fcce4/numpy-2.3.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4121c5beb58a7f9e6dfdee612cb24f4df5cd4db6e8261d7f4d7450a997a65d6a", size = 16641271, upload-time = "2025-10-15T16:15:56.67Z" },
-    { url = "https://files.pythonhosted.org/packages/06/f2/2e06a0f2adf23e3ae29283ad96959267938d0efd20a2e25353b70065bfec/numpy-2.3.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:65611ecbb00ac9846efe04db15cbe6186f562f6bb7e5e05f077e53a599225d16", size = 16059531, upload-time = "2025-10-15T16:15:59.412Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/e7/b106253c7c0d5dc352b9c8fab91afd76a93950998167fa3e5afe4ef3a18f/numpy-2.3.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dabc42f9c6577bcc13001b8810d300fe814b4cfbe8a92c873f269484594f9786", size = 18578983, upload-time = "2025-10-15T16:16:01.804Z" },
-    { url = "https://files.pythonhosted.org/packages/73/e3/04ecc41e71462276ee867ccbef26a4448638eadecf1bc56772c9ed6d0255/numpy-2.3.4-cp312-cp312-win32.whl", hash = "sha256:a49d797192a8d950ca59ee2d0337a4d804f713bb5c3c50e8db26d49666e351dc", size = 6291380, upload-time = "2025-10-15T16:16:03.938Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/a8/566578b10d8d0e9955b1b6cd5db4e9d4592dd0026a941ff7994cedda030a/numpy-2.3.4-cp312-cp312-win_amd64.whl", hash = "sha256:985f1e46358f06c2a09921e8921e2c98168ed4ae12ccd6e5e87a4f1857923f32", size = 12787999, upload-time = "2025-10-15T16:16:05.801Z" },
-    { url = "https://files.pythonhosted.org/packages/58/22/9c903a957d0a8071b607f5b1bff0761d6e608b9a965945411f867d515db1/numpy-2.3.4-cp312-cp312-win_arm64.whl", hash = "sha256:4635239814149e06e2cb9db3dd584b2fa64316c96f10656983b8026a82e6e4db", size = 10197412, upload-time = "2025-10-15T16:16:07.854Z" },
-    { url = "https://files.pythonhosted.org/packages/57/7e/b72610cc91edf138bc588df5150957a4937221ca6058b825b4725c27be62/numpy-2.3.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c090d4860032b857d94144d1a9976b8e36709e40386db289aaf6672de2a81966", size = 20950335, upload-time = "2025-10-15T16:16:10.304Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/46/bdd3370dcea2f95ef14af79dbf81e6927102ddf1cc54adc0024d61252fd9/numpy-2.3.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a13fc473b6db0be619e45f11f9e81260f7302f8d180c49a22b6e6120022596b3", size = 14179878, upload-time = "2025-10-15T16:16:12.595Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/01/5a67cb785bda60f45415d09c2bc245433f1c68dd82eef9c9002c508b5a65/numpy-2.3.4-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:3634093d0b428e6c32c3a69b78e554f0cd20ee420dcad5a9f3b2a63762ce4197", size = 5108673, upload-time = "2025-10-15T16:16:14.877Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/cd/8428e23a9fcebd33988f4cb61208fda832800ca03781f471f3727a820704/numpy-2.3.4-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:043885b4f7e6e232d7df4f51ffdef8c36320ee9d5f227b380ea636722c7ed12e", size = 6641438, upload-time = "2025-10-15T16:16:16.805Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/d1/913fe563820f3c6b079f992458f7331278dcd7ba8427e8e745af37ddb44f/numpy-2.3.4-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4ee6a571d1e4f0ea6d5f22d6e5fbd6ed1dc2b18542848e1e7301bd190500c9d7", size = 14281290, upload-time = "2025-10-15T16:16:18.764Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/7e/7d306ff7cb143e6d975cfa7eb98a93e73495c4deabb7d1b5ecf09ea0fd69/numpy-2.3.4-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fc8a63918b04b8571789688b2780ab2b4a33ab44bfe8ccea36d3eba51228c953", size = 16636543, upload-time = "2025-10-15T16:16:21.072Z" },
-    { url = "https://files.pythonhosted.org/packages/47/6a/8cfc486237e56ccfb0db234945552a557ca266f022d281a2f577b98e955c/numpy-2.3.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:40cc556d5abbc54aabe2b1ae287042d7bdb80c08edede19f0c0afb36ae586f37", size = 16056117, upload-time = "2025-10-15T16:16:23.369Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/0e/42cb5e69ea901e06ce24bfcc4b5664a56f950a70efdcf221f30d9615f3f3/numpy-2.3.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ecb63014bb7f4ce653f8be7f1df8cbc6093a5a2811211770f6606cc92b5a78fd", size = 18577788, upload-time = "2025-10-15T16:16:27.496Z" },
-    { url = "https://files.pythonhosted.org/packages/86/92/41c3d5157d3177559ef0a35da50f0cda7fa071f4ba2306dd36818591a5bc/numpy-2.3.4-cp313-cp313-win32.whl", hash = "sha256:e8370eb6925bb8c1c4264fec52b0384b44f675f191df91cbe0140ec9f0955646", size = 6282620, upload-time = "2025-10-15T16:16:29.811Z" },
-    { url = "https://files.pythonhosted.org/packages/09/97/fd421e8bc50766665ad35536c2bb4ef916533ba1fdd053a62d96cc7c8b95/numpy-2.3.4-cp313-cp313-win_amd64.whl", hash = "sha256:56209416e81a7893036eea03abcb91c130643eb14233b2515c90dcac963fe99d", size = 12784672, upload-time = "2025-10-15T16:16:31.589Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/df/5474fb2f74970ca8eb978093969b125a84cc3d30e47f82191f981f13a8a0/numpy-2.3.4-cp313-cp313-win_arm64.whl", hash = "sha256:a700a4031bc0fd6936e78a752eefb79092cecad2599ea9c8039c548bc097f9bc", size = 10196702, upload-time = "2025-10-15T16:16:33.902Z" },
-    { url = "https://files.pythonhosted.org/packages/11/83/66ac031464ec1767ea3ed48ce40f615eb441072945e98693bec0bcd056cc/numpy-2.3.4-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:86966db35c4040fdca64f0816a1c1dd8dbd027d90fca5a57e00e1ca4cd41b879", size = 21049003, upload-time = "2025-10-15T16:16:36.101Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/99/5b14e0e686e61371659a1d5bebd04596b1d72227ce36eed121bb0aeab798/numpy-2.3.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:838f045478638b26c375ee96ea89464d38428c69170360b23a1a50fa4baa3562", size = 14302980, upload-time = "2025-10-15T16:16:39.124Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/44/e9486649cd087d9fc6920e3fc3ac2aba10838d10804b1e179fb7cbc4e634/numpy-2.3.4-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:d7315ed1dab0286adca467377c8381cd748f3dc92235f22a7dfc42745644a96a", size = 5231472, upload-time = "2025-10-15T16:16:41.168Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/51/902b24fa8887e5fe2063fd61b1895a476d0bbf46811ab0c7fdf4bd127345/numpy-2.3.4-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:84f01a4d18b2cc4ade1814a08e5f3c907b079c847051d720fad15ce37aa930b6", size = 6739342, upload-time = "2025-10-15T16:16:43.777Z" },
-    { url = "https://files.pythonhosted.org/packages/34/f1/4de9586d05b1962acdcdb1dc4af6646361a643f8c864cef7c852bf509740/numpy-2.3.4-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:817e719a868f0dacde4abdfc5c1910b301877970195db9ab6a5e2c4bd5b121f7", size = 14354338, upload-time = "2025-10-15T16:16:46.081Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/06/1c16103b425de7969d5a76bdf5ada0804b476fed05d5f9e17b777f1cbefd/numpy-2.3.4-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:85e071da78d92a214212cacea81c6da557cab307f2c34b5f85b628e94803f9c0", size = 16702392, upload-time = "2025-10-15T16:16:48.455Z" },
-    { url = "https://files.pythonhosted.org/packages/34/b2/65f4dc1b89b5322093572b6e55161bb42e3e0487067af73627f795cc9d47/numpy-2.3.4-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:2ec646892819370cf3558f518797f16597b4e4669894a2ba712caccc9da53f1f", size = 16134998, upload-time = "2025-10-15T16:16:51.114Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/11/94ec578896cdb973aaf56425d6c7f2aff4186a5c00fac15ff2ec46998b46/numpy-2.3.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:035796aaaddfe2f9664b9a9372f089cfc88bd795a67bd1bfe15e6e770934cf64", size = 18651574, upload-time = "2025-10-15T16:16:53.429Z" },
-    { url = "https://files.pythonhosted.org/packages/62/b7/7efa763ab33dbccf56dade36938a77345ce8e8192d6b39e470ca25ff3cd0/numpy-2.3.4-cp313-cp313t-win32.whl", hash = "sha256:fea80f4f4cf83b54c3a051f2f727870ee51e22f0248d3114b8e755d160b38cfb", size = 6413135, upload-time = "2025-10-15T16:16:55.992Z" },
-    { url = "https://files.pythonhosted.org/packages/43/70/aba4c38e8400abcc2f345e13d972fb36c26409b3e644366db7649015f291/numpy-2.3.4-cp313-cp313t-win_amd64.whl", hash = "sha256:15eea9f306b98e0be91eb344a94c0e630689ef302e10c2ce5f7e11905c704f9c", size = 12928582, upload-time = "2025-10-15T16:16:57.943Z" },
-    { url = "https://files.pythonhosted.org/packages/67/63/871fad5f0073fc00fbbdd7232962ea1ac40eeaae2bba66c76214f7954236/numpy-2.3.4-cp313-cp313t-win_arm64.whl", hash = "sha256:b6c231c9c2fadbae4011ca5e7e83e12dc4a5072f1a1d85a0a7b3ed754d145a40", size = 10266691, upload-time = "2025-10-15T16:17:00.048Z" },
-    { url = "https://files.pythonhosted.org/packages/72/71/ae6170143c115732470ae3a2d01512870dd16e0953f8a6dc89525696069b/numpy-2.3.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:81c3e6d8c97295a7360d367f9f8553973651b76907988bb6066376bc2252f24e", size = 20955580, upload-time = "2025-10-15T16:17:02.509Z" },
-    { url = "https://files.pythonhosted.org/packages/af/39/4be9222ffd6ca8a30eda033d5f753276a9c3426c397bb137d8e19dedd200/numpy-2.3.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7c26b0b2bf58009ed1f38a641f3db4be8d960a417ca96d14e5b06df1506d41ff", size = 14188056, upload-time = "2025-10-15T16:17:04.873Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/3d/d85f6700d0a4aa4f9491030e1021c2b2b7421b2b38d01acd16734a2bfdc7/numpy-2.3.4-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:62b2198c438058a20b6704351b35a1d7db881812d8512d67a69c9de1f18ca05f", size = 5116555, upload-time = "2025-10-15T16:17:07.499Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/04/82c1467d86f47eee8a19a464c92f90a9bb68ccf14a54c5224d7031241ffb/numpy-2.3.4-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:9d729d60f8d53a7361707f4b68a9663c968882dd4f09e0d58c044c8bf5faee7b", size = 6643581, upload-time = "2025-10-15T16:17:09.774Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/d3/c79841741b837e293f48bd7db89d0ac7a4f2503b382b78a790ef1dc778a5/numpy-2.3.4-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bd0c630cf256b0a7fd9d0a11c9413b42fef5101219ce6ed5a09624f5a65392c7", size = 14299186, upload-time = "2025-10-15T16:17:11.937Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/7e/4a14a769741fbf237eec5a12a2cbc7a4c4e061852b6533bcb9e9a796c908/numpy-2.3.4-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d5e081bc082825f8b139f9e9fe42942cb4054524598aaeb177ff476cc76d09d2", size = 16638601, upload-time = "2025-10-15T16:17:14.391Z" },
-    { url = "https://files.pythonhosted.org/packages/93/87/1c1de269f002ff0a41173fe01dcc925f4ecff59264cd8f96cf3b60d12c9b/numpy-2.3.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:15fb27364ed84114438fff8aaf998c9e19adbeba08c0b75409f8c452a8692c52", size = 16074219, upload-time = "2025-10-15T16:17:17.058Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/28/18f72ee77408e40a76d691001ae599e712ca2a47ddd2c4f695b16c65f077/numpy-2.3.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:85d9fb2d8cd998c84d13a79a09cc0c1091648e848e4e6249b0ccd7f6b487fa26", size = 18576702, upload-time = "2025-10-15T16:17:19.379Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/76/95650169b465ececa8cf4b2e8f6df255d4bf662775e797ade2025cc51ae6/numpy-2.3.4-cp314-cp314-win32.whl", hash = "sha256:e73d63fd04e3a9d6bc187f5455d81abfad05660b212c8804bf3b407e984cd2bc", size = 6337136, upload-time = "2025-10-15T16:17:22.886Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/89/a231a5c43ede5d6f77ba4a91e915a87dea4aeea76560ba4d2bf185c683f0/numpy-2.3.4-cp314-cp314-win_amd64.whl", hash = "sha256:3da3491cee49cf16157e70f607c03a217ea6647b1cea4819c4f48e53d49139b9", size = 12920542, upload-time = "2025-10-15T16:17:24.783Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/0c/ae9434a888f717c5ed2ff2393b3f344f0ff6f1c793519fa0c540461dc530/numpy-2.3.4-cp314-cp314-win_arm64.whl", hash = "sha256:6d9cd732068e8288dbe2717177320723ccec4fb064123f0caf9bbd90ab5be868", size = 10480213, upload-time = "2025-10-15T16:17:26.935Z" },
-    { url = "https://files.pythonhosted.org/packages/83/4b/c4a5f0841f92536f6b9592694a5b5f68c9ab37b775ff342649eadf9055d3/numpy-2.3.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:22758999b256b595cf0b1d102b133bb61866ba5ceecf15f759623b64c020c9ec", size = 21052280, upload-time = "2025-10-15T16:17:29.638Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/80/90308845fc93b984d2cc96d83e2324ce8ad1fd6efea81b324cba4b673854/numpy-2.3.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:9cb177bc55b010b19798dc5497d540dea67fd13a8d9e882b2dae71de0cf09eb3", size = 14302930, upload-time = "2025-10-15T16:17:32.384Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/4e/07439f22f2a3b247cec4d63a713faae55e1141a36e77fb212881f7cda3fb/numpy-2.3.4-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:0f2bcc76f1e05e5ab58893407c63d90b2029908fa41f9f1cc51eecce936c3365", size = 5231504, upload-time = "2025-10-15T16:17:34.515Z" },
-    { url = "https://files.pythonhosted.org/packages/ab/de/1e11f2547e2fe3d00482b19721855348b94ada8359aef5d40dd57bfae9df/numpy-2.3.4-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:8dc20bde86802df2ed8397a08d793da0ad7a5fd4ea3ac85d757bf5dd4ad7c252", size = 6739405, upload-time = "2025-10-15T16:17:36.128Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/40/8cd57393a26cebe2e923005db5134a946c62fa56a1087dc7c478f3e30837/numpy-2.3.4-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5e199c087e2aa71c8f9ce1cb7a8e10677dc12457e7cc1be4798632da37c3e86e", size = 14354866, upload-time = "2025-10-15T16:17:38.884Z" },
-    { url = "https://files.pythonhosted.org/packages/93/39/5b3510f023f96874ee6fea2e40dfa99313a00bf3ab779f3c92978f34aace/numpy-2.3.4-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:85597b2d25ddf655495e2363fe044b0ae999b75bc4d630dc0d886484b03a5eb0", size = 16703296, upload-time = "2025-10-15T16:17:41.564Z" },
-    { url = "https://files.pythonhosted.org/packages/41/0d/19bb163617c8045209c1996c4e427bccbc4bbff1e2c711f39203c8ddbb4a/numpy-2.3.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:04a69abe45b49c5955923cf2c407843d1c85013b424ae8a560bba16c92fe44a0", size = 16136046, upload-time = "2025-10-15T16:17:43.901Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/c1/6dba12fdf68b02a21ac411c9df19afa66bed2540f467150ca64d246b463d/numpy-2.3.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e1708fac43ef8b419c975926ce1eaf793b0c13b7356cfab6ab0dc34c0a02ac0f", size = 18652691, upload-time = "2025-10-15T16:17:46.247Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/73/f85056701dbbbb910c51d846c58d29fd46b30eecd2b6ba760fc8b8a1641b/numpy-2.3.4-cp314-cp314t-win32.whl", hash = "sha256:863e3b5f4d9915aaf1b8ec79ae560ad21f0b8d5e3adc31e73126491bb86dee1d", size = 6485782, upload-time = "2025-10-15T16:17:48.872Z" },
-    { url = "https://files.pythonhosted.org/packages/17/90/28fa6f9865181cb817c2471ee65678afa8a7e2a1fb16141473d5fa6bacc3/numpy-2.3.4-cp314-cp314t-win_amd64.whl", hash = "sha256:962064de37b9aef801d33bc579690f8bfe6c5e70e29b61783f60bcba838a14d6", size = 13113301, upload-time = "2025-10-15T16:17:50.938Z" },
-    { url = "https://files.pythonhosted.org/packages/54/23/08c002201a8e7e1f9afba93b97deceb813252d9cfd0d3351caed123dcf97/numpy-2.3.4-cp314-cp314t-win_arm64.whl", hash = "sha256:8b5a9a39c45d852b62693d9b3f3e0fe052541f804296ff401a72a1b60edafb29", size = 10547532, upload-time = "2025-10-15T16:17:53.48Z" },
-]
-
 [[package]]
 name = "orjson"
 version = "3.11.4"
@@ -834,6 +876,75 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" },
 ]
 
+[[package]]
+name = "pillow"
+version = "12.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5a/b0/cace85a1b0c9775a9f8f5d5423c8261c858760e2466c79b2dd184638b056/pillow-12.0.0.tar.gz", hash = "sha256:87d4f8125c9988bfbed67af47dd7a953e2fc7b0cc1e7800ec6d2080d490bb353", size = 47008828, upload-time = "2025-10-15T18:24:14.008Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/90/4fcce2c22caf044e660a198d740e7fbc14395619e3cb1abad12192c0826c/pillow-12.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:53561a4ddc36facb432fae7a9d8afbfaf94795414f5cdc5fc52f28c1dca90371", size = 5249377, upload-time = "2025-10-15T18:22:05.993Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/e0/ed960067543d080691d47d6938ebccbf3976a931c9567ab2fbfab983a5dd/pillow-12.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:71db6b4c1653045dacc1585c1b0d184004f0d7e694c7b34ac165ca70c0838082", size = 4650343, upload-time = "2025-10-15T18:22:07.718Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/a1/f81fdeddcb99c044bf7d6faa47e12850f13cee0849537a7d27eeab5534d4/pillow-12.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2fa5f0b6716fc88f11380b88b31fe591a06c6315e955c096c35715788b339e3f", size = 6232981, upload-time = "2025-10-15T18:22:09.287Z" },
+    { url = "https://files.pythonhosted.org/packages/88/e1/9098d3ce341a8750b55b0e00c03f1630d6178f38ac191c81c97a3b047b44/pillow-12.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:82240051c6ca513c616f7f9da06e871f61bfd7805f566275841af15015b8f98d", size = 8041399, upload-time = "2025-10-15T18:22:10.872Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/62/a22e8d3b602ae8cc01446d0c57a54e982737f44b6f2e1e019a925143771d/pillow-12.0.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55f818bd74fe2f11d4d7cbc65880a843c4075e0ac7226bc1a23261dbea531953", size = 6347740, upload-time = "2025-10-15T18:22:12.769Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/87/424511bdcd02c8d7acf9f65caa09f291a519b16bd83c3fb3374b3d4ae951/pillow-12.0.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b87843e225e74576437fd5b6a4c2205d422754f84a06942cfaf1dc32243e45a8", size = 7040201, upload-time = "2025-10-15T18:22:14.813Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/4d/435c8ac688c54d11755aedfdd9f29c9eeddf68d150fe42d1d3dbd2365149/pillow-12.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c607c90ba67533e1b2355b821fef6764d1dd2cbe26b8c1005ae84f7aea25ff79", size = 6462334, upload-time = "2025-10-15T18:22:16.375Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/f2/ad34167a8059a59b8ad10bc5c72d4d9b35acc6b7c0877af8ac885b5f2044/pillow-12.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:21f241bdd5080a15bc86d3466a9f6074a9c2c2b314100dd896ac81ee6db2f1ba", size = 7134162, upload-time = "2025-10-15T18:22:17.996Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/b1/a7391df6adacf0a5c2cf6ac1cf1fcc1369e7d439d28f637a847f8803beb3/pillow-12.0.0-cp312-cp312-win32.whl", hash = "sha256:dd333073e0cacdc3089525c7df7d39b211bcdf31fc2824e49d01c6b6187b07d0", size = 6298769, upload-time = "2025-10-15T18:22:19.923Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/0b/d87733741526541c909bbf159e338dcace4f982daac6e5a8d6be225ca32d/pillow-12.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:9fe611163f6303d1619bbcb653540a4d60f9e55e622d60a3108be0d5b441017a", size = 7001107, upload-time = "2025-10-15T18:22:21.644Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/96/aaa61ce33cc98421fb6088af2a03be4157b1e7e0e87087c888e2370a7f45/pillow-12.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:7dfb439562f234f7d57b1ac6bc8fe7f838a4bd49c79230e0f6a1da93e82f1fad", size = 2436012, upload-time = "2025-10-15T18:22:23.621Z" },
+    { url = "https://files.pythonhosted.org/packages/62/f2/de993bb2d21b33a98d031ecf6a978e4b61da207bef02f7b43093774c480d/pillow-12.0.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:0869154a2d0546545cde61d1789a6524319fc1897d9ee31218eae7a60ccc5643", size = 4045493, upload-time = "2025-10-15T18:22:25.758Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/b6/bc8d0c4c9f6f111a783d045310945deb769b806d7574764234ffd50bc5ea/pillow-12.0.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:a7921c5a6d31b3d756ec980f2f47c0cfdbce0fc48c22a39347a895f41f4a6ea4", size = 4120461, upload-time = "2025-10-15T18:22:27.286Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/57/d60d343709366a353dc56adb4ee1e7d8a2cc34e3fbc22905f4167cfec119/pillow-12.0.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:1ee80a59f6ce048ae13cda1abf7fbd2a34ab9ee7d401c46be3ca685d1999a399", size = 3576912, upload-time = "2025-10-15T18:22:28.751Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/a4/a0a31467e3f83b94d37568294b01d22b43ae3c5d85f2811769b9c66389dd/pillow-12.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c50f36a62a22d350c96e49ad02d0da41dbd17ddc2e29750dbdba4323f85eb4a5", size = 5249132, upload-time = "2025-10-15T18:22:30.641Z" },
+    { url = "https://files.pythonhosted.org/packages/83/06/48eab21dd561de2914242711434c0c0eb992ed08ff3f6107a5f44527f5e9/pillow-12.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5193fde9a5f23c331ea26d0cf171fbf67e3f247585f50c08b3e205c7aeb4589b", size = 4650099, upload-time = "2025-10-15T18:22:32.73Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/bd/69ed99fd46a8dba7c1887156d3572fe4484e3f031405fcc5a92e31c04035/pillow-12.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bde737cff1a975b70652b62d626f7785e0480918dece11e8fef3c0cf057351c3", size = 6230808, upload-time = "2025-10-15T18:22:34.337Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/94/8fad659bcdbf86ed70099cb60ae40be6acca434bbc8c4c0d4ef356d7e0de/pillow-12.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a6597ff2b61d121172f5844b53f21467f7082f5fb385a9a29c01414463f93b07", size = 8037804, upload-time = "2025-10-15T18:22:36.402Z" },
+    { url = "https://files.pythonhosted.org/packages/20/39/c685d05c06deecfd4e2d1950e9a908aa2ca8bc4e6c3b12d93b9cafbd7837/pillow-12.0.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0b817e7035ea7f6b942c13aa03bb554fc44fea70838ea21f8eb31c638326584e", size = 6345553, upload-time = "2025-10-15T18:22:38.066Z" },
+    { url = "https://files.pythonhosted.org/packages/38/57/755dbd06530a27a5ed74f8cb0a7a44a21722ebf318edbe67ddbd7fb28f88/pillow-12.0.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f4f1231b7dec408e8670264ce63e9c71409d9583dd21d32c163e25213ee2a344", size = 7037729, upload-time = "2025-10-15T18:22:39.769Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/b6/7e94f4c41d238615674d06ed677c14883103dce1c52e4af16f000338cfd7/pillow-12.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6e51b71417049ad6ab14c49608b4a24d8fb3fe605e5dfabfe523b58064dc3d27", size = 6459789, upload-time = "2025-10-15T18:22:41.437Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/14/4448bb0b5e0f22dd865290536d20ec8a23b64e2d04280b89139f09a36bb6/pillow-12.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d120c38a42c234dc9a8c5de7ceaaf899cf33561956acb4941653f8bdc657aa79", size = 7130917, upload-time = "2025-10-15T18:22:43.152Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/ca/16c6926cc1c015845745d5c16c9358e24282f1e588237a4c36d2b30f182f/pillow-12.0.0-cp313-cp313-win32.whl", hash = "sha256:4cc6b3b2efff105c6a1656cfe59da4fdde2cda9af1c5e0b58529b24525d0a098", size = 6302391, upload-time = "2025-10-15T18:22:44.753Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/2a/dd43dcfd6dae9b6a49ee28a8eedb98c7d5ff2de94a5d834565164667b97b/pillow-12.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:4cf7fed4b4580601c4345ceb5d4cbf5a980d030fd5ad07c4d2ec589f95f09905", size = 7007477, upload-time = "2025-10-15T18:22:46.838Z" },
+    { url = "https://files.pythonhosted.org/packages/77/f0/72ea067f4b5ae5ead653053212af05ce3705807906ba3f3e8f58ddf617e6/pillow-12.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:9f0b04c6b8584c2c193babcccc908b38ed29524b29dd464bc8801bf10d746a3a", size = 2435918, upload-time = "2025-10-15T18:22:48.399Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/5e/9046b423735c21f0487ea6cb5b10f89ea8f8dfbe32576fe052b5ba9d4e5b/pillow-12.0.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:7fa22993bac7b77b78cae22bad1e2a987ddf0d9015c63358032f84a53f23cdc3", size = 5251406, upload-time = "2025-10-15T18:22:49.905Z" },
+    { url = "https://files.pythonhosted.org/packages/12/66/982ceebcdb13c97270ef7a56c3969635b4ee7cd45227fa707c94719229c5/pillow-12.0.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:f135c702ac42262573fe9714dfe99c944b4ba307af5eb507abef1667e2cbbced", size = 4653218, upload-time = "2025-10-15T18:22:51.587Z" },
+    { url = "https://files.pythonhosted.org/packages/16/b3/81e625524688c31859450119bf12674619429cab3119eec0e30a7a1029cb/pillow-12.0.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c85de1136429c524e55cfa4e033b4a7940ac5c8ee4d9401cc2d1bf48154bbc7b", size = 6266564, upload-time = "2025-10-15T18:22:53.215Z" },
+    { url = "https://files.pythonhosted.org/packages/98/59/dfb38f2a41240d2408096e1a76c671d0a105a4a8471b1871c6902719450c/pillow-12.0.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:38df9b4bfd3db902c9c2bd369bcacaf9d935b2fff73709429d95cc41554f7b3d", size = 8069260, upload-time = "2025-10-15T18:22:54.933Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/3d/378dbea5cd1874b94c312425ca77b0f47776c78e0df2df751b820c8c1d6c/pillow-12.0.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7d87ef5795da03d742bf49439f9ca4d027cde49c82c5371ba52464aee266699a", size = 6379248, upload-time = "2025-10-15T18:22:56.605Z" },
+    { url = "https://files.pythonhosted.org/packages/84/b0/d525ef47d71590f1621510327acec75ae58c721dc071b17d8d652ca494d8/pillow-12.0.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:aff9e4d82d082ff9513bdd6acd4f5bd359f5b2c870907d2b0a9c5e10d40c88fe", size = 7066043, upload-time = "2025-10-15T18:22:58.53Z" },
+    { url = "https://files.pythonhosted.org/packages/61/2c/aced60e9cf9d0cde341d54bf7932c9ffc33ddb4a1595798b3a5150c7ec4e/pillow-12.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:8d8ca2b210ada074d57fcee40c30446c9562e542fc46aedc19baf758a93532ee", size = 6490915, upload-time = "2025-10-15T18:23:00.582Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/26/69dcb9b91f4e59f8f34b2332a4a0a951b44f547c4ed39d3e4dcfcff48f89/pillow-12.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:99a7f72fb6249302aa62245680754862a44179b545ded638cf1fef59befb57ef", size = 7157998, upload-time = "2025-10-15T18:23:02.627Z" },
+    { url = "https://files.pythonhosted.org/packages/61/2b/726235842220ca95fa441ddf55dd2382b52ab5b8d9c0596fe6b3f23dafe8/pillow-12.0.0-cp313-cp313t-win32.whl", hash = "sha256:4078242472387600b2ce8d93ade8899c12bf33fa89e55ec89fe126e9d6d5d9e9", size = 6306201, upload-time = "2025-10-15T18:23:04.709Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/3d/2afaf4e840b2df71344ababf2f8edd75a705ce500e5dc1e7227808312ae1/pillow-12.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:2c54c1a783d6d60595d3514f0efe9b37c8808746a66920315bfd34a938d7994b", size = 7013165, upload-time = "2025-10-15T18:23:06.46Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/75/3fa09aa5cf6ed04bee3fa575798ddf1ce0bace8edb47249c798077a81f7f/pillow-12.0.0-cp313-cp313t-win_arm64.whl", hash = "sha256:26d9f7d2b604cd23aba3e9faf795787456ac25634d82cd060556998e39c6fa47", size = 2437834, upload-time = "2025-10-15T18:23:08.194Z" },
+    { url = "https://files.pythonhosted.org/packages/54/2a/9a8c6ba2c2c07b71bec92cf63e03370ca5e5f5c5b119b742bcc0cde3f9c5/pillow-12.0.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:beeae3f27f62308f1ddbcfb0690bf44b10732f2ef43758f169d5e9303165d3f9", size = 4045531, upload-time = "2025-10-15T18:23:10.121Z" },
+    { url = "https://files.pythonhosted.org/packages/84/54/836fdbf1bfb3d66a59f0189ff0b9f5f666cee09c6188309300df04ad71fa/pillow-12.0.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:d4827615da15cd59784ce39d3388275ec093ae3ee8d7f0c089b76fa87af756c2", size = 4120554, upload-time = "2025-10-15T18:23:12.14Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/cd/16aec9f0da4793e98e6b54778a5fbce4f375c6646fe662e80600b8797379/pillow-12.0.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:3e42edad50b6909089750e65c91aa09aaf1e0a71310d383f11321b27c224ed8a", size = 3576812, upload-time = "2025-10-15T18:23:13.962Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/b7/13957fda356dc46339298b351cae0d327704986337c3c69bb54628c88155/pillow-12.0.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:e5d8efac84c9afcb40914ab49ba063d94f5dbdf5066db4482c66a992f47a3a3b", size = 5252689, upload-time = "2025-10-15T18:23:15.562Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/f5/eae31a306341d8f331f43edb2e9122c7661b975433de5e447939ae61c5da/pillow-12.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:266cd5f2b63ff316d5a1bba46268e603c9caf5606d44f38c2873c380950576ad", size = 4650186, upload-time = "2025-10-15T18:23:17.379Z" },
+    { url = "https://files.pythonhosted.org/packages/86/62/2a88339aa40c4c77e79108facbd307d6091e2c0eb5b8d3cf4977cfca2fe6/pillow-12.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:58eea5ebe51504057dd95c5b77d21700b77615ab0243d8152793dc00eb4faf01", size = 6230308, upload-time = "2025-10-15T18:23:18.971Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/33/5425a8992bcb32d1cb9fa3dd39a89e613d09a22f2c8083b7bf43c455f760/pillow-12.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f13711b1a5ba512d647a0e4ba79280d3a9a045aaf7e0cc6fbe96b91d4cdf6b0c", size = 8039222, upload-time = "2025-10-15T18:23:20.909Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/61/3f5d3b35c5728f37953d3eec5b5f3e77111949523bd2dd7f31a851e50690/pillow-12.0.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6846bd2d116ff42cba6b646edf5bf61d37e5cbd256425fa089fee4ff5c07a99e", size = 6346657, upload-time = "2025-10-15T18:23:23.077Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/be/ee90a3d79271227e0f0a33c453531efd6ed14b2e708596ba5dd9be948da3/pillow-12.0.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c98fa880d695de164b4135a52fd2e9cd7b7c90a9d8ac5e9e443a24a95ef9248e", size = 7038482, upload-time = "2025-10-15T18:23:25.005Z" },
+    { url = "https://files.pythonhosted.org/packages/44/34/a16b6a4d1ad727de390e9bd9f19f5f669e079e5826ec0f329010ddea492f/pillow-12.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa3ed2a29a9e9d2d488b4da81dcb54720ac3104a20bf0bd273f1e4648aff5af9", size = 6461416, upload-time = "2025-10-15T18:23:27.009Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/39/1aa5850d2ade7d7ba9f54e4e4c17077244ff7a2d9e25998c38a29749eb3f/pillow-12.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d034140032870024e6b9892c692fe2968493790dd57208b2c37e3fb35f6df3ab", size = 7131584, upload-time = "2025-10-15T18:23:29.752Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/db/4fae862f8fad0167073a7733973bfa955f47e2cac3dc3e3e6257d10fab4a/pillow-12.0.0-cp314-cp314-win32.whl", hash = "sha256:1b1b133e6e16105f524a8dec491e0586d072948ce15c9b914e41cdadd209052b", size = 6400621, upload-time = "2025-10-15T18:23:32.06Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/24/b350c31543fb0107ab2599464d7e28e6f856027aadda995022e695313d94/pillow-12.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:8dc232e39d409036af549c86f24aed8273a40ffa459981146829a324e0848b4b", size = 7142916, upload-time = "2025-10-15T18:23:34.71Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/9b/0ba5a6fd9351793996ef7487c4fdbde8d3f5f75dbedc093bb598648fddf0/pillow-12.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:d52610d51e265a51518692045e372a4c363056130d922a7351429ac9f27e70b0", size = 2523836, upload-time = "2025-10-15T18:23:36.967Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/7a/ceee0840aebc579af529b523d530840338ecf63992395842e54edc805987/pillow-12.0.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:1979f4566bb96c1e50a62d9831e2ea2d1211761e5662afc545fa766f996632f6", size = 5255092, upload-time = "2025-10-15T18:23:38.573Z" },
+    { url = "https://files.pythonhosted.org/packages/44/76/20776057b4bfd1aef4eeca992ebde0f53a4dce874f3ae693d0ec90a4f79b/pillow-12.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b2e4b27a6e15b04832fe9bf292b94b5ca156016bbc1ea9c2c20098a0320d6cf6", size = 4653158, upload-time = "2025-10-15T18:23:40.238Z" },
+    { url = "https://files.pythonhosted.org/packages/82/3f/d9ff92ace07be8836b4e7e87e6a4c7a8318d47c2f1463ffcf121fc57d9cb/pillow-12.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fb3096c30df99fd01c7bf8e544f392103d0795b9f98ba71a8054bcbf56b255f1", size = 6267882, upload-time = "2025-10-15T18:23:42.434Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/7a/4f7ff87f00d3ad33ba21af78bfcd2f032107710baf8280e3722ceec28cda/pillow-12.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7438839e9e053ef79f7112c881cef684013855016f928b168b81ed5835f3e75e", size = 8071001, upload-time = "2025-10-15T18:23:44.29Z" },
+    { url = "https://files.pythonhosted.org/packages/75/87/fcea108944a52dad8cca0715ae6247e271eb80459364a98518f1e4f480c1/pillow-12.0.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d5c411a8eaa2299322b647cd932586b1427367fd3184ffbb8f7a219ea2041ca", size = 6380146, upload-time = "2025-10-15T18:23:46.065Z" },
+    { url = "https://files.pythonhosted.org/packages/91/52/0d31b5e571ef5fd111d2978b84603fce26aba1b6092f28e941cb46570745/pillow-12.0.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7e091d464ac59d2c7ad8e7e08105eaf9dafbc3883fd7265ffccc2baad6ac925", size = 7067344, upload-time = "2025-10-15T18:23:47.898Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/f4/2dd3d721f875f928d48e83bb30a434dee75a2531bca839bb996bb0aa5a91/pillow-12.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:792a2c0be4dcc18af9d4a2dfd8a11a17d5e25274a1062b0ec1c2d79c76f3e7f8", size = 6491864, upload-time = "2025-10-15T18:23:49.607Z" },
+    { url = "https://files.pythonhosted.org/packages/30/4b/667dfcf3d61fc309ba5a15b141845cece5915e39b99c1ceab0f34bf1d124/pillow-12.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:afbefa430092f71a9593a99ab6a4e7538bc9eabbf7bf94f91510d3503943edc4", size = 7158911, upload-time = "2025-10-15T18:23:51.351Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/2f/16cabcc6426c32218ace36bf0d55955e813f2958afddbf1d391849fee9d1/pillow-12.0.0-cp314-cp314t-win32.whl", hash = "sha256:3830c769decf88f1289680a59d4f4c46c72573446352e2befec9a8512104fa52", size = 6408045, upload-time = "2025-10-15T18:23:53.177Z" },
+    { url = "https://files.pythonhosted.org/packages/35/73/e29aa0c9c666cf787628d3f0dcf379f4791fba79f4936d02f8b37165bdf8/pillow-12.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:905b0365b210c73afb0ebe9101a32572152dfd1c144c7e28968a331b9217b94a", size = 7148282, upload-time = "2025-10-15T18:23:55.316Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/70/6b41bdcddf541b437bbb9f47f94d2db5d9ddef6c37ccab8c9107743748a4/pillow-12.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:99353a06902c2e43b43e8ff74ee65a7d90307d82370604746738a1e0661ccca7", size = 2525630, upload-time = "2025-10-15T18:23:57.149Z" },
+]
+
 [[package]]
 name = "propcache"
 version = "0.4.1"
@@ -918,6 +1029,27 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", hash = "sha256:af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237", size = 13305, upload-time = "2025-10-08T19:49:00.792Z" },
 ]
 
+[[package]]
+name = "pyasn1"
+version = "0.6.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ba/e9/01f1a64245b89f039897cb0130016d79f77d52669aae6ee7b159a6c4c018/pyasn1-0.6.1.tar.gz", hash = "sha256:6f580d2bdd84365380830acf45550f2511469f673cb4a5ae3857a3170128b034", size = 145322, upload-time = "2024-09-10T22:41:42.55Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c8/f1/d6a797abb14f6283c0ddff96bbdd46937f64122b8c925cab503dd37f8214/pyasn1-0.6.1-py3-none-any.whl", hash = "sha256:0d632f46f2ba09143da3a8afe9e33fb6f92fa2320ab7e886e2d0f7672af84629", size = 83135, upload-time = "2024-09-11T16:00:36.122Z" },
+]
+
+[[package]]
+name = "pyasn1-modules"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pyasn1" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e9/e6/78ebbb10a8c8e4b61a59249394a4a594c1a7af95593dc933a349c8d00964/pyasn1_modules-0.4.2.tar.gz", hash = "sha256:677091de870a80aae844b1ca6134f54652fa2c8c5a52aa396440ac3106e941e6", size = 307892, upload-time = "2025-03-28T02:41:22.17Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/47/8d/d529b5d697919ba8c11ad626e835d4039be708a35b0d22de83a269a6682c/pyasn1_modules-0.4.2-py3-none-any.whl", hash = "sha256:29253a9207ce32b64c3ac6600edc75368f98473906e8fd1043bd6b5b1de2c14a", size = 181259, upload-time = "2025-03-28T02:41:19.028Z" },
+]
+
 [[package]]
 name = "pydantic"
 version = "2.12.3"
@@ -1103,6 +1235,33 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
 ]
 
+[[package]]
+name = "requests"
+version = "2.32.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload-time = "2025-08-18T20:46:00.542Z" },
+]
+
+[[package]]
+name = "rsa"
+version = "4.9.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pyasn1" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/da/8a/22b7beea3ee0d44b1916c0c1cb0ee3af23b700b6da9f04991899d0c555d4/rsa-4.9.1.tar.gz", hash = "sha256:e7bdbfdb5497da4c07dfd35530e1a902659db6ff241e39d9953cad06ebd0ae75", size = 29034, upload-time = "2025-04-16T09:51:18.218Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/64/8d/0133e4eb4beed9e425d9a98ed6e081a55d195481b7632472be1af08d2f6b/rsa-4.9.1-py3-none-any.whl", hash = "sha256:68635866661c6836b8d39430f97a996acbd61bfa49406748ea243539fe239762", size = 34696, upload-time = "2025-04-16T09:51:17.142Z" },
+]
+
 [[package]]
 name = "shellingham"
 version = "1.5.4"
@@ -1146,6 +1305,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/51/da/545b75d420bb23b5d494b0517757b351963e974e79933f01e05c929f20a6/starlette-0.49.1-py3-none-any.whl", hash = "sha256:d92ce9f07e4a3caa3ac13a79523bd18e3bc0042bb8ff2d759a8e7dd0e1859875", size = 74175, upload-time = "2025-10-28T17:34:09.13Z" },
 ]
 
+[[package]]
+name = "tenacity"
+version = "9.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0a/d4/2b0cd0fe285e14b36db076e78c93766ff1d529d70408bd1d2a5a84f1d929/tenacity-9.1.2.tar.gz", hash = "sha256:1169d376c297e7de388d18b4481760d478b0e99a777cad3a9c86e556f4b697cb", size = 48036, upload-time = "2025-04-02T08:25:09.966Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/30/643397144bfbfec6f6ef821f36f33e57d35946c44a2352d3c9f0ae847619/tenacity-9.1.2-py3-none-any.whl", hash = "sha256:f77bf36710d8b73a50b2dd155c97b870017ad21afe6ab300326b0371b3b05138", size = 28248, upload-time = "2025-04-02T08:25:07.678Z" },
+]
+
 [[package]]
 name = "tqdm"
 version = "4.67.1"
@@ -1192,17 +1360,26 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
 ]
 
+[[package]]
+name = "urllib3"
+version = "2.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/15/22/9ee70a2574a4f4599c47dd506532914ce044817c7752a79b6a51286319bc/urllib3-2.5.0.tar.gz", hash = "sha256:3fc47733c7e419d4bc3f6b3dc2b4f890bb743906a30d56ba4a5bfa4bbff92760", size = 393185, upload-time = "2025-06-18T14:07:41.644Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a7/c2/fe1e52489ae3122415c51f387e221dd0773709bad6c6cdaa599e8a2c5185/urllib3-2.5.0-py3-none-any.whl", hash = "sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc", size = 129795, upload-time = "2025-06-18T14:07:40.39Z" },
+]
+
 [[package]]
 name = "uvicorn"
-version = "0.38.0"
+version = "0.35.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "click" },
     { name = "h11" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/cb/ce/f06b84e2697fef4688ca63bdb2fdf113ca0a3be33f94488f2cadb690b0cf/uvicorn-0.38.0.tar.gz", hash = "sha256:fd97093bdd120a2609fc0d3afe931d4d4ad688b6e75f0f929fde1bc36fe0e91d", size = 80605, upload-time = "2025-10-18T13:46:44.63Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/5e/42/e0e305207bb88c6b8d3061399c6a961ffe5fbb7e2aa63c9234df7259e9cd/uvicorn-0.35.0.tar.gz", hash = "sha256:bc662f087f7cf2ce11a1d7fd70b90c9f98ef2e2831556dd078d131b96cc94a01", size = 78473, upload-time = "2025-06-28T16:15:46.058Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ee/d9/d88e73ca598f4f6ff671fb5fde8a32925c2e08a637303a1d12883c7305fa/uvicorn-0.38.0-py3-none-any.whl", hash = "sha256:48c0afd214ceb59340075b4a052ea1ee91c16fbc2a9b1469cca0e54566977b02", size = 68109, upload-time = "2025-10-18T13:46:42.958Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/e2/dc81b1bd1dcfe91735810265e9d26bc8ec5da45b4c0f6237e286819194c3/uvicorn-0.35.0-py3-none-any.whl", hash = "sha256:197535216b25ff9b785e29a0b79199f55222193d47f820816e7da751e9bc8d4a", size = 66406, upload-time = "2025-06-28T16:15:44.816Z" },
 ]
 
 [package.optional-dependencies]