@asterai/cli 0.5.0 → 0.6.0

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.0 darwin-arm64 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.0/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.0/src/commands/deploy.ts)_
 
 ## `asterai help [COMMAND]`
 
@@ -97,7 +97,7 @@ DESCRIPTION
   Display help for asterai.
 ```
 
-_See code: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/v6.0.22/src/commands/help.ts)_
+_See code: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/v6.2.0/src/commands/help.ts)_
 
 ## `asterai init [OUTDIR]`
 
@@ -105,7 +105,11 @@ Initialise a new plugin project
 
 ```
 USAGE
-  $ asterai init [OUTDIR]
+  $ asterai init [OUTDIR] [--typescript] [--rust]
+
+FLAGS
+  --rust        init a the plugin project in rust
+  --typescript  init a the plugin project in typescript
 
 DESCRIPTION
   Initialise a new plugin project
@@ -114,7 +118,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.0/src/commands/init.ts)_
 
 ## `asterai pkg [INPUT]`
 
@@ -139,7 +143,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.0/src/commands/pkg.ts)_
 
 ## `asterai query`
 
@@ -162,5 +166,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.0/src/commands/query.ts)_
 <!-- commandsstop -->

package/dist/commands/init.d.ts

@@ -1,10 +1,17 @@
 import { Command } from "@oclif/core";
+export type InitFlags = {
+    rust?: boolean;
+    typescript?: boolean;
+};
 export default class Codegen extends Command {
     static args: {
         outDir: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
     };
     static description: string;
     static examples: string[];
-    static flags: {};
+    static flags: {
+        typescript: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        rust: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
     run(): Promise<void>;
 }

package/dist/commands/init.js

@@ -1,9 +1,10 @@
-import { Args, Command } from "@oclif/core";
+import { Args, Command, Flags } from "@oclif/core";
 import path from "path";
 import fs from "fs";
 import url from "url";
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
-const SOURCE_DIR = path.join(__dirname, "../../asterai-init-plugin");
+const SOURCE_DIR_TYPESCRIPT = path.join(__dirname, "../../init/typescript");
+const SOURCE_DIR_RUST = path.join(__dirname, "../../init/rust");
 export default class Codegen extends Command {
     static args = {
         outDir: Args.string({
@@ -12,10 +13,41 @@ export default class Codegen extends Command {
     };
     static description = "Initialise a new plugin project";
     static examples = [`<%= config.bin %> <%= command.id %> project-name`];
-    static flags = {};
+    static flags = {
+        typescript: Flags.boolean({
+            default: undefined,
+            description: "init a the plugin project in typescript",
+        }),
+        rust: Flags.boolean({
+            default: false,
+            description: "init a the plugin project in rust",
+        }),
+    };
     async run() {
-        const { args } = await this.parse(Codegen);
+        const { args, flags } = await this.parse(Codegen);
+        assertOneLanguageFlag([flags.typescript, flags.rust]);
         const outDir = path.resolve(args.outDir);
-        fs.cpSync(SOURCE_DIR, outDir, { recursive: true });
+        const sourceDir = getSourceDirByFlag(flags);
+        fs.cpSync(sourceDir, outDir, { recursive: true });
     }
 }
+const assertOneLanguageFlag = (flags) => {
+    const undefinedCount = flags.reduce((acc, curr) => (curr === undefined ? acc + 1 : acc), 0);
+    const trueCount = flags.reduce((acc, curr) => (curr ? acc + 1 : acc), 0);
+    if (trueCount === 0 && undefinedCount !== 1) {
+        throw new Error("one language flag must be set");
+    }
+    if (trueCount > 1) {
+        throw new Error("only one language flag can be set");
+    }
+};
+const getSourceDirByFlag = (flags) => {
+    if (flags.rust) {
+        return SOURCE_DIR_RUST;
+    }
+    // Typescript is the default option.
+    if (flags.typescript === true || flags.typescript === undefined) {
+        return SOURCE_DIR_TYPESCRIPT;
+    }
+    throw new Error("Invalid flags configuration.");
+};

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/oclif.manifest.json

@@ -103,7 +103,20 @@
       "examples": [
         "<%= config.bin %> <%= command.id %> project-name"
       ],
-      "flags": {},
+      "flags": {
+        "typescript": {
+          "description": "init a the plugin project in typescript",
+          "name": "typescript",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "rust": {
+          "description": "init a the plugin project in rust",
+          "name": "rust",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
       "hasDynamicHelp": false,
       "hiddenAliases": [],
       "id": "init",
@@ -231,5 +244,5 @@
       ]
     }
   },
-  "version": "0.5.0"
+  "version": "0.6.0"
 }

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.0",
   "author": "asterai <support@asterai.io>",
   "repository": "asterai-io/asterai-sdk",
   "homepage": "https://github.com/asterai-io/asterai-sdk",
@@ -36,7 +36,9 @@
     "/bin",
     "/dist",
     "/oclif.manifest.json",
-    "/asterai-init-plugin"
+    "/init",
+    "!/init/rust/target",
+    "!/init/rust/Cargo.lock"
   ],
   "oclif": {
     "bin": "asterai",