refactor: rename call methods to trigger for consistency across SDKs (#26)

- Updated method names from `call` to `trigger` and `callVoid` to `triggerVoid` in TypeScript, Python, and Rust implementations to standardize terminology.
- Adjusted related type definitions and method implementations to reflect the new naming convention.
- Ensured that the original `call` and `callVoid` methods now delegate to the new `trigger` and `triggerVoid` methods, maintaining backward compatibility.

Author: ytallo

packages/node/iii/src/iii.ts

@@ -224,13 +224,12 @@ class Sdk implements ISdk {
     this.services.set(message.id, { ...message, message_type: MessageType.RegisterService })
   }
 
-  call = async <TInput, TOutput>(
+  trigger = async <TInput, TOutput>(
     function_id: string,
     data: TInput,
     timeoutMs?: number,
   ): Promise<TOutput> => {
     const invocation_id = crypto.randomUUID()
-    // Inject trace context and baggage if available
     const traceparent = injectTraceparent()
     const baggage = injectBaggage()
     const effectiveTimeout = timeoutMs ?? this.invocationTimeoutMs
@@ -266,31 +265,39 @@ class Sdk implements ISdk {
     })
   }
 
-  callVoid = <TInput>(function_id: string, data: TInput): void => {
-    // Inject trace context and baggage if available
+  triggerVoid = <TInput>(function_id: string, data: TInput): void => {
     const traceparent = injectTraceparent()
     const baggage = injectBaggage()
     this.sendMessage(MessageType.InvokeFunction, { function_id, data, traceparent, baggage })
   }
 
+  call = async <TInput, TOutput>(
+    function_id: string,
+    data: TInput,
+    timeoutMs?: number,
+  ): Promise<TOutput> => this.trigger<TInput, TOutput>(function_id, data, timeoutMs)
+
+  callVoid = <TInput>(function_id: string, data: TInput): void =>
+    this.triggerVoid(function_id, data)
+
   listFunctions = async (): Promise<FunctionInfo[]> => {
-    const result = await this.call<Record<string, never>, { functions: FunctionInfo[] }>(
+    const result = await this.trigger<Record<string, never>, { functions: FunctionInfo[] }>(
       EngineFunctions.LIST_FUNCTIONS,
       {},
     )
     return result.functions
   }
 
   listWorkers = async (): Promise<WorkerInfo[]> => {
-    const result = await this.call<Record<string, never>, { workers: WorkerInfo[] }>(
+    const result = await this.trigger<Record<string, never>, { workers: WorkerInfo[] }>(
       EngineFunctions.LIST_WORKERS,
       {},
     )
     return result.workers
   }
 
   private registerWorkerMetadata(): void {
-    this.callVoid(EngineFunctions.REGISTER_WORKER, {
+    this.triggerVoid(EngineFunctions.REGISTER_WORKER, {
       runtime: 'node',
       version: SDK_VERSION,
       name: this.workerName,

packages/node/iii/src/types.ts

@@ -110,7 +110,7 @@ export interface ISdk {
    * @param timeoutMs - Optional timeout in milliseconds
    * @returns The result of the function
    */
-  call<TInput, TOutput>(function_id: string, data: TInput, timeoutMs?: number): Promise<TOutput>
+  trigger<TInput, TOutput>(function_id: string, data: TInput, timeoutMs?: number): Promise<TOutput>
 
   /**
    * Lists all registered functions.
@@ -122,6 +122,15 @@ export interface ISdk {
    * @param function_id - The path to the function
    * @param data - The data to pass to the function
    */
+  triggerVoid<TInput>(function_id: string, data: TInput): void
+
+  /**
+   * Lists all registered functions.
+   */
+  listFunctions(): Promise<FunctionInfo[]>
+
+  call<TInput, TOutput>(function_id: string, data: TInput, timeoutMs?: number): Promise<TOutput>
+
   callVoid<TInput>(function_id: string, data: TInput): void
 
   /**

packages/python/iii/src/iii/iii.py

@@ -532,8 +532,7 @@ def register_service(self, id: str, description: str | None = None, parent_id: s
         self._services[id] = msg
         self._send_if_connected(msg)
 
-    async def call(self, path: str, data: Any, timeout: float = 30.0) -> Any:
-        """Invoke a remote function and wait for the result."""
+    async def trigger(self, path: str, data: Any, timeout: float = 30.0) -> Any:
         invocation_id = str(uuid.uuid4())
         future: asyncio.Future[Any] = asyncio.get_running_loop().create_future()
 
@@ -555,8 +554,7 @@ async def call(self, path: str, data: Any, timeout: float = 30.0) -> Any:
             self._pending.pop(invocation_id, None)
             raise TimeoutError(f"Invocation of '{path}' timed out after {timeout}s")
 
-    def call_void(self, path: str, data: Any) -> None:
-        """Fire-and-forget invocation (no response expected)."""
+    def trigger_void(self, path: str, data: Any) -> None:
         msg = InvokeFunctionMessage(
             function_id=path,
             data=data,
@@ -568,15 +566,21 @@ def call_void(self, path: str, data: Any) -> None:
         except RuntimeError:
             self._enqueue(msg)
 
+    async def call(self, path: str, data: Any, timeout: float = 30.0) -> Any:
+        return await self.trigger(path, data, timeout)
+
+    def call_void(self, path: str, data: Any) -> None:
+        self.trigger_void(path, data)
+
     async def list_functions(self) -> list[FunctionInfo]:
         """List all registered functions from the engine."""
-        result = await self.call("engine::functions::list", {})
+        result = await self.trigger("engine::functions::list", {})
         functions_data = result.get("functions", [])
         return [FunctionInfo(**f) for f in functions_data]
 
     async def list_workers(self) -> list[WorkerInfo]:
         """List all connected workers from the engine."""
-        result = await self.call("engine::workers::list", {})
+        result = await self.trigger("engine::workers::list", {})
         workers_data = result.get("workers", [])
         return [WorkerInfo(**w) for w in workers_data]
 
@@ -598,7 +602,7 @@ def _get_worker_metadata(self) -> dict[str, Any]:
 
     def _register_worker_metadata(self) -> None:
         """Register this worker's metadata with the engine."""
-        self.call_void("engine::workers::register", self._get_worker_metadata())
+        self.trigger_void("engine::workers::register", self._get_worker_metadata())
 
     def on_functions_available(self, callback: Callable[[list[FunctionInfo]], None]) -> Callable[[], None]:
         """Subscribe to function availability events.

packages/python/iii/src/iii/types.py

@@ -86,7 +86,11 @@ def register_function(
         description: str | None = None,
     ) -> Any: ...
 
-    async def call(self, function_id: str, data: Any) -> Any: ...
+    async def trigger(self, function_id: str, data: Any, timeout: float = 30.0) -> Any: ...
+
+    def trigger_void(self, function_id: str, data: Any) -> None: ...
+
+    async def call(self, function_id: str, data: Any, timeout: float = 30.0) -> Any: ...
 
     def call_void(self, function_id: str, data: Any) -> None: ...
 

packages/rust/iii/src/iii.rs

@@ -483,17 +483,17 @@ impl III {
         Ok(Trigger::new(unregister_fn))
     }
 
-    pub async fn call(
+    pub async fn trigger(
         &self,
         function_id: &str,
         data: impl serde::Serialize,
     ) -> Result<Value, IIIError> {
         let value = serde_json::to_value(data)?;
-        self.call_with_timeout(function_id, value, DEFAULT_TIMEOUT)
+        self.trigger_with_timeout(function_id, value, DEFAULT_TIMEOUT)
             .await
     }
 
-    pub async fn call_with_timeout(
+    pub async fn trigger_with_timeout(
         &self,
         function_id: &str,
         data: Value,
@@ -527,7 +527,7 @@ impl III {
         }
     }
 
-    pub fn call_void<TInput>(&self, function_id: &str, data: TInput) -> Result<(), IIIError>
+    pub fn trigger_void<TInput>(&self, function_id: &str, data: TInput) -> Result<(), IIIError>
     where
         TInput: Serialize,
     {
@@ -544,10 +544,34 @@ impl III {
         })
     }
 
+    pub async fn call(
+        &self,
+        function_id: &str,
+        data: impl serde::Serialize,
+    ) -> Result<Value, IIIError> {
+        self.trigger(function_id, data).await
+    }
+
+    pub fn call_void<TInput>(&self, function_id: &str, data: TInput) -> Result<(), IIIError>
+    where
+        TInput: Serialize,
+    {
+        self.trigger_void(function_id, data)
+    }
+
+    pub async fn call_with_timeout(
+        &self,
+        function_id: &str,
+        data: Value,
+        timeout: Duration,
+    ) -> Result<Value, IIIError> {
+        self.trigger_with_timeout(function_id, data, timeout).await
+    }
+
     /// List all registered functions from the engine
     pub async fn list_functions(&self) -> Result<Vec<FunctionInfo>, IIIError> {
         let result = self
-            .call("engine::functions::list", serde_json::json!({}))
+            .trigger("engine::functions::list", serde_json::json!({}))
             .await?;
 
         let functions = result
@@ -642,7 +666,7 @@ impl III {
     /// List all connected workers from the engine
     pub async fn list_workers(&self) -> Result<Vec<WorkerInfo>, IIIError> {
         let result = self
-            .call("engine::workers::list", serde_json::json!({}))
+            .trigger("engine::workers::list", serde_json::json!({}))
             .await?;
 
         let workers = result
@@ -656,7 +680,7 @@ impl III {
     /// List all registered triggers from the engine
     pub async fn list_triggers(&self) -> Result<Vec<TriggerInfo>, IIIError> {
         let result = self
-            .call("engine::triggers::list", serde_json::json!({}))
+            .trigger("engine::triggers::list", serde_json::json!({}))
             .await?;
 
         let triggers = result
@@ -670,7 +694,7 @@ impl III {
     /// Register this worker's metadata with the engine (called automatically on connect)
     fn register_worker_metadata(&self) {
         if let Some(metadata) = self.inner.worker_metadata.lock_or_recover().clone() {
-            let _ = self.call_void("engine::workers::register", metadata);
+            let _ = self.trigger_void("engine::workers::register", metadata);
         }
     }
 
@@ -1112,7 +1136,7 @@ mod tests {
     async fn invoke_function_times_out_and_clears_pending() {
         let iii = III::new("ws://localhost:1234");
         let result = iii
-            .call_with_timeout(
+            .trigger_with_timeout(
                 "functions.echo",
                 json!({ "a": 1 }),
                 Duration::from_millis(10),

packages/rust/iii/src/stream.rs

@@ -91,7 +91,7 @@ impl Streams {
             ops,
         };
 
-        let result = self.iii.call("stream::update", input).await?;
+        let result = self.iii.trigger("stream::update", input).await?;
 
         serde_json::from_value(result).map_err(|e| IIIError::Serde(e.to_string()))
     }