@asterai/cli 0.5.0 → 0.6.1

package/README.md

@@ -20,7 +20,7 @@ $ npm install -g @asterai/cli
 $ asterai COMMAND
 running command...
 $ asterai (--version)
-@asterai/cli/0.5.0 linux-x64 node-v20.12.2
+@asterai/cli/0.6.1 linux-x64 node-v20.12.2
 $ asterai --help [COMMAND]
 USAGE
   $ asterai COMMAND
@@ -53,7 +53,7 @@ EXAMPLES
   $ asterai auth
 ```
 
-_See code: [src/commands/auth.ts](https://github.com/asterai-io/asterai-sdk/blob/v0.5.0/src/commands/auth.ts)_
+_See code: [src/commands/auth.ts](https://github.com/asterai-io/asterai-sdk/blob/v0.6.1/src/commands/auth.ts)_
 
 ## `asterai deploy`
 
@@ -77,7 +77,7 @@ EXAMPLES
   $ asterai deploy --app 66a46b12-b1a7-4b72-a64a-0e4fe21902b6
 ```
 
-_See code: [src/commands/deploy.ts](https://github.com/asterai-io/asterai-sdk/blob/v0.5.0/src/commands/deploy.ts)_
+_See code: [src/commands/deploy.ts](https://github.com/asterai-io/asterai-sdk/blob/v0.6.1/src/commands/deploy.ts)_
 
 ## `asterai help [COMMAND]`
 
@@ -114,7 +114,7 @@ EXAMPLES
   $ asterai init project-name
 ```
 
-_See code: [src/commands/init.ts](https://github.com/asterai-io/asterai-sdk/blob/v0.5.0/src/commands/init.ts)_
+_See code: [src/commands/init.ts](https://github.com/asterai-io/asterai-sdk/blob/v0.6.1/src/commands/init.ts)_
 
 ## `asterai pkg [INPUT]`
 
@@ -139,7 +139,7 @@ EXAMPLES
   $ asterai pkg
 ```
 
-_See code: [src/commands/pkg.ts](https://github.com/asterai-io/asterai-sdk/blob/v0.5.0/src/commands/pkg.ts)_
+_See code: [src/commands/pkg.ts](https://github.com/asterai-io/asterai-sdk/blob/v0.6.1/src/commands/pkg.ts)_
 
 ## `asterai query`
 
@@ -162,5 +162,5 @@ EXAMPLES
   $ asterai query
 ```
 
-_See code: [src/commands/query.ts](https://github.com/asterai-io/asterai-sdk/blob/v0.5.0/src/commands/query.ts)_
+_See code: [src/commands/query.ts](https://github.com/asterai-io/asterai-sdk/blob/v0.6.1/src/commands/query.ts)_
 <!-- commandsstop -->

package/init/rust/.gitignore

@@ -0,0 +1,2 @@
+target/
+wit/

package/init/rust/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "plugin"
+# Note that this version does not matter for the plugin,
+# only the one in plugin.wit is used.
+version = "0.0.0"
+edition = "2021"
+publish = false
+
+[dependencies]
+wit-bindgen-rt = { version = "0.39.0", features = ["bitflags"] }
+
+[lib]
+crate-type = ["cdylib"]
+
+[profile.release]
+codegen-units = 1
+opt-level = "s"
+debug = false
+strip = true
+lto = true
+
+[package.metadata.component]
+package = "your-username:plugin"
+
+[package.metadata.component.dependencies]

package/init/rust/build.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+set -e
+mkdir -p wit
+asterai pkg -o wit/package.wasm -w wit/package.wit
+cargo component build --release

package/init/rust/deploy.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -e
+if [ -z "$1" ]; then
+  echo "Deploying without agent ID. Optionally, pass it: $0 <agent ID>"
+fi
+bash ./build.sh
+asterai deploy --pkg wit/package.wasm --plugin target/wasm32-wasip1/release/plugin.wasm -a "$1"

package/init/rust/plugin.wit

@@ -0,0 +1,10 @@
+package your-username:greeter@0.1.0;
+
+interface greeter {
+  greet: func(name: string);
+}
+
+world plugin {
+  import asterai:host/api@0.1.0;
+  export greeter;
+}

package/init/rust/src/bindings.rs

@@ -0,0 +1,685 @@
+// Generated by `wit-bindgen` 0.36.0. DO NOT EDIT!
+// Options used:
+//   * runtime_path: "wit_bindgen_rt"
+#[rustfmt::skip]
+#[allow(dead_code, clippy::all)]
+pub mod asterai {
+    pub mod host {
+        #[allow(dead_code, clippy::all)]
+        pub mod api {
+            #[used]
+            #[doc(hidden)]
+            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
+            use super::super::super::_rt;
+            #[derive(Clone)]
+            pub struct EmbeddingSimilarityScore {
+                pub score: f32,
+                pub payload: _rt::Vec<(_rt::String, _rt::String)>,
+            }
+            impl ::core::fmt::Debug for EmbeddingSimilarityScore {
+                fn fmt(
+                    &self,
+                    f: &mut ::core::fmt::Formatter<'_>,
+                ) -> ::core::fmt::Result {
+                    f.debug_struct("EmbeddingSimilarityScore")
+                        .field("score", &self.score)
+                        .field("payload", &self.payload)
+                        .finish()
+                }
+            }
+            #[derive(Clone)]
+            pub struct Query {
+                pub content: _rt::String,
+                pub user_id: Option<_rt::String>,
+            }
+            impl ::core::fmt::Debug for Query {
+                fn fmt(
+                    &self,
+                    f: &mut ::core::fmt::Formatter<'_>,
+                ) -> ::core::fmt::Result {
+                    f.debug_struct("Query")
+                        .field("content", &self.content)
+                        .field("user-id", &self.user_id)
+                        .finish()
+                }
+            }
+            #[derive(Clone)]
+            pub struct PluginContext {
+                pub query: Query,
+                pub app_id: _rt::String,
+            }
+            impl ::core::fmt::Debug for PluginContext {
+                fn fmt(
+                    &self,
+                    f: &mut ::core::fmt::Formatter<'_>,
+                ) -> ::core::fmt::Result {
+                    f.debug_struct("PluginContext")
+                        .field("query", &self.query)
+                        .field("app-id", &self.app_id)
+                        .finish()
+                }
+            }
+            #[derive(Clone)]
+            pub struct QueryAgentArgs {
+                pub query: _rt::String,
+                pub agent_id: _rt::String,
+                pub query_key: Option<_rt::String>,
+            }
+            impl ::core::fmt::Debug for QueryAgentArgs {
+                fn fmt(
+                    &self,
+                    f: &mut ::core::fmt::Formatter<'_>,
+                ) -> ::core::fmt::Result {
+                    f.debug_struct("QueryAgentArgs")
+                        .field("query", &self.query)
+                        .field("agent-id", &self.agent_id)
+                        .field("query-key", &self.query_key)
+                        .finish()
+                }
+            }
+            #[derive(Clone)]
+            pub struct QueryAgentResponse {
+                pub content: _rt::String,
+            }
+            impl ::core::fmt::Debug for QueryAgentResponse {
+                fn fmt(
+                    &self,
+                    f: &mut ::core::fmt::Formatter<'_>,
+                ) -> ::core::fmt::Result {
+                    f.debug_struct("QueryAgentResponse")
+                        .field("content", &self.content)
+                        .finish()
+                }
+            }
+            #[allow(unused_unsafe, clippy::all)]
+            pub fn embedding_store(content: &str, collection_name: &str) {
+                unsafe {
+                    let vec0 = content;
+                    let ptr0 = vec0.as_ptr().cast::<u8>();
+                    let len0 = vec0.len();
+                    let vec1 = collection_name;
+                    let ptr1 = vec1.as_ptr().cast::<u8>();
+                    let len1 = vec1.len();
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "asterai:host/api@0.1.0")]
+                    extern "C" {
+                        #[link_name = "embedding-store"]
+                        fn wit_import(_: *mut u8, _: usize, _: *mut u8, _: usize);
+                    }
+                    #[cfg(not(target_arch = "wasm32"))]
+                    fn wit_import(_: *mut u8, _: usize, _: *mut u8, _: usize) {
+                        unreachable!()
+                    }
+                    wit_import(ptr0.cast_mut(), len0, ptr1.cast_mut(), len1);
+                }
+            }
+            #[allow(unused_unsafe, clippy::all)]
+            pub fn embedding_search(
+                query: &str,
+                collection_name: &str,
+            ) -> _rt::Vec<EmbeddingSimilarityScore> {
+                unsafe {
+                    #[repr(align(4))]
+                    struct RetArea([::core::mem::MaybeUninit<u8>; 8]);
+                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 8]);
+                    let vec0 = query;
+                    let ptr0 = vec0.as_ptr().cast::<u8>();
+                    let len0 = vec0.len();
+                    let vec1 = collection_name;
+                    let ptr1 = vec1.as_ptr().cast::<u8>();
+                    let len1 = vec1.len();
+                    let ptr2 = ret_area.0.as_mut_ptr().cast::<u8>();
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "asterai:host/api@0.1.0")]
+                    extern "C" {
+                        #[link_name = "embedding-search"]
+                        fn wit_import(
+                            _: *mut u8,
+                            _: usize,
+                            _: *mut u8,
+                            _: usize,
+                            _: *mut u8,
+                        );
+                    }
+                    #[cfg(not(target_arch = "wasm32"))]
+                    fn wit_import(
+                        _: *mut u8,
+                        _: usize,
+                        _: *mut u8,
+                        _: usize,
+                        _: *mut u8,
+                    ) {
+                        unreachable!()
+                    }
+                    wit_import(ptr0.cast_mut(), len0, ptr1.cast_mut(), len1, ptr2);
+                    let l3 = *ptr2.add(0).cast::<*mut u8>();
+                    let l4 = *ptr2.add(4).cast::<usize>();
+                    let base15 = l3;
+                    let len15 = l4;
+                    let mut result15 = _rt::Vec::with_capacity(len15);
+                    for i in 0..len15 {
+                        let base = base15.add(i * 12);
+                        let e15 = {
+                            let l5 = *base.add(0).cast::<f32>();
+                            let l6 = *base.add(4).cast::<*mut u8>();
+                            let l7 = *base.add(8).cast::<usize>();
+                            let base14 = l6;
+                            let len14 = l7;
+                            let mut result14 = _rt::Vec::with_capacity(len14);
+                            for i in 0..len14 {
+                                let base = base14.add(i * 16);
+                                let e14 = {
+                                    let l8 = *base.add(0).cast::<*mut u8>();
+                                    let l9 = *base.add(4).cast::<usize>();
+                                    let len10 = l9;
+                                    let bytes10 = _rt::Vec::from_raw_parts(
+                                        l8.cast(),
+                                        len10,
+                                        len10,
+                                    );
+                                    let l11 = *base.add(8).cast::<*mut u8>();
+                                    let l12 = *base.add(12).cast::<usize>();
+                                    let len13 = l12;
+                                    let bytes13 = _rt::Vec::from_raw_parts(
+                                        l11.cast(),
+                                        len13,
+                                        len13,
+                                    );
+                                    (_rt::string_lift(bytes10), _rt::string_lift(bytes13))
+                                };
+                                result14.push(e14);
+                            }
+                            _rt::cabi_dealloc(base14, len14 * 16, 4);
+                            EmbeddingSimilarityScore {
+                                score: l5,
+                                payload: result14,
+                            }
+                        };
+                        result15.push(e15);
+                    }
+                    _rt::cabi_dealloc(base15, len15 * 12, 4);
+                    result15
+                }
+            }
+            #[allow(unused_unsafe, clippy::all)]
+            pub fn kv_get(key: &str, user_id: Option<&str>) -> Option<_rt::String> {
+                unsafe {
+                    #[repr(align(4))]
+                    struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
+                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]);
+                    let vec0 = key;
+                    let ptr0 = vec0.as_ptr().cast::<u8>();
+                    let len0 = vec0.len();
+                    let (result2_0, result2_1, result2_2) = match user_id {
+                        Some(e) => {
+                            let vec1 = e;
+                            let ptr1 = vec1.as_ptr().cast::<u8>();
+                            let len1 = vec1.len();
+                            (1i32, ptr1.cast_mut(), len1)
+                        }
+                        None => (0i32, ::core::ptr::null_mut(), 0usize),
+                    };
+                    let ptr3 = ret_area.0.as_mut_ptr().cast::<u8>();
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "asterai:host/api@0.1.0")]
+                    extern "C" {
+                        #[link_name = "kv-get"]
+                        fn wit_import(
+                            _: *mut u8,
+                            _: usize,
+                            _: i32,
+                            _: *mut u8,
+                            _: usize,
+                            _: *mut u8,
+                        );
+                    }
+                    #[cfg(not(target_arch = "wasm32"))]
+                    fn wit_import(
+                        _: *mut u8,
+                        _: usize,
+                        _: i32,
+                        _: *mut u8,
+                        _: usize,
+                        _: *mut u8,
+                    ) {
+                        unreachable!()
+                    }
+                    wit_import(
+                        ptr0.cast_mut(),
+                        len0,
+                        result2_0,
+                        result2_1,
+                        result2_2,
+                        ptr3,
+                    );
+                    let l4 = i32::from(*ptr3.add(0).cast::<u8>());
+                    match l4 {
+                        0 => None,
+                        1 => {
+                            let e = {
+                                let l5 = *ptr3.add(4).cast::<*mut u8>();
+                                let l6 = *ptr3.add(8).cast::<usize>();
+                                let len7 = l6;
+                                let bytes7 = _rt::Vec::from_raw_parts(
+                                    l5.cast(),
+                                    len7,
+                                    len7,
+                                );
+                                _rt::string_lift(bytes7)
+                            };
+                            Some(e)
+                        }
+                        _ => _rt::invalid_enum_discriminant(),
+                    }
+                }
+            }
+            #[allow(unused_unsafe, clippy::all)]
+            pub fn kv_set(key: &str, value: Option<&str>, user_id: Option<&str>) {
+                unsafe {
+                    let vec0 = key;
+                    let ptr0 = vec0.as_ptr().cast::<u8>();
+                    let len0 = vec0.len();
+                    let (result2_0, result2_1, result2_2) = match value {
+                        Some(e) => {
+                            let vec1 = e;
+                            let ptr1 = vec1.as_ptr().cast::<u8>();
+                            let len1 = vec1.len();
+                            (1i32, ptr1.cast_mut(), len1)
+                        }
+                        None => (0i32, ::core::ptr::null_mut(), 0usize),
+                    };
+                    let (result4_0, result4_1, result4_2) = match user_id {
+                        Some(e) => {
+                            let vec3 = e;
+                            let ptr3 = vec3.as_ptr().cast::<u8>();
+                            let len3 = vec3.len();
+                            (1i32, ptr3.cast_mut(), len3)
+                        }
+                        None => (0i32, ::core::ptr::null_mut(), 0usize),
+                    };
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "asterai:host/api@0.1.0")]
+                    extern "C" {
+                        #[link_name = "kv-set"]
+                        fn wit_import(
+                            _: *mut u8,
+                            _: usize,
+                            _: i32,
+                            _: *mut u8,
+                            _: usize,
+                            _: i32,
+                            _: *mut u8,
+                            _: usize,
+                        );
+                    }
+                    #[cfg(not(target_arch = "wasm32"))]
+                    fn wit_import(
+                        _: *mut u8,
+                        _: usize,
+                        _: i32,
+                        _: *mut u8,
+                        _: usize,
+                        _: i32,
+                        _: *mut u8,
+                        _: usize,
+                    ) {
+                        unreachable!()
+                    }
+                    wit_import(
+                        ptr0.cast_mut(),
+                        len0,
+                        result2_0,
+                        result2_1,
+                        result2_2,
+                        result4_0,
+                        result4_1,
+                        result4_2,
+                    );
+                }
+            }
+            #[allow(unused_unsafe, clippy::all)]
+            pub fn get_env(key: &str) -> Option<_rt::String> {
+                unsafe {
+                    #[repr(align(4))]
+                    struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
+                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]);
+                    let vec0 = key;
+                    let ptr0 = vec0.as_ptr().cast::<u8>();
+                    let len0 = vec0.len();
+                    let ptr1 = ret_area.0.as_mut_ptr().cast::<u8>();
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "asterai:host/api@0.1.0")]
+                    extern "C" {
+                        #[link_name = "get-env"]
+                        fn wit_import(_: *mut u8, _: usize, _: *mut u8);
+                    }
+                    #[cfg(not(target_arch = "wasm32"))]
+                    fn wit_import(_: *mut u8, _: usize, _: *mut u8) {
+                        unreachable!()
+                    }
+                    wit_import(ptr0.cast_mut(), len0, ptr1);
+                    let l2 = i32::from(*ptr1.add(0).cast::<u8>());
+                    match l2 {
+                        0 => None,
+                        1 => {
+                            let e = {
+                                let l3 = *ptr1.add(4).cast::<*mut u8>();
+                                let l4 = *ptr1.add(8).cast::<usize>();
+                                let len5 = l4;
+                                let bytes5 = _rt::Vec::from_raw_parts(
+                                    l3.cast(),
+                                    len5,
+                                    len5,
+                                );
+                                _rt::string_lift(bytes5)
+                            };
+                            Some(e)
+                        }
+                        _ => _rt::invalid_enum_discriminant(),
+                    }
+                }
+            }
+            #[allow(unused_unsafe, clippy::all)]
+            pub fn get_context() -> PluginContext {
+                unsafe {
+                    #[repr(align(4))]
+                    struct RetArea([::core::mem::MaybeUninit<u8>; 28]);
+                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 28]);
+                    let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "asterai:host/api@0.1.0")]
+                    extern "C" {
+                        #[link_name = "get-context"]
+                        fn wit_import(_: *mut u8);
+                    }
+                    #[cfg(not(target_arch = "wasm32"))]
+                    fn wit_import(_: *mut u8) {
+                        unreachable!()
+                    }
+                    wit_import(ptr0);
+                    let l1 = *ptr0.add(0).cast::<*mut u8>();
+                    let l2 = *ptr0.add(4).cast::<usize>();
+                    let len3 = l2;
+                    let bytes3 = _rt::Vec::from_raw_parts(l1.cast(), len3, len3);
+                    let l4 = i32::from(*ptr0.add(8).cast::<u8>());
+                    let l8 = *ptr0.add(20).cast::<*mut u8>();
+                    let l9 = *ptr0.add(24).cast::<usize>();
+                    let len10 = l9;
+                    let bytes10 = _rt::Vec::from_raw_parts(l8.cast(), len10, len10);
+                    PluginContext {
+                        query: Query {
+                            content: _rt::string_lift(bytes3),
+                            user_id: match l4 {
+                                0 => None,
+                                1 => {
+                                    let e = {
+                                        let l5 = *ptr0.add(12).cast::<*mut u8>();
+                                        let l6 = *ptr0.add(16).cast::<usize>();
+                                        let len7 = l6;
+                                        let bytes7 = _rt::Vec::from_raw_parts(
+                                            l5.cast(),
+                                            len7,
+                                            len7,
+                                        );
+                                        _rt::string_lift(bytes7)
+                                    };
+                                    Some(e)
+                                }
+                                _ => _rt::invalid_enum_discriminant(),
+                            },
+                        },
+                        app_id: _rt::string_lift(bytes10),
+                    }
+                }
+            }
+            #[allow(unused_unsafe, clippy::all)]
+            pub fn send_response_to_agent(response: &str) {
+                unsafe {
+                    let vec0 = response;
+                    let ptr0 = vec0.as_ptr().cast::<u8>();
+                    let len0 = vec0.len();
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "asterai:host/api@0.1.0")]
+                    extern "C" {
+                        #[link_name = "send-response-to-agent"]
+                        fn wit_import(_: *mut u8, _: usize);
+                    }
+                    #[cfg(not(target_arch = "wasm32"))]
+                    fn wit_import(_: *mut u8, _: usize) {
+                        unreachable!()
+                    }
+                    wit_import(ptr0.cast_mut(), len0);
+                }
+            }
+            #[allow(unused_unsafe, clippy::all)]
+            pub fn query_agent(
+                args: &QueryAgentArgs,
+            ) -> Result<QueryAgentResponse, _rt::String> {
+                unsafe {
+                    #[repr(align(4))]
+                    struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
+                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]);
+                    let QueryAgentArgs {
+                        query: query0,
+                        agent_id: agent_id0,
+                        query_key: query_key0,
+                    } = args;
+                    let vec1 = query0;
+                    let ptr1 = vec1.as_ptr().cast::<u8>();
+                    let len1 = vec1.len();
+                    let vec2 = agent_id0;
+                    let ptr2 = vec2.as_ptr().cast::<u8>();
+                    let len2 = vec2.len();
+                    let (result4_0, result4_1, result4_2) = match query_key0 {
+                        Some(e) => {
+                            let vec3 = e;
+                            let ptr3 = vec3.as_ptr().cast::<u8>();
+                            let len3 = vec3.len();
+                            (1i32, ptr3.cast_mut(), len3)
+                        }
+                        None => (0i32, ::core::ptr::null_mut(), 0usize),
+                    };
+                    let ptr5 = ret_area.0.as_mut_ptr().cast::<u8>();
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "asterai:host/api@0.1.0")]
+                    extern "C" {
+                        #[link_name = "query-agent"]
+                        fn wit_import(
+                            _: *mut u8,
+                            _: usize,
+                            _: *mut u8,
+                            _: usize,
+                            _: i32,
+                            _: *mut u8,
+                            _: usize,
+                            _: *mut u8,
+                        );
+                    }
+                    #[cfg(not(target_arch = "wasm32"))]
+                    fn wit_import(
+                        _: *mut u8,
+                        _: usize,
+                        _: *mut u8,
+                        _: usize,
+                        _: i32,
+                        _: *mut u8,
+                        _: usize,
+                        _: *mut u8,
+                    ) {
+                        unreachable!()
+                    }
+                    wit_import(
+                        ptr1.cast_mut(),
+                        len1,
+                        ptr2.cast_mut(),
+                        len2,
+                        result4_0,
+                        result4_1,
+                        result4_2,
+                        ptr5,
+                    );
+                    let l6 = i32::from(*ptr5.add(0).cast::<u8>());
+                    match l6 {
+                        0 => {
+                            let e = {
+                                let l7 = *ptr5.add(4).cast::<*mut u8>();
+                                let l8 = *ptr5.add(8).cast::<usize>();
+                                let len9 = l8;
+                                let bytes9 = _rt::Vec::from_raw_parts(
+                                    l7.cast(),
+                                    len9,
+                                    len9,
+                                );
+                                QueryAgentResponse {
+                                    content: _rt::string_lift(bytes9),
+                                }
+                            };
+                            Ok(e)
+                        }
+                        1 => {
+                            let e = {
+                                let l10 = *ptr5.add(4).cast::<*mut u8>();
+                                let l11 = *ptr5.add(8).cast::<usize>();
+                                let len12 = l11;
+                                let bytes12 = _rt::Vec::from_raw_parts(
+                                    l10.cast(),
+                                    len12,
+                                    len12,
+                                );
+                                _rt::string_lift(bytes12)
+                            };
+                            Err(e)
+                        }
+                        _ => _rt::invalid_enum_discriminant(),
+                    }
+                }
+            }
+        }
+    }
+}
+#[rustfmt::skip]
+#[allow(dead_code, clippy::all)]
+pub mod exports {
+    pub mod your_username {
+        pub mod greeter {
+            #[allow(dead_code, clippy::all)]
+            pub mod greeter {
+                #[used]
+                #[doc(hidden)]
+                static __FORCE_SECTION_REF: fn() = super::super::super::super::__link_custom_section_describing_imports;
+                use super::super::super::super::_rt;
+                #[doc(hidden)]
+                #[allow(non_snake_case)]
+                pub unsafe fn _export_greet_cabi<T: Guest>(arg0: *mut u8, arg1: usize) {
+                    #[cfg(target_arch = "wasm32")] _rt::run_ctors_once();
+                    let len0 = arg1;
+                    let bytes0 = _rt::Vec::from_raw_parts(arg0.cast(), len0, len0);
+                    T::greet(_rt::string_lift(bytes0));
+                }
+                pub trait Guest {
+                    fn greet(name: _rt::String);
+                }
+                #[doc(hidden)]
+                macro_rules! __export_your_username_greeter_greeter_0_1_0_cabi {
+                    ($ty:ident with_types_in $($path_to_types:tt)*) => {
+                        const _ : () = { #[export_name =
+                        "your-username:greeter/greeter@0.1.0#greet"] unsafe extern "C" fn
+                        export_greet(arg0 : * mut u8, arg1 : usize,) {
+                        $($path_to_types)*:: _export_greet_cabi::<$ty > (arg0, arg1) } };
+                    };
+                }
+                #[doc(hidden)]
+                pub(crate) use __export_your_username_greeter_greeter_0_1_0_cabi;
+            }
+        }
+    }
+}
+#[rustfmt::skip]
+mod _rt {
+    pub use alloc_crate::vec::Vec;
+    pub use alloc_crate::string::String;
+    pub unsafe fn string_lift(bytes: Vec<u8>) -> String {
+        if cfg!(debug_assertions) {
+            String::from_utf8(bytes).unwrap()
+        } else {
+            String::from_utf8_unchecked(bytes)
+        }
+    }
+    pub unsafe fn cabi_dealloc(ptr: *mut u8, size: usize, align: usize) {
+        if size == 0 {
+            return;
+        }
+        let layout = alloc::Layout::from_size_align_unchecked(size, align);
+        alloc::dealloc(ptr, layout);
+    }
+    pub unsafe fn invalid_enum_discriminant<T>() -> T {
+        if cfg!(debug_assertions) {
+            panic!("invalid enum discriminant")
+        } else {
+            core::hint::unreachable_unchecked()
+        }
+    }
+    #[cfg(target_arch = "wasm32")]
+    pub fn run_ctors_once() {
+        wit_bindgen_rt::run_ctors_once();
+    }
+    extern crate alloc as alloc_crate;
+    pub use alloc_crate::alloc;
+}
+/// Generates `#[no_mangle]` functions to export the specified type as the
+/// root implementation of all generated traits.
+///
+/// For more information see the documentation of `wit_bindgen::generate!`.
+///
+/// ```rust
+/// # macro_rules! export{ ($($t:tt)*) => (); }
+/// # trait Guest {}
+/// struct MyType;
+///
+/// impl Guest for MyType {
+///     // ...
+/// }
+///
+/// export!(MyType);
+/// ```
+#[allow(unused_macros)]
+#[doc(hidden)]
+macro_rules! __export_plugin_impl {
+    ($ty:ident) => {
+        self::export!($ty with_types_in self);
+    };
+    ($ty:ident with_types_in $($path_to_types_root:tt)*) => {
+        $($path_to_types_root)*::
+        exports::your_username::greeter::greeter::__export_your_username_greeter_greeter_0_1_0_cabi!($ty
+        with_types_in $($path_to_types_root)*::
+        exports::your_username::greeter::greeter);
+    };
+}
+#[doc(inline)]
+pub(crate) use __export_plugin_impl as export;
+#[cfg(target_arch = "wasm32")]
+#[link_section = "component-type:wit-bindgen:0.36.0:your-username:greeter@0.1.0:plugin:encoded world"]
+#[doc(hidden)]
+pub static __WIT_BINDGEN_COMPONENT_TYPE: [u8; 776] = *b"\
+\0asm\x0d\0\x01\0\0\x19\x16wit-component-encoding\x04\0\x07\x8b\x05\x01A\x02\x01\
+A\x04\x01B\x1f\x01o\x02ss\x01p\0\x01r\x02\x05scorev\x07payload\x01\x04\0\x1aembe\
+dding-similarity-score\x03\0\x02\x01ks\x01r\x02\x07contents\x07user-id\x04\x04\0\
+\x05query\x03\0\x05\x01r\x02\x05query\x06\x06app-ids\x04\0\x0eplugin-context\x03\
+\0\x07\x01r\x03\x05querys\x08agent-ids\x09query-key\x04\x04\0\x10query-agent-arg\
+s\x03\0\x09\x01r\x01\x07contents\x04\0\x14query-agent-response\x03\0\x0b\x01@\x02\
+\x07contents\x0fcollection-names\x01\0\x04\0\x0fembedding-store\x01\x0d\x01p\x03\
+\x01@\x02\x05querys\x0fcollection-names\0\x0e\x04\0\x10embedding-search\x01\x0f\x01\
+@\x02\x03keys\x07user-id\x04\0\x04\x04\0\x06kv-get\x01\x10\x01@\x03\x03keys\x05v\
+alue\x04\x07user-id\x04\x01\0\x04\0\x06kv-set\x01\x11\x01@\x01\x03keys\0\x04\x04\
+\0\x07get-env\x01\x12\x01@\0\0\x08\x04\0\x0bget-context\x01\x13\x01@\x01\x08resp\
+onses\x01\0\x04\0\x16send-response-to-agent\x01\x14\x01j\x01\x0c\x01s\x01@\x01\x04\
+args\x0a\0\x15\x04\0\x0bquery-agent\x01\x16\x03\0\x16asterai:host/api@0.1.0\x05\0\
+\x01B\x02\x01@\x01\x04names\x01\0\x04\0\x05greet\x01\0\x04\0#your-username:greet\
+er/greeter@0.1.0\x05\x01\x04\0\"your-username:greeter/plugin@0.1.0\x04\0\x0b\x0c\
+\x01\0\x06plugin\x03\0\0\0G\x09producers\x01\x0cprocessed-by\x02\x0dwit-componen\
+t\x070.220.0\x10wit-bindgen-rust\x060.36.0";
+#[inline(never)]
+#[doc(hidden)]
+pub fn __link_custom_section_describing_imports() {
+    wit_bindgen_rt::maybe_link_cabi_realloc();
+}

package/init/rust/src/lib.rs

@@ -0,0 +1,16 @@
+use crate::bindings::asterai::host::api;
+use crate::bindings::exports::your_username::greeter::greeter::Guest;
+
+#[allow(warnings)]
+mod bindings;
+
+struct Component;
+
+impl Guest for Component {
+    fn greet(name: String) {
+        let greeting = format!("hello {name}");
+        api::send_response_to_agent(&greeting);
+    }
+}
+
+bindings::export!(Component with_types_in bindings);

package/init/typescript/.gitignore

@@ -0,0 +1,10 @@
+.idea/
+node_modules/
+package-lock.json
+pnpm-lock.yaml
+build/
+generated/
+.vscode/
+tsconfig.tsbuildinfo
+*.wasm
+typegen/

package/{asterai-init-plugin → init/typescript}/package.json

@@ -17,7 +17,7 @@
   "devDependencies": {
     "@asterai/cli": "latest",
     "@asterai/sdk": "latest",
-    "@bytecodealliance/jco": "^1.9.1",
+    "@bytecodealliance/jco": "^1.10.2",
     "@types/node": "^22.13.4",
     "mkdirp": "^3.0.1",
     "npm-run-all": "^4.1.5",

package/{asterai-init-plugin → init/typescript}/plugin.ts

@@ -1,11 +1,13 @@
-import { BinaryOperationInput } from "./generated/plugin";
 import * as asterai from "asterai:host/api@0.1.0";
+import { BinaryOperationResult } from "example:math/plugin@0.1.0";
 
-export const add = (input: BinaryOperationInput): number => {
-  const result = input.a + input.b;
+export const mul = (a: number, b: number): BinaryOperationResult => {
+  const result = a + b;
   // Send the calculation result to the agent.
   asterai.sendResponseToAgent(`the result is ${result}`);
   // This result is not seen by the agent, but it can be consumed by
   // other plugins calling this function.
-  return result;
+  return {
+    value: result,
+  };
 };

package/init/typescript/plugin.wit

@@ -0,0 +1,11 @@
+package example:math@0.1.0;
+
+world plugin {
+  import asterai:host/api@0.1.0;
+
+  export mul: func(a: f32, b: f32) -> binary-operation-result;
+
+  record binary-operation-result {
+    value: f64,
+  }
+}

package/init/typescript/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "include": ["./**/*.ts"],
+  "compilerOptions": {
+    "outDir": "build",
+    "module": "ESNext",
+    "moduleResolution": "node"
+  }
+}

package/oclif.manifest.json

@@ -231,5 +231,5 @@
       ]
     }
   },
-  "version": "0.5.0"
+  "version": "0.6.1"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@asterai/cli",
   "description": "CLI for building and deploying asterai plugins",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "author": "asterai <support@asterai.io>",
   "repository": "asterai-io/asterai-sdk",
   "homepage": "https://github.com/asterai-io/asterai-sdk",
@@ -13,18 +13,6 @@
   "license": "UNLICENSED",
   "main": "dist/index.js",
   "type": "module",
-  "scripts": {
-    "prepare": "cd .. && husky cli/.husky",
-    "build": "shx rm -rf dist && tsc -b",
-    "lint": "eslint . --ext .ts",
-    "postpack": "shx rm -f oclif.manifest.json",
-    "posttest": "pnpm run lint",
-    "prepack": "oclif manifest && oclif readme",
-    "test": "mocha --forbid-only \"test/**/*.test.ts\"",
-    "version": "oclif readme && git add README.md",
-    "format": "prettier --write .",
-    "format-staged": "pretty-quick --staged"
-  },
   "bin": {
     "asterai": "./bin/run.js"
   },
@@ -36,7 +24,15 @@
     "/bin",
     "/dist",
     "/oclif.manifest.json",
-    "/asterai-init-plugin"
+    "/init",
+    "/init/rust/.gitignore",
+    "/init/typescript/.gitignore",
+    "!/init/rust/target",
+    "!/init/rust/Cargo.lock",
+    "!/init/typescript/build",
+    "!/init/typescript/node_modules",
+    "!/init/typescript/generated",
+    "!/init/typescript/pnpm-lock.yaml"
   ],
   "oclif": {
     "bin": "asterai",
@@ -83,5 +79,14 @@
     "shx": "^0.3.3",
     "ts-node": "^10",
     "typescript": "^5"
+  },
+  "scripts": {
+    "build": "shx rm -rf dist && tsc -b",
+    "lint": "eslint . --ext .ts",
+    "posttest": "pnpm run lint",
+    "test": "mocha --forbid-only \"test/**/*.test.ts\"",
+    "version": "oclif readme && git add README.md",
+    "format": "prettier --write .",
+    "format-staged": "pretty-quick --staged"
   }
-}
+}

package/asterai-init-plugin/plugin.wit

@@ -1,12 +0,0 @@
-package example:math@0.1.0;
-
-world plugin {
-  import asterai:host/api@0.1.0;
-
-  export add: func(input: binary-operation-input) -> s32;
-
-  record binary-operation-input {
-    a: f64,
-    b: f64,
-  }
-}

package/asterai-init-plugin/tsconfig.json

@@ -1,11 +0,0 @@
-{
-  "include": ["./**/*.ts"],
-  "compilerOptions": {
-    "outDir": "build",
-    "module": "ESNext",
-    "moduleResolution": "node",
-    "paths": {
-      "asterai:host/api@0.1.0": ["./generated/interfaces/asterai-host-api.d.ts"]
-    }
-  }
-}