deps: updated tucana v0.0.75

Cargo.toml

@@ -9,7 +9,7 @@ edition = "2024"
 [workspace.dependencies]
 async-trait = "0.1.89"
 code0-flow = { version = "0.0.36" }
-tucana = { version = "0.0.74" }
+tucana = { version = "0.0.75" }
 tokio = { version = "1.44.1", features = ["rt-multi-thread", "signal"] }
 log = "0.4.27"
 futures-lite = "2.6.0"

crates/taurus-core/src/handler/argument.rs

@@ -13,7 +13,6 @@ use tucana::shared::SubFlowSetting;
 #[derive(Clone)]
 pub struct FunctionThunk {
     pub identifier: String,
-    pub result_id: Option<i64>,
     pub parameter_index: i64,
     pub settings: Vec<SubFlowSetting>,
 }
@@ -22,7 +21,6 @@ impl fmt::Debug for FunctionThunk {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("FunctionThunk")
             .field("identifier", &self.identifier)
-            .field("result_id", &self.result_id)
             .field("parameter_index", &self.parameter_index)
             .field("settings_len", &self.settings.len())
             .finish()

crates/taurus-core/src/runtime/engine.rs

@@ -418,10 +418,12 @@ mod tests {
         );
     }
 
-    fn assert_function_result_id(result: &NodeExecutionResult, expected_id: i64) {
+    fn assert_function_result_id(result: &NodeExecutionResult, expected_id: &str) {
         assert_eq!(
             result.id,
-            Some(node_execution_result::Id::FunctionId(expected_id))
+            Some(node_execution_result::Id::FunctionIdentifier(
+                expected_id.to_string()
+            ))
         );
     }
 
@@ -880,7 +882,11 @@ mod tests {
     #[test]
     fn execution_report_includes_function_identifier_subflow_results() {
         let mut handlers = FunctionStore::default();
-        handlers.populate(&[FunctionRegistration::eager("42", echo_first_arg_handler, 1)]);
+        handlers.populate(&[FunctionRegistration::eager(
+            "std::test::echo",
+            echo_first_arg_handler,
+            1,
+        )]);
         let engine = ExecutionEngine { handlers };
 
         let add_node = node(
@@ -890,7 +896,7 @@ mod tests {
                 function_thunk_param(
                     100,
                     "lhs",
-                    "42",
+                    "std::test::echo",
                     vec![subflow_setting("value", Some(int_value(20)), false, true)],
                 ),
                 literal_param(101, "rhs", int_value(2)),
@@ -905,7 +911,7 @@ mod tests {
         assert_eq!(report.node_execution_results.len(), 2);
 
         let function_result = &report.node_execution_results[0];
-        assert_function_result_id(function_result, 42);
+        assert_function_result_id(function_result, "std::test::echo");
         assert_eq!(function_result.parameter_results.len(), 1);
         assert_eq!(
             function_result.parameter_results[0].value,
@@ -1234,7 +1240,12 @@ mod tests {
         let function_results: Vec<_> = report
             .node_execution_results
             .iter()
-            .filter(|result| result.id == Some(node_execution_result::Id::FunctionId(5)))
+            .filter(|result| {
+                result.id
+                    == Some(node_execution_result::Id::FunctionIdentifier(
+                        "std::boolean::from_number".to_string(),
+                    ))
+            })
             .collect();
         assert_eq!(function_results.len(), 3);
 
@@ -1257,9 +1268,18 @@ mod tests {
             }
         }
 
-        assert_function_result_id(&report.node_execution_results[0], 5);
-        assert_function_result_id(&report.node_execution_results[1], 5);
-        assert_function_result_id(&report.node_execution_results[2], 5);
+        assert_function_result_id(
+            &report.node_execution_results[0],
+            "std::boolean::from_number",
+        );
+        assert_function_result_id(
+            &report.node_execution_results[1],
+            "std::boolean::from_number",
+        );
+        assert_function_result_id(
+            &report.node_execution_results[2],
+            "std::boolean::from_number",
+        );
         assert_node_result_id(&report.node_execution_results[3], 2);
         assert_node_result_id(&report.node_execution_results[4], 1);
     }

crates/taurus-core/src/runtime/engine/compiler.rs

@@ -162,7 +162,6 @@ pub fn compile_flow(
                         Some(sub_flow::ExecutionReference::FunctionIdentifier(identifier)) => {
                             CompiledArg::Deferred(CompiledThunk::Function {
                                 identifier: identifier.clone(),
-                                result_id: identifier.parse().ok().or(Some(parameter.database_id)),
                                 parameter_index: parameter_index as i64,
                                 settings: sub_flow.settings.clone(),
                             })

crates/taurus-core/src/runtime/engine/executor.rs

@@ -184,7 +184,6 @@ impl<'a> EngineExecutor<'a> {
         value_store: &mut ValueStore,
     ) -> ExecutionResult {
         let started_at = now_unix_micros();
-        let function_result_id = parse_function_result_id(function);
         let entry = match self.handlers.get(function.identifier.as_str()).copied() {
             Some(entry) => entry,
             None => {
@@ -193,15 +192,13 @@ impl<'a> EngineExecutor<'a> {
                     "FunctionNotFound",
                     format!("Function {} not found", function.identifier),
                 );
-                if let Some(function_id) = function_result_id {
-                    value_store.insert_function_error_with_timing(
-                        function_id,
-                        error.clone(),
-                        Vec::new(),
-                        started_at,
-                        now_unix_micros(),
-                    );
-                }
+                value_store.insert_function_error_with_timing(
+                    function.identifier.clone(),
+                    error.clone(),
+                    Vec::new(),
+                    started_at,
+                    now_unix_micros(),
+                );
                 return ExecutionResult {
                     signal: Signal::Failure(error),
                     root_frame: None,
@@ -220,17 +217,15 @@ impl<'a> EngineExecutor<'a> {
             Err(err) => {
                 let signal = Signal::Failure(err);
                 self.trace_exit(frame_id, &signal, value_store);
-                if let Some(function_id) = function_result_id {
-                    let parameter_results = Vec::new();
-                    self.commit_function_result(
-                        function_id,
-                        signal.clone(),
-                        parameter_results,
-                        started_at,
-                        now_unix_micros(),
-                        value_store,
-                    );
-                }
+                let parameter_results = Vec::new();
+                self.commit_function_result(
+                    function.identifier.as_str(),
+                    signal.clone(),
+                    parameter_results,
+                    started_at,
+                    now_unix_micros(),
+                    value_store,
+                );
                 return ExecutionResult {
                     signal,
                     root_frame: frame_id,
@@ -257,16 +252,14 @@ impl<'a> EngineExecutor<'a> {
             };
 
         self.trace_exit(frame_id, &signal, value_store);
-        if let Some(function_id) = function_result_id {
-            self.commit_function_result(
-                function_id,
-                signal.clone(),
-                parameter_results,
-                started_at,
-                now_unix_micros(),
-                value_store,
-            );
-        }
+        self.commit_function_result(
+            function.identifier.as_str(),
+            signal.clone(),
+            parameter_results,
+            started_at,
+            now_unix_micros(),
+            value_store,
+        );
 
         ExecutionResult {
             signal,
@@ -783,7 +776,7 @@ impl<'a> EngineExecutor<'a> {
 
     fn commit_function_result(
         &self,
-        function_id: i64,
+        function_id: &str,
         signal: Signal,
         parameter_results: Vec<NodeParameterNodeExecutionResult>,
         started_at: i64,
@@ -793,7 +786,7 @@ impl<'a> EngineExecutor<'a> {
         match signal {
             Signal::Success(value) => {
                 value_store.insert_function_success_with_timing(
-                    function_id,
+                    function_id.to_string(),
                     value.clone(),
                     parameter_results,
                     started_at,
@@ -803,7 +796,7 @@ impl<'a> EngineExecutor<'a> {
             }
             Signal::Failure(err) => {
                 value_store.insert_function_error_with_timing(
-                    function_id,
+                    function_id.to_string(),
                     err.clone(),
                     parameter_results,
                     started_at,
@@ -959,24 +952,16 @@ fn compiled_thunk_to_argument(thunk: &CompiledThunk) -> Thunk {
         CompiledThunk::Node(node_id) => Thunk::Node(*node_id),
         CompiledThunk::Function {
             identifier,
-            result_id,
             parameter_index,
             settings,
         } => Thunk::Function(FunctionThunk {
             identifier: identifier.clone(),
-            result_id: *result_id,
             parameter_index: *parameter_index,
             settings: settings.clone(),
         }),
     }
 }
 
-fn parse_function_result_id(function: &FunctionThunk) -> Option<i64> {
-    function
-        .result_id
-        .or_else(|| function.identifier.parse::<i64>().ok())
-}
-
 fn resolve_function_setting(
     function: &FunctionThunk,
     setting: &SubFlowSetting,

crates/taurus-core/src/runtime/engine/model.rs

@@ -26,7 +26,6 @@ pub enum CompiledThunk {
     Node(i64),
     Function {
         identifier: String,
-        result_id: Option<i64>,
         parameter_index: i64,
         settings: Vec<SubFlowSetting>,
     },

crates/taurus-core/src/runtime/execution/value_store.rs

@@ -194,7 +194,7 @@ impl ValueStore {
 
     pub fn insert_function_success_with_timing(
         &mut self,
-        id: i64,
+        id: String,
         value: Value,
         parameter_results: Vec<NodeParameterNodeExecutionResult>,
         started_at: i64,
@@ -204,14 +204,14 @@ impl ValueStore {
             started_at,
             finished_at,
             parameter_results,
-            id: Some(TucanaNodeResultId::FunctionId(id)),
+            id: Some(TucanaNodeResultId::FunctionIdentifier(id)),
             result: Some(TucanaNodeResult::Success(value)),
         });
     }
 
     pub fn insert_function_error_with_timing(
         &mut self,
-        id: i64,
+        id: String,
         runtime_error: RuntimeError,
         parameter_results: Vec<NodeParameterNodeExecutionResult>,
         started_at: i64,
@@ -221,7 +221,7 @@ impl ValueStore {
             started_at,
             finished_at,
             parameter_results,
-            id: Some(TucanaNodeResultId::FunctionId(id)),
+            id: Some(TucanaNodeResultId::FunctionIdentifier(id)),
             result: Some(TucanaNodeResult::Error(runtime_error.as_tucana_error())),
         });
     }

crates/taurus-manual/src/main.rs

@@ -418,9 +418,11 @@ fn null_value() -> Value {
 }
 
 fn execution_result_id_label(result: &NodeExecutionResult) -> String {
-    match result.id {
+    match &result.id {
         Some(NodeExecutionResultId::NodeId(id)) => format!("node_id={}", id),
-        Some(NodeExecutionResultId::FunctionId(id)) => format!("function_id={}", id),
+        Some(NodeExecutionResultId::FunctionIdentifier(id)) => {
+            format!("function_identifier={}", id)
+        }
         None => "id=<missing>".to_string(),
     }
 }