zust-vm 0.9.40

Cranelift JIT runtime for executing Zust modules.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use crate::memory::alloc_dynamic;
use anyhow::Result;
use base64::{Engine as _, engine::general_purpose};
use dynamic::{Dynamic, Type};
use std::future::Future;

extern "C" fn llm_complete(openai: *const Dynamic, value: *const Dynamic) -> *const Dynamic {
    let openai = unsafe { (&*openai).clone() };
    let value = unsafe { (&*value).clone() };
    let result = root::sync_await!(llm::complete(openai, value, None)).unwrap_or(Dynamic::Null);
    alloc_dynamic(result)
}

extern "C" fn llm_audio(openai: *const Dynamic, value: *const Dynamic) -> *const Dynamic {
    let openai = unsafe { (&*openai).clone() };
    let value = unsafe { (&*value).clone() };
    let text = root::sync_await!(llm::audio_recognize(openai, value)).ok().unwrap_or(Dynamic::Null);
    alloc_dynamic(text)
}

extern "C" fn llm_tts(openai: *const Dynamic, value: *const Dynamic) -> *const Dynamic {
    let openai = unsafe { (&*openai).clone() };
    let value = unsafe { (&*value).clone() };
    let audio = root::sync_await!(llm::tts(openai, value)).ok().unwrap_or(Dynamic::Null);
    alloc_dynamic(audio)
}

fn task_value(id: &str, status: &str, info: Dynamic) -> Dynamic {
    dynamic::map!("id"=> id, "status"=> status, "info"=> info)
}

fn start_llm_task<F, Fut>(info: Dynamic, f: F) -> Dynamic
where
    F: FnOnce() -> Fut + 'static + Send,
    Fut: Future<Output = Result<Dynamic>> + 'static + Send,
{
    let id = uuid::Uuid::new_v4().to_string();
    let path = format!("local/tasks/{}", id);
    let running = task_value(&id, "running", info.deep_clone());
    let done_id = id.clone();
    let done_path = path.clone();
    let done_info = info.deep_clone();
    let runner = async move {
        match f().await {
            Ok(result) => {
                let _ = root::add_value(&done_path, dynamic::map!("id"=> done_id, "status"=> "done", "info"=> done_info, "result"=> result));
                Ok(())
            }
            Err(err) => {
                let _ = root::add_value(&done_path, dynamic::map!("id"=> done_id, "status"=> "error", "info"=> done_info, "error"=> err.to_string()));
                Err(err)
            }
        }
    };

    let object = if tokio::runtime::Handle::try_current().is_ok() {
        root::Object::Task(tokio::task::spawn(runner), running)
    } else {
        root::Object::ThreadTask(
            std::thread::spawn(move || {
                let rt = tokio::runtime::Runtime::new().unwrap();
                rt.block_on(runner)
            }),
            running,
        )
    };
    let _ = root::add(&path, object);
    id.into()
}

extern "C" fn llm_deep(openai: *const Dynamic, value: *const Dynamic, notifier: *const Dynamic) -> *const Dynamic {
    //启动一个任务 使用 消息点来接收 中间消息
    let openai = unsafe { (&*openai).clone() };
    let value = unsafe { (&*value).clone() };
    let notifier = unsafe { (&*notifier).clone() };
    let id = start_llm_task(value.clone(), || async move {
        let r = llm::complete(openai, value, Some(notifier.clone())).await?;
        llm::notify(&notifier, r.clone())?;
        Ok(r)
    });
    alloc_dynamic(id.into())
}

fn image_url(value: &Dynamic) -> Option<Dynamic> {
    value.get_dynamic("url").or_else(|| value.get_dynamic("image_url")).or_else(|| value.get_dynamic("image"))
}

fn image_b64(value: &Dynamic) -> Option<Dynamic> {
    value.get_dynamic("b64_json").or_else(|| value.get_dynamic("base64")).or_else(|| value.get_dynamic("image_base64"))
}

async fn store_generated_image(result: &Dynamic, image_name: &str) -> Option<String> {
    if let Some(b64) = image_b64(result) {
        if let Ok(data) = general_purpose::STANDARD.decode(b64.as_str()) {
            let _ = root::insert("redis/images", image_name, Dynamic::Bytes(data));
            return Some(format!("/images/{}", image_name));
        }
    }
    if let Some(url) = image_url(result) {
        if let Ok(resp) = reqwest::get(url.as_str()).await {
            if let Ok(data) = resp.bytes().await {
                let _ = root::insert("redis/images", image_name, Dynamic::Bytes(data.to_vec()));
                return Some(format!("/images/{}", image_name));
            }
        }
        return Some(url.as_str().to_string());
    }
    None
}

extern "C" fn llm_image(openai: *const Dynamic, value: *const Dynamic, notifier: *const Dynamic) -> *const Dynamic {
    //启动一个任务 使用 消息点来接收 中间消息
    let openai = unsafe { (&*openai).clone() };
    let value = unsafe { (&*value).clone() };
    let notifier = unsafe { (&*notifier).clone() };
    let id = start_llm_task(value.clone(), || async move {
        let r = llm::image(openai, value, Some(notifier.clone())).await?;
        if let (Some(world_id), Some(image_id)) = (notifier.get_dynamic("world_id"), notifier.get_dynamic("image_id")) {
            // 从外部 URL 下载图片，存入 redis/images 提供长期访问
            let image_name = format!("world-{}-{}", world_id.as_str(), image_id.as_str());
            let local_url = store_generated_image(&r, &image_name).await.unwrap_or_default();
            // 图片元信息存入 redis/worlds/{id}/images/{image_id}
            let image_key = format!("redis/worlds/{}/images/{}", world_id.as_str(), image_id.as_str());
            let image_info = dynamic::map!();
            image_info.insert("id", image_id.clone());
            image_info.insert("kind", "world_intro");
            image_info.insert("status", "ready");
            if !local_url.is_empty() {
                image_info.insert("url", local_url.clone());
            }
            if let Some(prompt) = notifier.get_dynamic("prompt") {
                image_info.insert("prompt", prompt.clone());
            }
            let _ = root::add_value(&image_key, image_info.clone());
            // 通知客户端刷新
            let ws_msg = dynamic::map!("type" => "world_image_ready", "world_id" => world_id.clone(), "image_id" => image_id.clone(), "image" => image_info);
            let _ = llm::notify(&notifier, ws_msg);
        } else {
            let _ = llm::notify(&notifier, r.clone());
        }
        Ok(r)
    });
    alloc_dynamic(id.into())
}

pub const LLM_NATIVE: [(&str, &[Type], Type, *const u8); 5] = [
    ("complete", &[Type::Any, Type::Any], Type::Any, llm_complete as *const u8),
    ("image", &[Type::Any, Type::Any, Type::Any], Type::Any, llm_image as *const u8),
    ("audio", &[Type::Any, Type::Any], Type::Any, llm_audio as *const u8),
    ("tts", &[Type::Any, Type::Any], Type::Any, llm_tts as *const u8),
    ("deep", &[Type::Any, Type::Any, Type::Any], Type::Any, llm_deep as *const u8),
];