refactor(rust-sdk)!: simplify register_function — 3 constructors + IIIError handlers

console/packages/console-rust/src/main.rs

@@ -118,7 +118,6 @@ async fn main() -> Result<()> {
             }),
             otel: otel_config,
             headers: None,
-            ..Default::default()
         },
     );
 

crates/iii-worker/src/cli/worker_manager_daemon.rs

@@ -15,7 +15,9 @@ use crate::core::{
     list as core_list, remove as core_remove, start as core_start, stop as core_stop,
     update as core_update,
 };
-use iii_sdk::{III, InitOptions, OtelConfig, RegisterFunction, WorkerMetadata, register_worker};
+use iii_sdk::{
+    III, IIIError, InitOptions, OtelConfig, RegisterFunction, WorkerMetadata, register_worker,
+};
 use schemars::{JsonSchema, schema_for};
 use serde_json::Value;
 
@@ -72,6 +74,18 @@ pub fn bad_request_payload(input_label: &str, e: &serde_json::Error) -> String {
     err_payload(&err)
 }
 
+fn handler_error(payload: String) -> IIIError {
+    IIIError::Handler(payload)
+}
+
+fn op_error(e: &WorkerOpError) -> IIIError {
+    handler_error(err_payload(e))
+}
+
+fn bad_request_error(input_label: &str, e: &serde_json::Error) -> IIIError {
+    handler_error(bad_request_payload(input_label, e))
+}
+
 fn schema_for_value<T: JsonSchema>() -> Option<Value> {
     serde_json::to_value(schema_for!(T)).ok()
 }
@@ -130,9 +144,10 @@ struct SchemaResponse {
 
 fn register_schema(iii: &III) {
     let _ = iii.register_function(
-        RegisterFunction::new_async("worker::schema", |payload: Value| async move {
+        "worker::schema",
+        RegisterFunction::new_async(|payload: Value| async move {
             let req: SchemaRequest = serde_json::from_value(payload)
-                .map_err(|e| bad_request_payload("worker::schema", &e))?;
+                .map_err(|e| bad_request_error("worker::schema", &e))?;
             let all = vec![
                 (
                     "worker::add",
@@ -199,7 +214,7 @@ fn register_schema(iii: &III) {
                     }
                 })
                 .collect();
-            Ok::<_, String>(SchemaResponse { schemas })
+            Ok::<_, IIIError>(SchemaResponse { schemas })
         })
         .description(
             "Introspect request/response schemas for worker::* triggers. \
@@ -210,12 +225,13 @@ fn register_schema(iii: &III) {
 
 fn register_add(iii: &III, project_root: PathBuf) {
     let _ = iii.register_function(
-        RegisterFunction::new_async("worker::add", move |payload: Value| {
+        "worker::add",
+        RegisterFunction::new_async(move |payload: Value| {
             let project_root = project_root.clone();
             async move {
                 let opts: AddOptions = serde_json::from_value(payload)
-                    .map_err(|e| bad_request_payload("worker::add", &e))?;
-                let ctx = ProjectCtx::open(project_root).map_err(|e| err_payload(&e))?;
+                    .map_err(|e| bad_request_error("worker::add", &e))?;
+                let ctx = ProjectCtx::open(project_root).map_err(|e| op_error(&e))?;
                 core_add::run(
                     opts,
                     &ctx,
@@ -224,7 +240,7 @@ fn register_add(iii: &III, project_root: PathBuf) {
                     core_add::CallerMode::Trigger,
                 )
                 .await
-                .map_err(|e| err_payload(&e))
+                .map_err(|e| op_error(&e))
             }
         })
         .description("Install a worker from registry name or OCI ref"),
@@ -233,15 +249,16 @@ fn register_add(iii: &III, project_root: PathBuf) {
 
 fn register_remove(iii: &III, project_root: PathBuf) {
     let _ = iii.register_function(
-        RegisterFunction::new_async("worker::remove", move |payload: Value| {
+        "worker::remove",
+        RegisterFunction::new_async(move |payload: Value| {
             let project_root = project_root.clone();
             async move {
                 let opts: RemoveOptions = serde_json::from_value(payload)
-                    .map_err(|e| bad_request_payload("worker::remove", &e))?;
-                let ctx = ProjectCtx::open(project_root).map_err(|e| err_payload(&e))?;
+                    .map_err(|e| bad_request_error("worker::remove", &e))?;
+                let ctx = ProjectCtx::open(project_root).map_err(|e| op_error(&e))?;
                 core_remove::run(opts, &ctx, &NullSink, &CliHostShim)
                     .await
-                    .map_err(|e| err_payload(&e))
+                    .map_err(|e| op_error(&e))
             }
         })
         .description("Uninstall workers and clear their artifacts"),
@@ -250,15 +267,16 @@ fn register_remove(iii: &III, project_root: PathBuf) {
 
 fn register_update(iii: &III, project_root: PathBuf) {
     let _ = iii.register_function(
-        RegisterFunction::new_async("worker::update", move |payload: Value| {
+        "worker::update",
+        RegisterFunction::new_async(move |payload: Value| {
             let project_root = project_root.clone();
             async move {
                 let opts: UpdateOptions = serde_json::from_value(payload)
-                    .map_err(|e| bad_request_payload("worker::update", &e))?;
-                let ctx = ProjectCtx::open(project_root).map_err(|e| err_payload(&e))?;
+                    .map_err(|e| bad_request_error("worker::update", &e))?;
+                let ctx = ProjectCtx::open(project_root).map_err(|e| op_error(&e))?;
                 core_update::run(opts, &ctx, &NullSink, &CliHostShim)
                     .await
-                    .map_err(|e| err_payload(&e))
+                    .map_err(|e| op_error(&e))
             }
         })
         .description("Reinstall workers preserving config"),
@@ -267,15 +285,16 @@ fn register_update(iii: &III, project_root: PathBuf) {
 
 fn register_start(iii: &III, project_root: PathBuf) {
     let _ = iii.register_function(
-        RegisterFunction::new_async("worker::start", move |payload: Value| {
+        "worker::start",
+        RegisterFunction::new_async(move |payload: Value| {
             let project_root = project_root.clone();
             async move {
                 let opts: StartOptions = serde_json::from_value(payload)
-                    .map_err(|e| bad_request_payload("worker::start", &e))?;
-                let ctx = ProjectCtx::open(project_root).map_err(|e| err_payload(&e))?;
+                    .map_err(|e| bad_request_error("worker::start", &e))?;
+                let ctx = ProjectCtx::open(project_root).map_err(|e| op_error(&e))?;
                 core_start::run(opts, &ctx, &NullSink, &CliHostShim)
                     .await
-                    .map_err(|e| err_payload(&e))
+                    .map_err(|e| op_error(&e))
             }
         })
         .description("Start a configured worker"),
@@ -284,15 +303,16 @@ fn register_start(iii: &III, project_root: PathBuf) {
 
 fn register_stop(iii: &III, project_root: PathBuf) {
     let _ = iii.register_function(
-        RegisterFunction::new_async("worker::stop", move |payload: Value| {
+        "worker::stop",
+        RegisterFunction::new_async(move |payload: Value| {
             let project_root = project_root.clone();
             async move {
                 let opts: StopOptions = serde_json::from_value(payload)
-                    .map_err(|e| bad_request_payload("worker::stop", &e))?;
-                let ctx = ProjectCtx::open(project_root).map_err(|e| err_payload(&e))?;
+                    .map_err(|e| bad_request_error("worker::stop", &e))?;
+                let ctx = ProjectCtx::open(project_root).map_err(|e| op_error(&e))?;
                 core_stop::run(opts, &ctx, &NullSink, &CliHostShim)
                     .await
-                    .map_err(|e| err_payload(&e))
+                    .map_err(|e| op_error(&e))
             }
         })
         .description("Stop a running worker"),
@@ -301,7 +321,8 @@ fn register_stop(iii: &III, project_root: PathBuf) {
 
 fn register_list(iii: &III, project_root: PathBuf) {
     let _ = iii.register_function(
-        RegisterFunction::new_async("worker::list", move |payload: Value| {
+        "worker::list",
+        RegisterFunction::new_async(move |payload: Value| {
             let project_root = project_root.clone();
             async move {
                 // Lenient default only for null or empty object. Other shapes
@@ -311,12 +332,12 @@ fn register_list(iii: &III, project_root: PathBuf) {
                     Value::Null => ListOptions::default(),
                     Value::Object(map) if map.is_empty() => ListOptions::default(),
                     _ => serde_json::from_value(payload)
-                        .map_err(|e| bad_request_payload("worker::list", &e))?,
+                        .map_err(|e| bad_request_error("worker::list", &e))?,
                 };
                 let ctx = ProjectCtx::open_unlocked(project_root);
                 core_list::run(opts, &ctx, &NullSink, &CliHostShim)
                     .await
-                    .map_err(|e| err_payload(&e))
+                    .map_err(|e| op_error(&e))
             }
         })
         .description("List installed workers"),
@@ -325,15 +346,16 @@ fn register_list(iii: &III, project_root: PathBuf) {
 
 fn register_clear(iii: &III, project_root: PathBuf) {
     let _ = iii.register_function(
-        RegisterFunction::new_async("worker::clear", move |payload: Value| {
+        "worker::clear",
+        RegisterFunction::new_async(move |payload: Value| {
             let project_root = project_root.clone();
             async move {
                 let opts: ClearOptions = serde_json::from_value(payload)
-                    .map_err(|e| bad_request_payload("worker::clear", &e))?;
-                let ctx = ProjectCtx::open(project_root).map_err(|e| err_payload(&e))?;
+                    .map_err(|e| bad_request_error("worker::clear", &e))?;
+                let ctx = ProjectCtx::open(project_root).map_err(|e| op_error(&e))?;
                 core_clear::run(opts, &ctx, &NullSink, &CliHostShim)
                     .await
-                    .map_err(|e| err_payload(&e))
+                    .map_err(|e| op_error(&e))
             }
         })
         .description("Wipe worker artifacts"),

crates/iii-worker/src/sandbox_daemon/fs/chmod.rs

@@ -5,7 +5,7 @@ use std::future::Future;
 use std::pin::Pin;
 use std::sync::Arc;
 
-use iii_sdk::{IIIError, RegisterFunctionMessage};
+use iii_sdk::IIIError;
 use iii_shell_proto::{FsOp, FsResult};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -91,16 +91,10 @@ pub(super) fn register(
             }
         }) as Pin<Box<dyn Future<Output = Result<Value, IIIError>> + Send>>
     };
-    let _ = iii.register_function_with(
-        RegisterFunctionMessage {
-            id: "sandbox::fs::chmod".to_string(),
-            description: Some("Change file permissions inside a sandbox".to_string()),
-            request_format: None,
-            response_format: None,
-            metadata: None,
-            invocation: None,
-        },
-        handler,
+    let _ = iii.register_function(
+        "sandbox::fs::chmod",
+        iii_sdk::RegisterFunction::new_async(handler)
+            .description("Change file permissions inside a sandbox".to_string()),
     );
 }
 

crates/iii-worker/src/sandbox_daemon/fs/grep.rs

@@ -5,7 +5,7 @@ use std::future::Future;
 use std::pin::Pin;
 use std::sync::Arc;
 
-use iii_sdk::{IIIError, RegisterFunctionMessage};
+use iii_sdk::IIIError;
 use iii_shell_proto::{FsMatch, FsOp, FsResult};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -111,16 +111,10 @@ pub(super) fn register(
             }
         }) as Pin<Box<dyn Future<Output = Result<Value, IIIError>> + Send>>
     };
-    let _ = iii.register_function_with(
-        RegisterFunctionMessage {
-            id: "sandbox::fs::grep".to_string(),
-            description: Some("Search for a pattern in files inside a sandbox".to_string()),
-            request_format: None,
-            response_format: None,
-            metadata: None,
-            invocation: None,
-        },
-        handler,
+    let _ = iii.register_function(
+        "sandbox::fs::grep",
+        iii_sdk::RegisterFunction::new_async(handler)
+            .description("Search for a pattern in files inside a sandbox".to_string()),
     );
 }
 

crates/iii-worker/src/sandbox_daemon/fs/ls.rs

@@ -5,7 +5,7 @@ use std::future::Future;
 use std::pin::Pin;
 use std::sync::Arc;
 
-use iii_sdk::{IIIError, RegisterFunctionMessage};
+use iii_sdk::IIIError;
 use iii_shell_proto::{FsEntry, FsOp, FsResult};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -75,16 +75,10 @@ pub(super) fn register(
             }
         }) as Pin<Box<dyn Future<Output = Result<Value, IIIError>> + Send>>
     };
-    let _ = iii.register_function_with(
-        RegisterFunctionMessage {
-            id: "sandbox::fs::ls".to_string(),
-            description: Some("List directory contents inside a sandbox".to_string()),
-            request_format: None,
-            response_format: None,
-            metadata: None,
-            invocation: None,
-        },
-        handler,
+    let _ = iii.register_function(
+        "sandbox::fs::ls",
+        iii_sdk::RegisterFunction::new_async(handler)
+            .description("List directory contents inside a sandbox".to_string()),
     );
 }
 

crates/iii-worker/src/sandbox_daemon/fs/mkdir.rs

@@ -5,7 +5,7 @@ use std::future::Future;
 use std::pin::Pin;
 use std::sync::Arc;
 
-use iii_sdk::{IIIError, RegisterFunctionMessage};
+use iii_sdk::IIIError;
 use iii_shell_proto::{FsOp, FsResult};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -90,16 +90,10 @@ pub(super) fn register(
             }
         }) as Pin<Box<dyn Future<Output = Result<Value, IIIError>> + Send>>
     };
-    let _ = iii.register_function_with(
-        RegisterFunctionMessage {
-            id: "sandbox::fs::mkdir".to_string(),
-            description: Some("Create a directory inside a sandbox".to_string()),
-            request_format: None,
-            response_format: None,
-            metadata: None,
-            invocation: None,
-        },
-        handler,
+    let _ = iii.register_function(
+        "sandbox::fs::mkdir",
+        iii_sdk::RegisterFunction::new_async(handler)
+            .description("Create a directory inside a sandbox".to_string()),
     );
 }
 

crates/iii-worker/src/sandbox_daemon/fs/mv.rs

@@ -5,7 +5,7 @@ use std::future::Future;
 use std::pin::Pin;
 use std::sync::Arc;
 
-use iii_sdk::{IIIError, RegisterFunctionMessage};
+use iii_sdk::IIIError;
 use iii_shell_proto::{FsOp, FsResult};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -85,16 +85,10 @@ pub(super) fn register(
             }
         }) as Pin<Box<dyn Future<Output = Result<Value, IIIError>> + Send>>
     };
-    let _ = iii.register_function_with(
-        RegisterFunctionMessage {
-            id: "sandbox::fs::mv".to_string(),
-            description: Some("Move or rename a path inside a sandbox".to_string()),
-            request_format: None,
-            response_format: None,
-            metadata: None,
-            invocation: None,
-        },
-        handler,
+    let _ = iii.register_function(
+        "sandbox::fs::mv",
+        iii_sdk::RegisterFunction::new_async(handler)
+            .description("Move or rename a path inside a sandbox".to_string()),
     );
 }
 

crates/iii-worker/src/sandbox_daemon/fs/read.rs

@@ -15,8 +15,8 @@ use std::future::Future;
 use std::pin::Pin;
 use std::sync::Arc;
 
+use iii_sdk::IIIError;
 use iii_sdk::channels::StreamChannelRef;
-use iii_sdk::{IIIError, RegisterFunctionMessage};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use tokio::io::AsyncReadExt;
@@ -149,16 +149,10 @@ pub(super) fn register(
             }
         }) as Pin<Box<dyn Future<Output = Result<Value, IIIError>> + Send>>
     };
-    let _ = iii.register_function_with(
-        RegisterFunctionMessage {
-            id: "sandbox::fs::read".to_string(),
-            description: Some("Stream-download a file from a sandbox".to_string()),
-            request_format: None,
-            response_format: None,
-            metadata: None,
-            invocation: None,
-        },
-        handler,
+    let _ = iii.register_function(
+        "sandbox::fs::read",
+        iii_sdk::RegisterFunction::new_async(handler)
+            .description("Stream-download a file from a sandbox".to_string()),
     );
 }