add Assistant example

Author: ifsheldon

async-openai-wasm/src/client.rs

@@ -588,7 +588,6 @@ impl<O> Stream for OpenAIEventMappedStream<O>
 {
     type Item = Result<O, OpenAIError>;
 
-    // TODO: test this
     fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         let this = self.project();
         if *this.done {

examples/openai-web-app-assistant/.gitignore

@@ -0,0 +1 @@
+/dist

examples/openai-web-app-assistant/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "openai-web-assistant-chat"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+dioxus = {version = "~0.5", features = ["web"]}
+futures = "0.3.30"
+async-openai-wasm = { path = "../../async-openai-wasm" }
+# Debug
+tracing = "0.1.40"
+dioxus-logger = "~0.5"
+serde_json = "1.0.117"

examples/openai-web-app-assistant/Dioxus.toml

@@ -0,0 +1,40 @@
+[application]
+
+# App (Project) Name
+name = "openai-web-app-assistant-dioxus"
+
+# Dioxus App Default Platform
+# desktop, web
+default_platform = "web"
+
+# `build` & `serve` dist path
+out_dir = "dist"
+
+[web.app]
+
+# HTML title tag content
+title = "openai-web-app-assistant-dioxus"
+
+[web.watcher]
+
+# when watcher trigger, regenerate the `index.html`
+reload_html = true
+
+# which files or dirs will be watcher monitoring
+watch_path = ["src"]
+
+# include `assets` in web platform
+[web.resource]
+
+# CSS style file
+
+style = []
+
+# Javascript code file
+script = []
+
+[web.resource.dev]
+
+# Javascript code file
+# serve: [dev-server] only
+script = []

examples/openai-web-app-assistant/README.md

@@ -0,0 +1,14 @@
+# OpenAI Web App - Assistant
+
+This builds a `dioxus` web App that uses OpenAI Assistant APIs to generate text.
+
+To run it, you need:
+1. Set OpenAI secrets in `./src/main.rs`. Please do NOT take this demo into production without using a secure secret store
+2. Install `dioxus-cli` by `cargo install dioxus-cli`.
+3. Run `dx serve`
+
+Note: Safari may not work due to CORS issues. Please use Chrome or Edge.
+
+## Reference
+
+The code is adapted from [assistant-func-call-stream example in async-openai](https://github.com/64bit/async-openai/tree/main/examples/assistants-func-call-stream).

examples/openai-web-app-assistant/src/main.rs

@@ -0,0 +1,98 @@
+#![allow(non_snake_case)]
+
+use dioxus::prelude::*;
+use dioxus_logger::tracing::{error, info, Level};
+use futures::stream::StreamExt;
+
+use async_openai_wasm::types::{AssistantStreamEvent, CreateMessageRequest, CreateRunRequest, CreateThreadRequest, MessageRole};
+
+use crate::utils::*;
+
+mod utils;
+
+pub const API_BASE: &str = "...";
+pub const API_KEY: &str = "...";
+
+
+pub fn App() -> Element {
+    const QUERY: &str = "What's the weather in San Francisco today and the likelihood it'll rain?";
+    let reply = use_signal(String::new);
+    let _run_assistant: Coroutine<()> = use_coroutine(|_rx| {
+        let client = get_client();
+        async move {
+            //
+            // Step 1: Define functions
+            //
+            let assistant = client
+                .assistants()
+                .create(create_assistant_request())
+                .await
+                .expect("failed to create assistant");
+            //
+            // Step 2: Create a Thread and add Messages
+            //
+            let thread = client
+                .threads()
+                .create(CreateThreadRequest::default())
+                .await
+                .expect("failed to create thread");
+            let _message = client
+                .threads()
+                .messages(&thread.id)
+                .create(CreateMessageRequest {
+                    role: MessageRole::User,
+                    content: QUERY.into(),
+                    ..Default::default()
+                })
+                .await
+                .expect("failed to create message");
+            //
+            // Step 3: Initiate a Run
+            //
+            let mut event_stream = client
+                .threads()
+                .runs(&thread.id)
+                .create_stream(CreateRunRequest {
+                    assistant_id: assistant.id.clone(),
+                    stream: Some(true),
+                    ..Default::default()
+                })
+                .await
+                .expect("failed to create run");
+
+
+            while let Some(event) = event_stream.next().await {
+                match event {
+                    Ok(event) => match event {
+                        AssistantStreamEvent::ThreadRunRequiresAction(run_object) => {
+                            info!("thread.run.requires_action: run_id:{}", run_object.id);
+                            handle_requires_action(&client, run_object, reply.to_owned()).await
+                        }
+                        _ => info!("\nEvent: {event:?}\n"),
+                    },
+                    Err(e) => {
+                        error!("Error: {e}");
+                    }
+                }
+            }
+
+            client.threads().delete(&thread.id).await.expect("failed to delete thread");
+            client.assistants().delete(&assistant.id).await.expect("failed to delete assistant");
+            info!("Done!");
+        }
+    });
+
+    rsx! {
+        div {
+            p { "Using OpenAI" }
+            p { "User: {QUERY}" }
+            p { "Expected Stats (Debug): temperature = {TEMPERATURE}, rain_probability = {RAIN_PROBABILITY}" }
+            p { "Assistant: {reply}" }
+        }
+    }
+}
+
+fn main() {
+    dioxus_logger::init(Level::INFO).expect("failed to init logger");
+    launch(App);
+}

examples/openai-web-app-assistant/src/utils.rs

@@ -0,0 +1,148 @@
+use std::error::Error;
+use dioxus::prelude::Signal;
+use futures::StreamExt;
+use tracing::{error, info};
+use async_openai_wasm::Client;
+use async_openai_wasm::config::OpenAIConfig;
+use async_openai_wasm::types::{AssistantStreamEvent, CreateAssistantRequest, CreateAssistantRequestArgs, FunctionObject, MessageDeltaContent, RunObject, SubmitToolOutputsRunRequest, ToolsOutputs};
+use crate::{API_BASE, API_KEY};
+use dioxus::prelude::*;
+
+
+pub const TEMPERATURE: &str = "57";
+pub const RAIN_PROBABILITY: &str = "0.06";
+
+pub fn get_client() -> Client<OpenAIConfig> {
+    let config = OpenAIConfig::new()
+        .with_api_key(API_KEY);
+    let config = if API_BASE != "..." {
+        config.with_api_base(API_BASE)
+    } else {
+        config
+    };
+
+    Client::with_config(config)
+}
+
+pub async fn handle_requires_action(client: &Client<OpenAIConfig>, run_object: RunObject, reply_signal: Signal<String>) {
+    let mut tool_outputs: Vec<ToolsOutputs> = vec![];
+    if let Some(ref required_action) = run_object.required_action {
+        for tool in &required_action.submit_tool_outputs.tool_calls {
+            if tool.function.name == "get_current_temperature" {
+                info!("get_current_temperature");
+                tool_outputs.push(ToolsOutputs {
+                    tool_call_id: Some(tool.id.clone()),
+                    output: Some(TEMPERATURE.into()),
+                })
+            } else if tool.function.name == "get_rain_probability" {
+                info!("get_rain_probability");
+                tool_outputs.push(ToolsOutputs {
+                    tool_call_id: Some(tool.id.clone()),
+                    output: Some(RAIN_PROBABILITY.into()),
+                })
+            } else {
+                error!("Unknown tool: {}", tool.function.name);
+                unreachable!();
+            }
+        }
+
+        if let Err(e) = submit_tool_outputs(client, run_object, tool_outputs, reply_signal).await {
+            error!("Error on submitting tool outputs: {e}");
+        }
+    }
+}
+
+pub async fn submit_tool_outputs(
+    client: &Client<OpenAIConfig>,
+    run_object: RunObject,
+    tool_outputs: Vec<ToolsOutputs>,
+    mut reply_signal: Signal<String>,
+) -> Result<(), Box<dyn Error>> {
+    let mut event_stream = client
+        .threads()
+        .runs(&run_object.thread_id)
+        .submit_tool_outputs_stream(
+            &run_object.id,
+            SubmitToolOutputsRunRequest {
+                tool_outputs,
+                stream: Some(true),
+            },
+        )
+        .await?;
+
+    while let Some(event) = event_stream.next().await {
+        match event {
+            Ok(event) => {
+                if let AssistantStreamEvent::ThreadMessageDelta(delta) = event {
+                    if let Some(contents) = delta.delta.content {
+                        for content in contents {
+                            // only text is expected here and no images
+                            if let MessageDeltaContent::Text(text) = content {
+                                if let Some(text) = text.text {
+                                    if let Some(text) = text.value {
+                                        info!("After submitted tool results: {}", text);
+                                        reply_signal.with_mut(|reply| {
+                                            reply.push_str(&text);
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            Err(e) => {
+                error!("Error: {e}");
+            }
+        }
+    }
+
+    Ok(())
+}
+
+pub fn create_assistant_request() -> CreateAssistantRequest {
+    CreateAssistantRequestArgs::default()
+        .instructions("You are a weather bot. Use the provided functions to answer questions.")
+        .model("gpt-4o")
+        .tools(vec![
+            FunctionObject {
+                name: "get_current_temperature".into(),
+                description: Some("Get the current temperature for a specific location".into()),
+                parameters: Some(serde_json::json!(
+                {
+                    "type": "object",
+                    "properties": {
+                    "location": {
+                        "type": "string",
+                        "description": "The city and state, e.g., San Francisco, CA"
+                    },
+                    "unit": {
+                        "type": "string",
+                        "enum": ["Celsius", "Fahrenheit"],
+                        "description": "The temperature unit to use. Infer this from the user's location."
+                    }
+                    },
+                    "required": ["location", "unit"]
+                }
+            )),
+            }.into(),
+            FunctionObject {
+                name: "get_rain_probability".into(),
+                description: Some("Get the probability of rain for a specific location".into()),
+                parameters: Some(serde_json::json!(
+                {
+                    "type": "object",
+                    "properties": {
+                    "location": {
+                        "type": "string",
+                        "description": "The city and state, e.g., San Francisco, CA"
+                    }
+                    },
+                    "required": ["location"]
+                }
+            )),
+            }.into(),
+        ])
+        .build()
+        .expect("failed to build CreateAssistantRequestArgs")
+}