Update markdown files to be compatible with latest Hugo (#287)

Signed-off-by: Marc Duiker <marcduiker@users.noreply.github.com>

.github/workflows/ci.yml

@@ -1,6 +1,8 @@
 name: dapr-rust-sdk
 
 on:
+  schedule:
+    - cron: '8 8 * * *'
   push:
     branches:
       - main
@@ -14,13 +16,12 @@ on:
 
 env:
   CARGO_TERM_COLOR: always
-  CARGO_TOKEN: ${{ secrets.CRATES_IO_TOKEN }}
   PROTOC_VERSION: 24.4
   RUSTFLAGS: "-D warnings"
 
 jobs:
   lint:
-    name: Lint
+    name: Check and Lint
     runs-on: ubuntu-latest
 
     steps:
@@ -35,14 +36,20 @@ jobs:
         repo-token: ${{ secrets.GITHUB_TOKEN }}
         version: ${{ env.PROTOC_VERSION }}
     - uses: actions/checkout@v4
+
+    - name: Check compiled protos for a diff
+      run: |
+        make proto-gen check-diff-proto
+
     - name: cargo fmt
       run: cargo fmt -- --check --color ${{ env.CARGO_TERM_COLOR }}
+
     - name: cargo clippy
       run: cargo clippy
 
 
   build:
-    name: Build on rust-${{ matrix.rust-version}}
+    name: Test and Build on rust-${{ matrix.rust-version }}
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false
@@ -69,33 +76,60 @@ jobs:
     - name: Run Tests
       run: cargo test --workspace --all-targets --all-features
 
-  test-docs-sdk:
-    name: Docs SDK
+  test-docs:
+    name: Check Docs - ${{ matrix.crate }}
     runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        crate:
+          - dapr
+          - dapr-macros
     env:
       RUSTDOCFLAGS: -Dwarnings
     steps:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@nightly
       - uses: dtolnay/install@cargo-docs-rs
-      - run: cargo docs-rs -p dapr
+      - run: cargo docs-rs -p ${{ matrix.crate }}
 
-  test-docs-macros:
-    name: Docs Macros
+  publish-dry:
+    name: Publish Test
     runs-on: ubuntu-latest
-    env:
-      RUSTDOCFLAGS: -Dwarnings
+    strategy:
+      fail-fast: false
+      matrix:
+        crate:
+          - dapr
+          - dapr-macros
+
     steps:
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: stable
+          components: clippy, rustfmt
+      - name: Install Protoc
+        uses: arduino/setup-protoc@v3
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          version: ${{ env.PROTOC_VERSION }}
       - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@nightly
-      - uses: dtolnay/install@cargo-docs-rs
-      - run: cargo docs-rs -p dapr-macros
+      - name: cargo publish - ${{ matrix.crate }}
+        run: cargo publish --manifest-path ${{ matrix.crate }}/Cargo.toml --dry-run
+
 
   publish:
     name: Publish
     runs-on: ubuntu-latest
-    needs: [test-docs-sdk, test-docs-macros, lint, build]
+    needs: [test-docs, lint, build, publish-dry]
     if: startswith(github.ref, 'refs/tags/v')
+    strategy:
+      fail-fast: false
+      matrix:
+        crate:
+          - dapr
+          - dapr-macros
 
     steps:
     - name: Install Rust
@@ -109,7 +143,7 @@ jobs:
         repo-token: ${{ secrets.GITHUB_TOKEN }}
         version: ${{ env.PROTOC_VERSION }}
     - uses: actions/checkout@v4
-    - name: cargo publish dapr-macros
-      run: cargo publish --manifest-path dapr-macros/Cargo.toml --token ${{ env.CARGO_TOKEN }}
-    - name: cargo publish dapr
-      run: cargo publish --token ${{ env.CARGO_TOKEN }}
+    - name: cargo publish - ${{ matrix.crate }}
+      env:
+          CARGO_TOKEN: ${{ secrets.CARGO_TOKEN }}
+      run: cargo publish --manifest-path ${{ matrix.crate }}/Cargo.toml --token ${{ env.CARGO_TOKEN }}

.github/workflows/dapr-bot/Cargo.toml

@@ -11,6 +11,6 @@ rust-version = "1.70.0"
 
 [dependencies]
 exitcode = "1.1.2"
-octocrab = "0.34.1"
+octocrab = "0.42.1"
 serde_json = "1.0.114"
 tokio = { version = "1.36.0", features = ["full"] }

.github/workflows/validate-examples.yml

@@ -1,6 +1,8 @@
 name: validate-examples
 
 on:
+  schedule:
+    - cron: '8 8 * * *'
   push:
     branches:
       - main
@@ -74,14 +76,14 @@ jobs:
       - name: Determine latest Dapr Runtime version
         if: env.DAPR_RUNTIME_VERSION == ''
         run: |
-          RUNTIME_VERSION=$(curl -s "https://api.github.com/repos/dapr/dapr/releases/latest" | grep '"tag_name"' | cut -d ':' -f2 | tr -d '",v')
+          RUNTIME_VERSION=$(curl -s "https://api.github.com/repos/dapr/dapr/releases/latest" | grep '"tag_name"' | cut -d ':' -f2 | tr -d ' ",v')
           echo "DAPR_RUNTIME_VERSION=$RUNTIME_VERSION" >> $GITHUB_ENV
           echo "Found $RUNTIME_VERSION"
 
       - name: Determine latest Dapr Cli version
         if: env.DAPR_CLI_VERSION == ''
         run: |
-          CLI_VERSION=$(curl -s "https://api.github.com/repos/dapr/cli/releases/latest" | grep '"tag_name"' | cut -d ':' -f2 | tr -d '",v')
+          CLI_VERSION=$(curl -s "https://api.github.com/repos/dapr/cli/releases/latest" | grep '"tag_name"' | cut -d ':' -f2 | tr -d ' ",v')
           echo "DAPR_CLI_VERSION=$CLI_VERSION" >> $GITHUB_ENV
           echo "Found $CLI_VERSION"
 
@@ -125,6 +127,7 @@ jobs:
           cd dapr_runtime
           make
           echo "artifactPath=~/artifacts/$GITHUB_SHA/" >> $GITHUB_ENV
+          mkdir -p $HOME/artifacts/$GITHUB_SHA/
           RUNTIME_VERSION=edge
           echo "DAPR_RUNTIME_VERSION=$RUNTIME_VERSION" >> $GITHUB_ENV
 
@@ -133,7 +136,7 @@ jobs:
         run: |
           mkdir ~/dapr_docker
           cd dapr_runtime
-          docker build --build-arg "PKG_FILES=*" -f ./docker/Dockerfile ./dist/linux_amd64/release -t daprio/dapr:0.0.0-dev
+          docker build --build-arg "PKG_FILES=*" -f ./docker/Dockerfile ./dist/linux_amd64/release -t daprio/dapr:9.0.0-dev
 
       - name: Download Install Bundle CLI
         if: env.DAPR_REF != '' && env.DAPR_CLI_REF == ''
@@ -145,14 +148,14 @@ jobs:
           ls -la
 
       - name: Build Custom Install Bundle
-        if: env.DAPR_REF != '' && env.DAPR_CLI_REF != ''
+        if: env.DAPR_REF != '' || env.DAPR_CLI_REF != ''
         run: |
           : # Create daprbundle directory
           mkdir ~/daprbundle
           cp .github/workflows/validate-examples/details.json ~/daprbundle/
 
           : # Add cli
-          cp ~/artifacts/$GITHUB_SHA/dapr ~/daprbundle/dapr
+          cp cli/dist/linux_amd64/release/dapr ~/daprbundle/dapr
 
           : # Compress executables to /dist/ appending _linux_amd64 to the name
           mkdir ~/daprbundle/dist
@@ -167,7 +170,7 @@ jobs:
 
           : # Add docker image
           mkdir ~/daprbundle/docker
-          docker save daprio/dapr:0.0.0-dev | gzip > ~/daprbundle/docker/daprio-dapr-0.0.0-dev.tar.gz
+          docker save daprio/dapr:9.0.0-dev | gzip > ~/daprbundle/docker/daprio-dapr-9.0.0-dev.tar.gz
 
           : # Bundle
           cd ~/daprbundle
@@ -217,7 +220,7 @@ jobs:
       fail-fast: false
       matrix:
         examples:
-          [ "actors", "bindings", "client", "configuration", "crypto", "invoke/grpc", "invoke/grpc-proxying", "jobs", "pubsub", "query_state", "secrets-bulk" ]
+          [ "actors", "bindings", "client", "configuration", "conversation", "crypto", "invoke/grpc", "invoke/grpc-proxying", "jobs", "pubsub", "query_state", "secrets-bulk" ]
     steps:
       - name: Check out code
         uses: actions/checkout@v4

.github/workflows/validate-examples/details.json

@@ -1,9 +1,9 @@
 {
-    "daprd": "0.0.0-dev",
-    "dashboard": "0.0.0-dev",
-    "cli": "0.0.0-dev",
+    "daprd": "9.0.0-dev",
+    "dashboard": "9.0.0-dev",
+    "cli": "9.0.0-dev",
     "daprBinarySubDir": "dist",
     "dockerImageSubDir": "docker",
-    "daprImageName": "daprio/dapr:0.0.0-dev",
-    "daprImageFileName": "daprio-dapr-0.0.0-dev.tar.gz"
+    "daprImageName": "daprio/dapr:9.0.0-dev",
+    "daprImageFileName": "daprio-dapr-9.0.0-dev.tar.gz"
   }

Cargo.toml

@@ -12,27 +12,21 @@ resolver = "2"
 
 [workspace.dependencies]
 async-trait = "0.1"
-
-dapr = { version = "0.16.0-rc.0", path = "./dapr" }
-dapr-macros = { version = "0.16.0-rc.0", path = "./dapr-macros" }
-
-prost = "0.13.1"
-prost-build = "0.13.1"
-prost-types = "0.13.1"
+prost = "0.13.4"
+prost-types = "0.13.4"
 
 serde = "1.0"
 serde_json = "1.0"
 
 tokio = "1.39"
 tokio-stream = "0.1"
-tokio-test = "0.4"
 tokio-util = "0.7"
 
-tonic = "0.12.1"
-tonic-build = "0.12.1"
+tonic = "0.12.3"
+tonic-build = "0.12.3"
 
 [workspace.package]
-version = "0.16.0-rc.0"
+version = "0.16.0"
 authors = [
     "Mike Nguyen <hey@mike.ee>",
     "The Dapr Authors <dapr@dapr.io>"

Makefile

@@ -0,0 +1,7 @@
+.PHONY: proto-gen
+proto-gen:
+	cargo run --bin proto-gen
+
+.PHONY: check-diff-proto
+check-diff-proto:
+	git diff --exit-code ./proto/

README.md

@@ -45,7 +45,7 @@ resiliency.
 
 Ensure you have Rust version 1.78 or higher installed. If not, install Rust [here](https://www.rust-lang.org/tools/install).
 
-You will also need to install [protoc](https://github.com/protocolbuffers/protobuf#protobuf-compiler-installation).
+These crates no longer require protoc unless to recompile the protobuf files.
 
 ## How to use
 
@@ -53,7 +53,7 @@ Add the following to your `Cargo.toml` file:
 
 ```toml
 [dependencies]
-dapr = "0.16.0-rc.0"
+dapr = "0.16.0"
 ```
 
 Here's a basic example to create a client:
@@ -74,7 +74,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
 ## Explore more examples
 
-Browse through more examples to understand the SDK better: [View examples](./examples)
+Browse through more examples to understand the SDK better: [View examples](https://github.com/dapr/rust-sdk/tree/main/examples)
 
 ## Building
 
@@ -84,8 +84,6 @@ To build the SDK run:
 cargo build
 ```
 
->Note: The protobuf client generation is built into `cargo build` process so updating the proto files under `dapr/` is enough to update the protobuf client.
-
 ## Developing (Updating .proto files from upstream Dapr)
 
 To fetch the latest .proto files from Dapr execute the script `update-protos.sh`:
@@ -100,6 +98,8 @@ By default, the script fetches the latest proto updates from the master branch o
 ./update-protos.sh -v v1.14.0
 ```
 
+You will also need to install [protoc](https://github.com/protocolbuffers/protobuf#protobuf-compiler-installation).
+
 Protos can then be compiled using:
 
 ```bash

dapr-macros/Cargo.toml

@@ -12,9 +12,6 @@ rust-version.workspace = true
 proc-macro = true
 
 [dependencies]
-async-trait = { workspace = true }
-axum = "0.7"
-log = "0.4"
 proc-macro2 = "1.0"
 quote = "1.0"
 syn = { version = "2.0", features = ["full"] }

dapr-macros/src/lib.rs

@@ -81,7 +81,7 @@ pub fn actor(_attr: TokenStream, item: TokenStream) -> TokenStream {
         Ok(actor_struct) => actor_struct.ident.clone(),
         Err(_) => match syn::parse::<syn::ItemType>(item.clone()) {
             Ok(ty) => ty.ident.clone(),
-            Err(e) => panic!("Error parsing actor struct: {}", e),
+            Err(e) => panic!("Error parsing actor struct: {e}"),
         },
     };
 

dapr/Cargo.toml

@@ -6,16 +6,14 @@ edition.workspace = true
 license.workspace = true
 repository.workspace = true
 description = "Rust SDK for dapr"
-readme = "../README.md"
+readme = "README.md"
 keywords = ["microservices", "dapr"]
 rust-version.workspace = true
 
 [dependencies]
 async-trait = { workspace = true }
 axum = "0.7"
-bytes = "1.7"
 chrono = "0.4"
-dapr-macros = { workspace = true }
 futures = "0.3"
 log = "0.4"
 prost = { workspace = true }
@@ -28,10 +26,15 @@ tokio-util = { workspace = true, features = ["io"] }
 
 
 [dev-dependencies]
-axum-test = "15.3"
+axum-test = "=16.4.0" # TODO: Remove problematic dep
+litemap = "=0.7.4" # TODO: Remove pinned - linked to axum_test
+zerofrom = "=0.1.5" # TODO: Remove pinned - linked to axum_test
+reserve-port = "=2.1.0" # TODO: Remove pinned - linked to axum_test
+idna_adapter = "=1.2.0"
+
 once_cell = "1.19"
+dapr = { path = "./" }
+dapr-macros = { path = "../dapr-macros" }
 tokio = { workspace = true, features = ["full"] }
 uuid = { version = "1.10", features = ["v4"] }
-dapr = { workspace = true }
-tokio-test = { workspace = true }
 tokio-stream = { workspace = true }

dapr/README.md

@@ -0,0 +1 @@
+../README.md

dapr/src/appcallback.rs

@@ -1,37 +1,36 @@
-use crate::dapr;
 use crate::dapr::proto::runtime::v1::app_callback_server::AppCallback;
 use crate::dapr::proto::{common, runtime};
 use std::collections::HashMap;
 use tonic::{Code, Request, Response, Status};
 
 /// InvokeRequest is the message to invoke a method with the data.
-pub type InvokeRequest = dapr::proto::common::v1::InvokeRequest;
+pub type InvokeRequest = common::v1::InvokeRequest;
 
 /// InvokeResponse is the response message inclduing data and its content type
 /// from app callback.
-pub type InvokeResponse = dapr::proto::common::v1::InvokeResponse;
+pub type InvokeResponse = common::v1::InvokeResponse;
 
 /// ListTopicSubscriptionsResponse is the message including the list of the subscribing topics.
-pub type ListTopicSubscriptionsResponse = dapr::proto::runtime::v1::ListTopicSubscriptionsResponse;
+pub type ListTopicSubscriptionsResponse = runtime::v1::ListTopicSubscriptionsResponse;
 
 /// TopicSubscription represents a topic and it's metadata (session id etc.)
-pub type TopicSubscription = dapr::proto::runtime::v1::TopicSubscription;
+pub type TopicSubscription = runtime::v1::TopicSubscription;
 
 /// TopicEventRequest message is compatiable with CloudEvent spec v1.0.
-pub type TopicEventRequest = dapr::proto::runtime::v1::TopicEventRequest;
+pub type TopicEventRequest = runtime::v1::TopicEventRequest;
 
 /// TopicEventResponse is response from app on published message
-pub type TopicEventResponse = dapr::proto::runtime::v1::TopicEventResponse;
+pub type TopicEventResponse = runtime::v1::TopicEventResponse;
 
 /// ListInputBindingsResponse is the message including the list of input bindings.
-pub type ListInputBindingsResponse = dapr::proto::runtime::v1::ListInputBindingsResponse;
+pub type ListInputBindingsResponse = runtime::v1::ListInputBindingsResponse;
 
 /// BindingEventRequest represents input bindings event.
-pub type BindingEventRequest = dapr::proto::runtime::v1::BindingEventRequest;
+pub type BindingEventRequest = runtime::v1::BindingEventRequest;
 
 /// BindingEventResponse includes operations to save state or
 /// send data to output bindings optionally.
-pub type BindingEventResponse = dapr::proto::runtime::v1::BindingEventResponse;
+pub type BindingEventResponse = runtime::v1::BindingEventResponse;
 
 impl ListTopicSubscriptionsResponse {
     /// Create `ListTopicSubscriptionsResponse` with a topic.

dapr/src/client.rs

@@ -25,7 +25,27 @@ impl<T: DaprInterface> Client<T> {
     pub async fn connect(addr: String) -> Result<Self, Error> {
         // Get the Dapr port to create a connection
         let port: u16 = std::env::var("DAPR_GRPC_PORT")?.parse()?;
-        let address = format!("{}:{}", addr, port);
+        let address = format!("{addr}:{port}");
+
+        Ok(Client(T::connect(address).await?))
+    }
+
+    /// Connect to the Dapr sidecar with a specific port.
+    ///
+    /// # Arguments
+    ///
+    /// * `addr` - Address of gRPC server to connect to.
+    /// * `port` - Port of the gRPC server to connect to.
+    pub async fn connect_with_port(addr: String, port: String) -> Result<Self, Error> {
+        // assert that port is between 1 and 65535
+        let port: u16 = match port.parse::<u16>() {
+            Ok(p) => p,
+            Err(_) => {
+                panic!("Port must be a number between 1 and 65535");
+            }
+        };
+
+        let address = format!("{addr}:{port}");
 
         Ok(Client(T::connect(address).await?))
     }
@@ -172,6 +192,7 @@ impl<T: DaprInterface> Client<T> {
     ///
     /// * `store_name` - The name of state store.
     /// * `key` - The key of the desired state.
+    /// * `metadata` - Any metadata pairs to include in the request.
     pub async fn get_state<S>(
         &mut self,
         store_name: S,
@@ -198,19 +219,54 @@ impl<T: DaprInterface> Client<T> {
 
     /// Save an array of state objects.
     ///
+    /// This does not include any etag or metadata options.
+    ///
     /// # Arguments
     ///
     /// * `store_name` - The name of state store.
-    /// * `states` - The array of the state key values.
-    pub async fn save_state<I, K>(&mut self, store_name: K, states: I) -> Result<(), Error>
+    /// * `key` - The key for the value
+    /// * `value` - The value to be saved for the key
+    /// * `etag` - The etag identifier
+    /// * `metadata` - Any metadata pairs to include in the request.
+    /// * `options` - Any state option
+    pub async fn save_state<S>(
+        &mut self,
+        store_name: S,
+        key: S,
+        value: Vec<u8>,
+        etag: Option<Etag>,
+        metadata: Option<HashMap<String, String>>,
+        options: Option<StateOptions>,
+    ) -> Result<(), Error>
     where
-        I: IntoIterator<Item = (K, Vec<u8>)>,
-        K: Into<String>,
+        S: Into<String>,
+    {
+        let states = vec![StateItem {
+            key: key.into(),
+            value,
+            etag,
+            metadata: metadata.unwrap_or_default(),
+            options,
+        }];
+
+        self.save_bulk_states(store_name, states).await
+    }
+
+    /// Save an array of state objects.
+    ///
+    /// # Arguments
+    ///
+    /// * `store_name` - The name of state store.
+    /// * `items` - The array of the state items.
+    pub async fn save_bulk_states<S, I>(&mut self, store_name: S, items: I) -> Result<(), Error>
+    where
+        S: Into<String>,
+        I: Into<Vec<StateItem>>,
     {
         self.0
             .save_state(SaveStateRequest {
                 store_name: store_name.into(),
-                states: states.into_iter().map(|pair| pair.into()).collect(),
+                states: items.into(),
             })
             .await
     }
@@ -533,6 +589,18 @@ impl<T: DaprInterface> Client<T> {
         };
         self.0.delete_job_alpha1(request).await
     }
+
+    /// Converse with an LLM
+    ///
+    /// # Arguments
+    ///
+    /// * ConversationRequest - The request containing inputs to send to the LLM
+    pub async fn converse_alpha1(
+        &mut self,
+        request: ConversationRequest,
+    ) -> Result<ConversationResponse, Error> {
+        self.0.converse_alpha1(request).await
+    }
 }
 
 #[async_trait]
@@ -595,6 +663,11 @@ pub trait DaprInterface: Sized {
         &mut self,
         request: DeleteJobRequest,
     ) -> Result<DeleteJobResponse, Error>;
+
+    async fn converse_alpha1(
+        &mut self,
+        request: ConversationRequest,
+    ) -> Result<ConversationResponse, Error>;
 }
 
 #[async_trait]
@@ -603,6 +676,13 @@ impl DaprInterface for dapr_v1::dapr_client::DaprClient<TonicChannel> {
         Ok(dapr_v1::dapr_client::DaprClient::connect(addr).await?)
     }
 
+    async fn publish_event(&mut self, request: PublishEventRequest) -> Result<(), Error> {
+        self.publish_event(Request::new(request))
+            .await?
+            .into_inner();
+        Ok(())
+    }
+
     async fn invoke_service(
         &mut self,
         request: InvokeServiceRequest,
@@ -623,13 +703,6 @@ impl DaprInterface for dapr_v1::dapr_client::DaprClient<TonicChannel> {
             .into_inner())
     }
 
-    async fn publish_event(&mut self, request: PublishEventRequest) -> Result<(), Error> {
-        self.publish_event(Request::new(request))
-            .await?
-            .into_inner();
-        Ok(())
-    }
-
     async fn get_secret(&mut self, request: GetSecretRequest) -> Result<GetSecretResponse, Error> {
         Ok(self.get_secret(Request::new(request)).await?.into_inner())
     }
@@ -648,6 +721,11 @@ impl DaprInterface for dapr_v1::dapr_client::DaprClient<TonicChannel> {
         Ok(self.get_state(Request::new(request)).await?.into_inner())
     }
 
+    async fn save_state(&mut self, request: SaveStateRequest) -> Result<(), Error> {
+        self.save_state(Request::new(request)).await?.into_inner();
+        Ok(())
+    }
+
     async fn query_state_alpha1(
         &mut self,
         request: QueryStateRequest,
@@ -658,11 +736,6 @@ impl DaprInterface for dapr_v1::dapr_client::DaprClient<TonicChannel> {
             .into_inner())
     }
 
-    async fn save_state(&mut self, request: SaveStateRequest) -> Result<(), Error> {
-        self.save_state(Request::new(request)).await?.into_inner();
-        Ok(())
-    }
-
     async fn delete_state(&mut self, request: DeleteStateRequest) -> Result<(), Error> {
         self.delete_state(Request::new(request)).await?.into_inner();
         Ok(())
@@ -789,6 +862,16 @@ impl DaprInterface for dapr_v1::dapr_client::DaprClient<TonicChannel> {
             .await?
             .into_inner())
     }
+
+    async fn converse_alpha1(
+        &mut self,
+        request: ConversationRequest,
+    ) -> Result<ConversationResponse, Error> {
+        Ok(self
+            .converse_alpha1(Request::new(request))
+            .await?
+            .into_inner())
+    }
 }
 
 /// A request from invoking a service
@@ -815,6 +898,15 @@ pub type GetStateResponse = dapr_v1::GetStateResponse;
 /// A request for saving state
 pub type SaveStateRequest = dapr_v1::SaveStateRequest;
 
+/// A state item
+pub type StateItem = common_v1::StateItem;
+
+/// State options
+pub type StateOptions = common_v1::StateOptions;
+
+/// Etag identifier
+pub type Etag = common_v1::Etag;
+
 /// A request for querying state
 pub type QueryStateRequest = dapr_v1::QueryStateRequest;
 
@@ -907,6 +999,18 @@ pub type DeleteJobRequest = crate::dapr::proto::runtime::v1::DeleteJobRequest;
 /// A response from a delete job request
 pub type DeleteJobResponse = crate::dapr::proto::runtime::v1::DeleteJobResponse;
 
+/// A request to conversate with an LLM
+pub type ConversationRequest = crate::dapr::proto::runtime::v1::ConversationRequest;
+
+/// A response from conversating with an LLM
+pub type ConversationResponse = crate::dapr::proto::runtime::v1::ConversationResponse;
+
+/// A result from an interacting with a LLM
+pub type ConversationResult = crate::dapr::proto::runtime::v1::ConversationResult;
+
+/// An input to the conversation
+pub type ConversationInput = crate::dapr::proto::runtime::v1::ConversationInput;
+
 type StreamPayload = crate::dapr::proto::common::v1::StreamPayload;
 impl<K> From<(K, Vec<u8>)> for common_v1::StateItem
 where
@@ -987,3 +1091,62 @@ impl JobBuilder {
         }
     }
 }
+
+pub struct ConversationInputBuilder {
+    content: String,
+    role: Option<String>,
+    scrub_pii: Option<bool>,
+}
+
+impl ConversationInputBuilder {
+    pub fn new(message: &str) -> Self {
+        ConversationInputBuilder {
+            content: message.to_string(),
+            role: None,
+            scrub_pii: None,
+        }
+    }
+
+    pub fn build(self) -> ConversationInput {
+        ConversationInput {
+            content: self.content,
+            role: self.role,
+            scrub_pii: self.scrub_pii,
+        }
+    }
+}
+
+pub struct ConversationRequestBuilder {
+    name: String,
+    context_id: Option<String>,
+    inputs: Vec<ConversationInput>,
+    parameters: HashMap<String, Any>,
+    metadata: HashMap<String, String>,
+    scrub_pii: Option<bool>,
+    temperature: Option<f64>,
+}
+impl ConversationRequestBuilder {
+    pub fn new(name: &str, inputs: Vec<ConversationInput>) -> Self {
+        ConversationRequestBuilder {
+            name: name.to_string(),
+            context_id: None,
+            inputs,
+            parameters: Default::default(),
+            metadata: Default::default(),
+            scrub_pii: None,
+            temperature: None,
+        }
+    }
+
+    pub fn build(self) -> ConversationRequest {
+        ConversationRequest {
+            name: self.name,
+            context_id: self.context_id,
+            inputs: self.inputs,
+            parameters: self.parameters,
+            metadata: self.metadata,
+            scrub_pii: self.scrub_pii,
+            temperature: self.temperature,
+        }
+    }
+}

dapr/src/dapr/dapr.proto.common.v1.rs

@@ -6,7 +6,6 @@
 /// `POST <http://localhost:3500/v1.0/invoke/<app_id>/method/<method>?query1=value1&query2=value2`>
 ///
 /// Dapr runtime will parse POST as a verb and extract querystring to quersytring map.
-#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct HttpExtension {
     /// Required. HTTP verb.
@@ -21,7 +20,17 @@ pub mod http_extension {
     /// Type of HTTP 1.1 Methods
     /// RFC 7231: <https://tools.ietf.org/html/rfc7231#page-24>
     /// RFC 5789: <https://datatracker.ietf.org/doc/html/rfc5789>
-    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+    #[derive(
+        Clone,
+        Copy,
+        Debug,
+        PartialEq,
+        Eq,
+        Hash,
+        PartialOrd,
+        Ord,
+        ::prost::Enumeration
+    )]
     #[repr(i32)]
     pub enum Verb {
         None = 0,
@@ -42,16 +51,16 @@ pub mod http_extension {
         /// (if the ProtoBuf definition does not change) and safe for programmatic use.
         pub fn as_str_name(&self) -> &'static str {
             match self {
-                Verb::None => "NONE",
-                Verb::Get => "GET",
-                Verb::Head => "HEAD",
-                Verb::Post => "POST",
-                Verb::Put => "PUT",
-                Verb::Delete => "DELETE",
-                Verb::Connect => "CONNECT",
-                Verb::Options => "OPTIONS",
-                Verb::Trace => "TRACE",
-                Verb::Patch => "PATCH",
+                Self::None => "NONE",
+                Self::Get => "GET",
+                Self::Head => "HEAD",
+                Self::Post => "POST",
+                Self::Put => "PUT",
+                Self::Delete => "DELETE",
+                Self::Connect => "CONNECT",
+                Self::Options => "OPTIONS",
+                Self::Trace => "TRACE",
+                Self::Patch => "PATCH",
             }
         }
         /// Creates an enum from field names used in the ProtoBuf definition.
@@ -75,7 +84,6 @@ pub mod http_extension {
 /// InvokeRequest is the message to invoke a method with the data.
 /// This message is used in InvokeService of Dapr gRPC Service and OnInvoke
 /// of AppCallback gRPC service.
-#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct InvokeRequest {
     /// Required. method is a method name which will be invoked by caller.
@@ -102,7 +110,6 @@ pub struct InvokeRequest {
 /// from app callback.
 /// This message is used in InvokeService of Dapr gRPC Service and OnInvoke
 /// of AppCallback gRPC service.
-#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct InvokeResponse {
     /// Required in unary RPCs. The content body of InvokeService response.
@@ -114,7 +121,6 @@ pub struct InvokeResponse {
 }
 /// Chunk of data sent in a streaming request or response.
 /// This is used in requests including InternalInvokeRequestStream.
-#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct StreamPayload {
     /// Data sent in the chunk.
@@ -128,7 +134,6 @@ pub struct StreamPayload {
     pub seq: u64,
 }
 /// StateItem represents state key, value, and additional options to save state.
-#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct StateItem {
     /// Required. The state key
@@ -143,14 +148,15 @@ pub struct StateItem {
     pub etag: ::core::option::Option<Etag>,
     /// The metadata which will be passed to state store component.
     #[prost(map = "string, string", tag = "4")]
-    pub metadata:
-        ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
+    pub metadata: ::std::collections::HashMap<
+        ::prost::alloc::string::String,
+        ::prost::alloc::string::String,
+    >,
     /// Options for concurrency and consistency to save the state.
     #[prost(message, optional, tag = "5")]
     pub options: ::core::option::Option<StateOptions>,
 }
 /// Etag represents a state item version
-#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Etag {
     /// value sets the etag value
@@ -158,7 +164,6 @@ pub struct Etag {
     pub value: ::prost::alloc::string::String,
 }
 /// StateOptions configures concurrency and consistency for state operations
-#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, Copy, PartialEq, ::prost::Message)]
 pub struct StateOptions {
     #[prost(enumeration = "state_options::StateConcurrency", tag = "1")]
@@ -169,7 +174,17 @@ pub struct StateOptions {
 /// Nested message and enum types in `StateOptions`.
 pub mod state_options {
     /// Enum describing the supported concurrency for state.
-    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+    #[derive(
+        Clone,
+        Copy,
+        Debug,
+        PartialEq,
+        Eq,
+        Hash,
+        PartialOrd,
+        Ord,
+        ::prost::Enumeration
+    )]
     #[repr(i32)]
     pub enum StateConcurrency {
         ConcurrencyUnspecified = 0,
@@ -183,9 +198,9 @@ pub mod state_options {
         /// (if the ProtoBuf definition does not change) and safe for programmatic use.
         pub fn as_str_name(&self) -> &'static str {
             match self {
-                StateConcurrency::ConcurrencyUnspecified => "CONCURRENCY_UNSPECIFIED",
-                StateConcurrency::ConcurrencyFirstWrite => "CONCURRENCY_FIRST_WRITE",
-                StateConcurrency::ConcurrencyLastWrite => "CONCURRENCY_LAST_WRITE",
+                Self::ConcurrencyUnspecified => "CONCURRENCY_UNSPECIFIED",
+                Self::ConcurrencyFirstWrite => "CONCURRENCY_FIRST_WRITE",
+                Self::ConcurrencyLastWrite => "CONCURRENCY_LAST_WRITE",
             }
         }
         /// Creates an enum from field names used in the ProtoBuf definition.
@@ -199,7 +214,17 @@ pub mod state_options {
         }
     }
     /// Enum describing the supported consistency for state.
-    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+    #[derive(
+        Clone,
+        Copy,
+        Debug,
+        PartialEq,
+        Eq,
+        Hash,
+        PartialOrd,
+        Ord,
+        ::prost::Enumeration
+    )]
     #[repr(i32)]
     pub enum StateConsistency {
         ConsistencyUnspecified = 0,
@@ -213,9 +238,9 @@ pub mod state_options {
         /// (if the ProtoBuf definition does not change) and safe for programmatic use.
         pub fn as_str_name(&self) -> &'static str {
             match self {
-                StateConsistency::ConsistencyUnspecified => "CONSISTENCY_UNSPECIFIED",
-                StateConsistency::ConsistencyEventual => "CONSISTENCY_EVENTUAL",
-                StateConsistency::ConsistencyStrong => "CONSISTENCY_STRONG",
+                Self::ConsistencyUnspecified => "CONSISTENCY_UNSPECIFIED",
+                Self::ConsistencyEventual => "CONSISTENCY_EVENTUAL",
+                Self::ConsistencyStrong => "CONSISTENCY_STRONG",
             }
         }
         /// Creates an enum from field names used in the ProtoBuf definition.
@@ -230,7 +255,6 @@ pub mod state_options {
     }
 }
 /// ConfigurationItem represents all the configuration with its name(key).
-#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ConfigurationItem {
     /// Required. The value of configuration item.
@@ -241,6 +265,8 @@ pub struct ConfigurationItem {
     pub version: ::prost::alloc::string::String,
     /// the metadata which will be passed to/from configuration store component.
     #[prost(map = "string, string", tag = "3")]
-    pub metadata:
-        ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
+    pub metadata: ::std::collections::HashMap<
+        ::prost::alloc::string::String,
+        ::prost::alloc::string::String,
+    >,
 }

dapr/src/error.rs

@@ -13,7 +13,7 @@ pub enum Error {
 
 impl Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:?}", self)
+        write!(f, "{self:?}")
     }
 }
 
@@ -50,6 +50,6 @@ pub struct GrpcError {
 
 impl Display for GrpcError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:?}", self)
+        write!(f, "{self:?}")
     }
 }

dapr/src/lib.rs

@@ -1,8 +1,5 @@
-#![doc = include_str!("../../README.md")]
+#![doc = include_str!("../README.md")]
 
-extern crate dapr_macros;
-
-pub use dapr_macros::actor;
 pub use serde;
 pub use serde_json;
 
@@ -12,8 +9,10 @@ pub use client::Client;
 pub mod appcallback;
 /// Module containing the 'Client' implementation.
 pub mod client;
+
 /// Module importing the Dapr runtime implementation.
 pub mod dapr {
+    #![allow(clippy::large_enum_variant)]
     pub mod proto {
         pub mod common {
             pub mod v1 {

dapr/src/server/actor/mod.rs

@@ -37,7 +37,7 @@ impl Display for ActorError {
             ActorError::CorruptedState => write!(f, "Actor state corrupted"),
             ActorError::MethodNotFound => write!(f, "Method not found"),
             ActorError::ActorNotFound => write!(f, "Actor not found"),
-            ActorError::MethodError(e) => write!(f, "Method error: {}", e),
+            ActorError::MethodError(e) => write!(f, "Method error: {e}"),
             ActorError::SerializationError() => write!(f, "Serialization error"),
         }
     }

dapr/src/server/actor/runtime/mod.rs

@@ -102,9 +102,9 @@ impl ActorTypeRegistration {
     /// # Arguments:
     /// * `method_name` - The name of the method to be registered. This name will be used by actor clients to invoke the method.
     /// * `handler` - The handler function to be invoked when the method is called.  
-    ///     Can be any valid [Axum handler](https://docs.rs/axum/latest/axum/handler/index.html),
-    ///     use [Axum extractors](https://docs.rs/axum/latest/axum/extract/index.html) to access the incoming request and return an [`impl IntoResponse`](https://docs.rs/axum/latest/axum/response/trait.IntoResponse.html).
-    ///     Use the `DaprJson` extractor to deserialize the request from Json coming from a Dapr sidecar.
+    ///   Can be any valid [Axum handler](https://docs.rs/axum/latest/axum/handler/index.html),
+    ///   use [Axum extractors](https://docs.rs/axum/latest/axum/extract/index.html) to access the incoming request and return an [`impl IntoResponse`](https://docs.rs/axum/latest/axum/response/trait.IntoResponse.html).
+    ///   Use the `DaprJson` extractor to deserialize the request from Json coming from a Dapr sidecar.
     /// # Example:
     /// ```ignore
     /// # use std::sync::Arc;
@@ -174,7 +174,7 @@ impl ActorTypeRegistration {
         T: 'static,
     {
         let actor_type = self.name.clone();
-        let method_path = format!("/actors/{}/:actor_id/method/{}", actor_type, method_name);
+        let method_path = format!("/actors/{actor_type}/:actor_id/method/{method_name}");
 
         let reg_func = move |router: Router, runtime: Arc<ActorRuntime>| {
             router.route(
@@ -224,7 +224,7 @@ impl ActorRuntime {
         let name = registration.name.clone();
         let mut g = self.registered_actors_types.write().await;
         g.insert(name.clone(), registration);
-        log::info!("registered actor {}", name);
+        log::info!("registered actor {name}");
     }
 
     pub async fn configure_method_routes(

dapr/src/server/actor/tests.rs

@@ -1,3 +1,4 @@
+#[cfg(test)]
 use std::{collections::HashMap, sync::Arc};
 
 use async_trait::async_trait;
@@ -96,7 +97,7 @@ async fn test_actor_invoke() {
     let server = TestServer::new(app.into_make_service()).unwrap();
 
     let invoke_resp = server
-        .put(&format!("/actors/MyActor/{}/method/do_stuff", actor_id))
+        .put(&format!("/actors/MyActor/{actor_id}/method/do_stuff"))
         .json(&json!({ "name": "foo" }))
         .await;
     invoke_resp.assert_status_ok();
@@ -117,7 +118,7 @@ async fn test_actor_invoke() {
     );
 
     let invoke_resp2 = server
-        .put(&format!("/actors/MyActor/{}/method/do_stuff", actor_id))
+        .put(&format!("/actors/MyActor/{actor_id}/method/do_stuff"))
         .json(&json!({ "name": "foo" }))
         .await;
     invoke_resp2.assert_status_ok();
@@ -168,19 +169,15 @@ async fn test_actor_deactivate() {
     let actor_id = Uuid::new_v4().to_string();
 
     let invoke_resp = server
-        .put(&format!("/actors/MyActor/{}/method/do_stuff", actor_id))
+        .put(&format!("/actors/MyActor/{actor_id}/method/do_stuff"))
         .json(&json!({ "name": "foo" }))
         .await;
     invoke_resp.assert_status_ok();
 
-    let deactivate_resp1 = server
-        .delete(&format!("/actors/MyActor/{}", actor_id))
-        .await;
+    let deactivate_resp1 = server.delete(&format!("/actors/MyActor/{actor_id}")).await;
     deactivate_resp1.assert_status_ok();
 
-    let deactivate_resp2 = server
-        .delete(&format!("/actors/MyActor/{}", actor_id))
-        .await;
+    let deactivate_resp2 = server.delete(&format!("/actors/MyActor/{actor_id}")).await;
     deactivate_resp2.assert_status_not_found();
 
     assert_eq!(

dapr/src/server/http.rs

@@ -1,5 +1,5 @@
 use axum::{
-    extract::{Path, State},
+    extract::{OriginalUri, Path, State},
     http::StatusCode,
     response::IntoResponse,
     routing::{delete, get, put},
@@ -84,6 +84,12 @@ pub struct DaprHttpServer {
 
 impl DaprHttpServer {
     /// Creates a new instance of the Dapr HTTP server with default options.
+    ///
+    /// # Panics
+    ///
+    /// This function panics if the Dapr Sidecar cannot be reached!
+    /// For a non-panicking version that allows you to handle any errors yourself, see:
+    /// [DaprHttpServer::try_new_with_dapr_port]
     pub async fn new() -> Self {
         let dapr_port: u16 = std::env::var("DAPR_GRPC_PORT")
             .unwrap_or("3501".into())
@@ -92,19 +98,38 @@ impl DaprHttpServer {
         Self::with_dapr_port(dapr_port).await
     }
 
+    /// Creates a new instance of the Dapr HTTP server that connects to the Dapr sidecar on the
+    /// given dapr_port.
+    ///
+    /// # Panics
+    ///
+    /// This function panics if the Dapr Sidecar cannot be reached!
+    /// For a non-panicking version that allows you to handle any errors yourself, see:
+    /// [DaprHttpServer::try_new_with_dapr_port]
     pub async fn with_dapr_port(dapr_port: u16) -> Self {
-        let dapr_addr = format!("https://127.0.0.1:{}", dapr_port);
-
-        let cc = match TonicClient::connect(dapr_addr).await {
+        match Self::try_new_with_dapr_port(dapr_port).await {
             Ok(c) => c,
-            Err(err) => panic!("failed to connect to dapr: {}", err),
-        };
+            Err(err) => panic!("failed to connect to dapr: {err}"),
+        }
+    }
+
+    /// Creates a new instance of the Dapr HTTP server that connects to the Dapr sidecar on the
+    /// given dapr_port.
+    ///
+    /// In contrast to the other functions that create a DaprHttpServer, this function does
+    /// not panic, but instead returns a Result.
+    pub async fn try_new_with_dapr_port(
+        dapr_port: u16,
+    ) -> Result<Self, Box<dyn std::error::Error>> {
+        let dapr_addr = format!("https://127.0.0.1:{dapr_port}");
+
+        let cc = TonicClient::connect(dapr_addr).await?;
         let rt = ActorRuntime::new(cc);
 
-        DaprHttpServer {
+        Ok(DaprHttpServer {
             actor_runtime: Arc::new(rt),
             shutdown_signal: None,
-        }
+        })
     }
 
     pub fn with_graceful_shutdown<F>(self, signal: F) -> Self
@@ -138,7 +163,7 @@ impl DaprHttpServer {
             .unwrap_or(8080);
 
         let address = format!("127.0.0.1:{}", port.unwrap_or(default_port));
-        let listener = TcpListener::bind(address).await.unwrap();
+        let listener = TcpListener::bind(address).await?;
 
         let server = axum::serve(listener, app.into_make_service());
 
@@ -182,7 +207,8 @@ impl DaprHttpServer {
             .route(
                 "/actors/:actor_type/:actor_id/method/timer/:timer_name",
                 put(invoke_timer).with_state(rt.clone()),
-            );
+            )
+            .fallback(fallback_handler);
 
         self.actor_runtime
             .configure_method_routes(app, rt.clone())
@@ -190,6 +216,14 @@ impl DaprHttpServer {
     }
 }
 
+async fn fallback_handler(OriginalUri(uri): OriginalUri) -> impl IntoResponse {
+    log::warn!("Returning 404 for request: {uri}");
+    (
+        StatusCode::NOT_FOUND,
+        format!("The URI '{uri}' could not be found!"),
+    )
+}
+
 async fn health_check() -> impl IntoResponse {
     log::debug!("recieved health check request");
     StatusCode::OK
@@ -210,11 +244,11 @@ async fn deactivate_actor(
     match runtime.deactivate_actor(&actor_type, &actor_id).await {
         Ok(_) => StatusCode::OK,
         Err(err) => {
-            log::error!("invoke_actor: {:?}", err);
+            log::error!("invoke_actor: {err:?}");
             match err {
                 super::actor::ActorError::ActorNotFound => StatusCode::NOT_FOUND,
                 _ => {
-                    log::error!("deactivate_actor: {:?}", err);
+                    log::error!("deactivate_actor: {err:?}");
                     StatusCode::INTERNAL_SERVER_ERROR
                 }
             }
@@ -227,13 +261,7 @@ async fn invoke_reminder(
     Path((actor_type, actor_id, reminder_name)): Path<(String, String, String)>,
     Json(payload): Json<ReminderPayload>,
 ) -> impl IntoResponse {
-    log::debug!(
-        "invoke_reminder: {} {} {} {:?}",
-        actor_type,
-        actor_id,
-        reminder_name,
-        payload
-    );
+    log::debug!("invoke_reminder: {actor_type} {actor_id} {reminder_name} {payload:?}");
 
     match runtime
         .invoke_reminder(
@@ -246,11 +274,11 @@ async fn invoke_reminder(
     {
         Ok(_output) => StatusCode::OK,
         Err(err) => {
-            log::error!("invoke_actor: {:?}", err);
+            log::error!("invoke_actor: {err:?}");
             match err {
                 super::actor::ActorError::ActorNotFound => StatusCode::NOT_FOUND,
                 _ => {
-                    log::error!("invoke_reminder: {:?}", err);
+                    log::error!("invoke_reminder: {err:?}");
                     StatusCode::INTERNAL_SERVER_ERROR
                 }
             }
@@ -263,13 +291,7 @@ async fn invoke_timer(
     Path((actor_type, actor_id, timer_name)): Path<(String, String, String)>,
     Json(payload): Json<TimerPayload>,
 ) -> impl IntoResponse {
-    log::debug!(
-        "invoke_timer: {} {} {}, {:?}",
-        actor_type,
-        actor_id,
-        timer_name,
-        payload
-    );
+    log::debug!("invoke_timer: {actor_type} {actor_id} {timer_name}, {payload:?}");
 
     match runtime
         .invoke_timer(
@@ -282,11 +304,11 @@ async fn invoke_timer(
     {
         Ok(_output) => StatusCode::OK,
         Err(err) => {
-            log::error!("invoke_actor: {:?}", err);
+            log::error!("invoke_actor: {err:?}");
             match err {
                 super::actor::ActorError::ActorNotFound => StatusCode::NOT_FOUND,
                 _ => {
-                    log::error!("invoke_timer: {:?}", err);
+                    log::error!("invoke_timer: {err:?}");
                     StatusCode::INTERNAL_SERVER_ERROR
                 }
             }

dapr/src/server/utils.rs

@@ -28,14 +28,14 @@ where
         let bytes = match axum::body::Bytes::from_request(req, state).await {
             Ok(bytes) => bytes,
             Err(e) => {
-                log::error!("Error getting bytes: {}", e);
+                log::error!("Error getting bytes: {e}");
                 return Err(JsonRejection::JsonError(e.to_string()));
             }
         };
         let value = match serde_json::from_slice::<T>(&bytes) {
             Ok(value) => value,
             Err(e) => {
-                log::error!("Error deserializing JSON: {}", e);
+                log::error!("Error deserializing JSON: {e}");
                 return Err(JsonRejection::JsonError(e.to_string()));
             }
         };

daprdocs/README.md

@@ -8,13 +8,14 @@ All Dapr documentation is hosted at [docs.dapr.io](https://docs.dapr.io), includ
 
 ### Rust SDK docs source 
 
-Although the docs site code and content is in the [docs repo](https://github.com/dapr/docs), the Go SDK content and images are within the `content` and `static` directories, respectively. 
+Although the docs site code and content is in the [docs repo](https://github.com/dapr/docs), the Rust SDK content and images are within the `content` and `static` directories, respectively. 
 
 This allows separation of roles and expertise between maintainers, and makes it easy to find the docs files you are looking for.
 
 ## Writing Rust SDK docs
 
-To get up and running to write Go SDK docs, visit the [docs repo](https://github.com/dapr/docs) to initialize your environment. It will clone both the docs repo and this repo, so you can make changes and see it rendered within the site instantly, as well as commit and PR into this repo.
+To get up and running to write Rust SDK docs, visit the [docs repo](https://github.com/dapr/docs) to initialize your 
+environment. It will clone both the docs repo and this repo, so you can make changes and see it rendered within the site instantly, as well as commit and PR into this repo.
 
 Make sure to read the [docs contributing guide](https://docs.dapr.io/contributing/contributing-docs/) for information on style/semantics/etc.
 

daprdocs/content/en/rust-sdk-contributing/rust-contributing.md

@@ -12,7 +12,7 @@ When contributing to the [Rust SDK](https://github.com/dapr/rust-sdk) the follow
 
 The `examples` directory contains code samples for users to run to try out specific functionality of the various Rust SDK packages and extensions. It also hosts component examples used for validation. When writing new and updated samples keep in mind:
 
-- All examples should be runnable on Windows, Linux, and MacOS. While Rust code is consistent among operating systems aside from minor OS-feature gating, any pre/post example commands should provide options through [codetabs]({{< ref "contributing-docs.md#tabbed-content" >}})
+- All examples should be runnable on Windows, Linux, and MacOS. While Rust code is consistent among operating systems aside from minor OS-feature gating, any pre/post example commands should provide options through [tabpane]({{% ref "contributing-docs.md#tabbed-content" %}})
 - Contain steps to download/install any required pre-requisites. Someone coming in with a fresh OS install should be able to start on the example and complete it without an error. Links to external download pages are fine.
 - Examples should be pass validation and include mechanical markdown steps and be added to the validation workflow [TBA](#)
 
@@ -20,7 +20,7 @@ The `examples` directory contains code samples for users to run to try out speci
 
 The `daprdocs` directory contains the markdown files that are rendered into the [Dapr Docs](https://docs.dapr.io) website. When the documentation website is built this repo is cloned and configured so that its contents are rendered with the docs content. When writing docs keep in mind:
 
-   - All rules in the [docs guide]({{< ref contributing-docs.md >}}) should be followed in addition to these.
+   - All rules in the [docs guide]({{% ref contributing-docs.md %}}) should be followed in addition to these.
    - All files and directories should be prefixed with `rust-` to ensure all file/directory names are globally unique across all Dapr documentation.
 
 ## Update Protobufs

daprdocs/content/en/rust-sdk-docs/_index.md

@@ -22,6 +22,6 @@ A client library to help build Dapr applications using Rust. This client is targ
 {{< card title="**Client**">}}
   Use the Rust Client SDK for invoking public Dapr APIs
 
-  [**Learn more about the Rust Client SDK**]({{< ref rust-client >}})
+  [**Learn more about the Rust Client SDK**]({{% ref rust-client %}})
 {{< /card >}}
 {{< /cardpane >}}

daprdocs/content/en/rust-sdk-docs/rust-client/_index.md

@@ -7,19 +7,20 @@ description: How to get up and running with the Dapr Rust SDK
 no_list: true
 ---
 
-The Dapr client package allows you to interact with other Dapr applications from a Rust application.
+The Dapr client package allows you to interact with other Dapr applications from
+a Rust application.
 
 {{% alert title="Note" color="primary" %}}
-The Dapr Rust-SDK is currently in Alpha. Work is underway to bring it to a stable release and will likely involve breaking changes.
+The Dapr Rust-SDK is currently in Alpha. Work is underway to bring it to a
+stable release and will likely involve breaking changes.
 {{% /alert %}}
 
 ## Prerequisites
 
-- [Dapr CLI]({{< ref install-dapr-cli.md >}}) installed
-- Initialized [Dapr environment]({{< ref install-dapr-selfhost.md >}})
+- [Dapr CLI]({{% ref install-dapr-cli.md %}}) installed
+- Initialized [Dapr environment]({{% ref install-dapr-selfhost.md %}})
 - [Rust installed](https://www.rust-lang.org/tools/install)
 
-
 ## Import the client package
 
 Add Dapr to your `cargo.toml`
@@ -27,34 +28,42 @@ Add Dapr to your `cargo.toml`
 ```toml
 [dependencies]
 # Other dependencies
-dapr = "0.13.0"
+dapr = "0.16.0"
 ```
 
 You can either reference `dapr::Client` or bind the full path to a new name as follows:
+
 ```rust
-use dapr::Client as DaprClient
+use dapr::Client as DaprClient;
 ```
 
 ## Instantiating the Dapr client
 
 ```rust
-const addr: String = "https://127.0.0.1";
-const port: String = "50001";
+let addr = "https://127.0.0.1".to_string();
 
 let mut client = dapr::Client::<dapr::client::TonicClient>::connect(addr,
-    port).await?;
+port).await?;
 ```
 
+Alternatively if you would like to specify a custom port, this can be done by using this connect method:
+
+```rust
+let mut client = dapr::Client::<dapr::client::TonicClient>::connect_with_port(addr, "3500".to_string()).await?;
+```
 
 ## Building blocks
 
-The Rust SDK allows you to interface with the [Dapr building blocks]({{< ref building-blocks >}}).
+The Rust SDK allows you to interface with the
+[Dapr building blocks]({{% ref building-blocks %}}).
 
-### Service Invocation
+### Service Invocation (gRPC)
 
-To invoke a specific method on another service running with Dapr sidecar, the Dapr client Go SDK provides two options:
+To invoke a specific method on another service running with Dapr sidecar, the
+Dapr client provides two options:
+
+Invoke a (gRPC) service
 
-Invoke a service
 ```rust
 let response = client
     .invoke_service("service-to-invoke", "method-to-invoke", Some(data))
@@ -62,36 +71,43 @@ let response = client
     .unwrap();
 ```
 
-
-For a full guide on service invocation, visit [How-To: Invoke a service]({{< ref howto-invoke-discover-services.md >}}).
+For a full guide on service invocation, visit
+[How-To: Invoke a service]({{% ref howto-invoke-discover-services.md %}}).
 
 ### State Management
 
-The Dapr Client provides access to these state management methods:  `save_state`, `get_state`, `delete_state` that can be used like so:
+The Dapr Client provides access to these state management methods:  `save_state`
+, `get_state`, `delete_state` that can be used like so:
 
 ```rust
-let store_name = "store-name";
-let state_key = "state-key";
+let store_name = String::from("statestore");
 
-let states = vec![(state_key, ("state-value").as_bytes().to_vec())];
+let key = String::from("hello");
+let val = String::from("world").into_bytes();
 
-// save state with the key "state-key" and value "state-value"
-client.save_state(store_name, states).await?;
+// save key-value pair in the state store
+client
+    .save_state(store_name, key, val, None, None, None)
+    .await?;
 
-// get state for key "state-key"
-let response = client.get_state(store_name, state_key, None).await.unwrap();
+let get_response = client
+    .get_state("statestore", "hello", None)
+    .await?;
 
-// delete state for key "state-key"
-client.delete_state(store_name, state_key, None).await?;
+// delete a value from the state store
+client
+    .delete_state("statestore", "hello", None)
+    .await?;
 ```
 
-> **Note:** The `save_state` method currently performs a 'bulk' save but this will be refactored
+Multiple states can be sent with the `save_bulk_states` method.
 
-
-For a full guide on state management, visit [How-To: Save & get state]({{< ref howto-get-save-state.md >}}).
+For a full guide on state management, visit
+[How-To: Save & get state]({{% ref howto-get-save-state.md %}}).
 
 ### Publish Messages
-To publish data onto a topic, the Dapr Go client provides a simple method:
+
+To publish data onto a topic, the Dapr client provides a simple method:
 
 ```rust
 let pubsub_name = "pubsub-name".to_string();
@@ -104,7 +120,9 @@ client
     .await?;
 ```
 
-For a full guide on pub/sub, visit [How-To: Publish & subscribe]({{< ref howto-publish-subscribe.md >}}).
+For a full guide on pub/sub, visit
+[How-To: Publish & subscribe]({{% ref howto-publish-subscribe.md %}}).
 
 ## Related links
+
 [Rust SDK Examples](https://github.com/dapr/rust-sdk/tree/master/examples)

examples/Cargo.toml

@@ -10,7 +10,6 @@ rust-version.workspace = true
 
 [dependencies]
 async-trait = { workspace = true }
-base64 = "0.22"
 dapr = { path = "../dapr" }
 dapr-macros = { path = "../dapr-macros" }
 env_logger = "0.11"
@@ -47,6 +46,10 @@ path = "src/client/client.rs"
 name = "configuration"
 path = "src/configuration/main.rs"
 
+[[example]]
+name = "conversation"
+path = "src/conversation/main.rs"
+
 [[example]]
 name = "crypto"
 path = "src/crypto/main.rs"

examples/src/actors/client.rs

@@ -14,7 +14,7 @@ pub struct MyRequest {
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // TODO: Handle this issue in the sdk
     // Introduce delay so that dapr grpc port is assigned before app tries to connect
-    std::thread::sleep(std::time::Duration::new(2, 0));
+    tokio::time::sleep(std::time::Duration::new(2, 0)).await;
 
     // Define the Dapr address
     let addr = "https://127.0.0.1".to_string();
@@ -30,7 +30,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         .invoke_actor("MyActor", "a1", "do_stuff", data, None)
         .await;
 
-    println!("Response: {:#?}", resp);
+    println!("Response: {resp:#?}");
 
     Ok(())
 }

examples/src/actors/server.rs

@@ -31,7 +31,7 @@ impl MyActor {
         println!("doing stuff with {}", req.name);
         let mut dapr = self.client.clone();
         let r = dapr.get_actor_state("key1").await.unwrap();
-        println!("get_actor_state {:?}", r);
+        println!("get_actor_state {r:?}");
         Json(MyResponse { available: true })
     }
 }

examples/src/bindings/input.rs

@@ -61,7 +61,7 @@ impl AppCallback for AppCallbackService {
         let name = &r.name;
         let data = &r.data;
 
-        let message = String::from_utf8_lossy(&data);
+        let message = String::from_utf8_lossy(data);
         println!("Binding Name: {}", &name);
         println!("Message: {}", &message);
 
@@ -75,7 +75,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let callback_service = AppCallbackService::default();
 
-    println!("AppCallback server listening on: {}", addr);
+    println!("AppCallback server listening on: {addr}");
 
     // Create a gRPC server with the callback_service.
     Server::builder()

examples/src/bindings/output.rs

@@ -1,10 +1,10 @@
-use std::{collections::HashMap, thread, time::Duration};
+use std::{collections::HashMap, time::Duration};
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // TODO: Handle this issue in the sdk
     // Introduce delay so that dapr grpc port is assigned before app tries to connect
-    thread::sleep(Duration::from_secs(2));
+    tokio::time::sleep(Duration::from_secs(2)).await;
 
     // Get the Dapr port and create a connection
     let addr = "https://127.0.0.1".to_string();

examples/src/client/client.rs

@@ -2,7 +2,7 @@
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // TODO: Handle this issue in the sdk
     // Introduce delay so that dapr grpc port is assigned before app tries to connect
-    std::thread::sleep(std::time::Duration::new(2, 0));
+    tokio::time::sleep(std::time::Duration::new(2, 0)).await;
 
     // Set the Dapr address
     let addr = "https://127.0.0.1".to_string();
@@ -17,7 +17,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let store_name = String::from("statestore");
 
     // save key-value pair in the state store
-    client.save_state(store_name, vec![(key, val)]).await?;
+    client
+        .save_state(store_name, key, val, None, None, None)
+        .await?;
 
     println!("Successfully saved!");
 

examples/src/configuration/main.rs

@@ -7,7 +7,7 @@ type DaprClient = dapr::Client<dapr::client::TonicClient>;
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // TODO: Handle this issue in the sdk
     // Introduce delay so that dapr grpc port is assigned before app tries to connect
-    std::thread::sleep(std::time::Duration::new(2, 0));
+    tokio::time::sleep(std::time::Duration::new(2, 0)).await;
 
     // Set the Dapr address
     let addr = "https://127.0.0.1".to_string();
@@ -19,14 +19,14 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     // get key-value pair in the state store
     let response = client
-        .get_configuration(CONFIGSTORE_NAME, vec![(&key)], None)
+        .get_configuration(CONFIGSTORE_NAME, vec![&key], None)
         .await?;
     let val = response.items.get("hello").unwrap();
     println!("Configuration value: {val:?}");
 
     // Subscribe for configuration changes
     let mut stream = client
-        .subscribe_configuration(CONFIGSTORE_NAME, vec![(&key)], None)
+        .subscribe_configuration(CONFIGSTORE_NAME, vec![&key], None)
         .await?;
 
     let mut subscription_id = String::new();
@@ -52,7 +52,7 @@ async fn unsubscribe(client: &mut DaprClient, subscription_id: &str) {
         .await
     {
         Ok(_) => println!("App unsubscribed from config changes"),
-        Err(e) => println!("Error unsubscribing from config updates: {}", e),
+        Err(e) => println!("Error unsubscribing from config updates: {e}"),
     }
     std::process::exit(0);
 }

examples/src/conversation/README.md

@@ -0,0 +1,53 @@
+# Dapr Conversation Example with the Rust-SDK
+
+This example uses the echo component to send a request and the component response will be the exact message received.
+
+## Step
+
+### Prepare
+
+- Dapr installed
+
+### Run Conversation Example
+
+1. To run the example we need to first build the examples using the following command:
+
+<!-- STEP
+name: Build
+background: false
+sleep: 30
+timeout: 60
+-->
+
+```bash
+cargo build --examples
+```
+
+<!-- END_STEP -->
+
+2. Run the example using the Dapr CLI
+
+<!-- STEP
+name: Run Conversation
+output_match_mode: substring
+expected_stdout_lines:
+  - 'conversation input: "hello world"'
+  - 'conversation output: "hello world"'
+
+background: true
+sleep: 15
+timeout_seconds: 30
+-->
+
+```bash
+dapr run --app-id=conversation --resources-path ./config --dapr-grpc-port 3500 -- cargo run --example conversation
+```
+
+<!-- END_STEP -->
+
+## Result
+
+```
+  - 'conversation input: hello world'
+  - 'conversation output: hello world'
+```

examples/src/conversation/config/conversation-echo.yaml

@@ -0,0 +1,7 @@
+apiVersion: dapr.io/v1alpha1
+kind: Component
+metadata:
+  name: echo
+spec:
+  type: conversation.echo
+  version: v1

examples/src/conversation/main.rs

@@ -0,0 +1,30 @@
+use dapr::client::{ConversationInputBuilder, ConversationRequestBuilder};
+use std::time::Duration;
+
+type DaprClient = dapr::Client<dapr::client::TonicClient>;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Sleep to allow for the server to become available
+    tokio::time::sleep(Duration::from_secs(5)).await;
+
+    // Set the Dapr address
+    let address = "https://127.0.0.1".to_string();
+    let port = "3500".to_string();
+
+    let mut client = DaprClient::connect_with_port(address, port).await?;
+
+    let input = ConversationInputBuilder::new("hello world").build();
+
+    let conversation_component = "echo";
+
+    let request =
+        ConversationRequestBuilder::new(conversation_component, vec![input.clone()]).build();
+
+    println!("conversation input: {:?}", input.content);
+
+    let response = client.converse_alpha1(request).await?;
+
+    println!("conversation output: {:?}", response.outputs[0].result);
+    Ok(())
+}

examples/src/invoke/grpc-proxying/client.rs

@@ -1,4 +1,4 @@
-use std::{thread, time::Duration};
+use std::time::Duration;
 
 use hello_world::{greeter_client::GreeterClient, HelloRequest};
 
@@ -11,11 +11,11 @@ pub mod hello_world {
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Sleep to allow for the server to become available
-    thread::sleep(Duration::from_secs(5));
+    tokio::time::sleep(Duration::from_secs(5)).await;
 
     // Get the Dapr port and create a connection
     let port: u16 = std::env::var("DAPR_GRPC_PORT").unwrap().parse().unwrap();
-    let address = format!("https://127.0.0.1:{}", port);
+    let address = format!("https://127.0.0.1:{port}");
 
     let mut client = GreeterClient::connect(address).await?;
 
@@ -31,7 +31,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let response = client.say_hello(request).await.unwrap();
     let hello_reply = response.into_inner();
 
-    println!("Response: {:#?}", hello_reply);
+    println!("Response: {hello_reply:#?}");
 
     Ok(())
 }

examples/src/invoke/grpc-proxying/server.rs

@@ -33,7 +33,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let greeter_service = GreeterService::default();
 
-    println!("AppCallback server listening on: {}", server_address);
+    println!("AppCallback server listening on: {server_address}");
     // Create a gRPC server with the callback_service.
     Server::builder()
         .add_service(GreeterServer::new(greeter_service))

examples/src/invoke/grpc/client.rs

@@ -1,5 +1,5 @@
 use crate::hello_world::HelloReply;
-use std::{thread, time::Duration};
+use std::time::Duration;
 
 use prost::Message;
 
@@ -12,7 +12,7 @@ type DaprClient = dapr::Client<dapr::client::TonicClient>;
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Sleep to allow for the server to become available
-    thread::sleep(Duration::from_secs(5));
+    tokio::time::sleep(Duration::from_secs(5)).await;
 
     // Set the Dapr address
     let address = "https://127.0.0.1".to_string();
@@ -39,7 +39,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         println!("Message: {:#?}", &resp.message);
     };
 
-    println!("Response: {:#?}", response);
+    println!("Response: {response:#?}");
 
     Ok(())
 }

examples/src/invoke/grpc/server.rs

@@ -97,7 +97,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let callback_service = AppCallbackService {};
 
-    println!("AppCallback server listening on: {}", server_address);
+    println!("AppCallback server listening on: {server_address}");
     // Create a gRPC server with the callback_service.
     Server::builder()
         .add_service(AppCallbackServer::new(callback_service))

examples/src/invoke/protos/helloworld.rs

@@ -1,11 +1,9 @@
 // This file is @generated by prost-build.
-#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct HelloRequest {
     #[prost(string, tag = "1")]
     pub name: ::prost::alloc::string::String,
 }
-#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct HelloReply {
     #[prost(string, tag = "1")]
@@ -13,10 +11,15 @@ pub struct HelloReply {
 }
 /// Generated client implementations.
 pub mod greeter_client {
-    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
-    use tonic::codegen::http::Uri;
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
     use tonic::codegen::*;
-
+    use tonic::codegen::http::Uri;
     #[derive(Debug, Clone)]
     pub struct GreeterClient<T> {
         inner: tonic::client::Grpc<T>,
@@ -36,8 +39,8 @@ pub mod greeter_client {
     where
         T: tonic::client::GrpcService<tonic::body::BoxBody>,
         T::Error: Into<StdError>,
-        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
-        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
+        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
     {
         pub fn new(inner: T) -> Self {
             let inner = tonic::client::Grpc::new(inner);
@@ -60,8 +63,9 @@ pub mod greeter_client {
                     <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                 >,
             >,
-            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
-                Into<StdError> + Send + Sync,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
         {
             GreeterClient::new(InterceptedService::new(inner, interceptor))
         }
@@ -100,14 +104,18 @@ pub mod greeter_client {
             &mut self,
             request: impl tonic::IntoRequest<super::HelloRequest>,
         ) -> std::result::Result<tonic::Response<super::HelloReply>, tonic::Status> {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::new(
-                    tonic::Code::Unknown,
-                    format!("Service was not ready: {}", e.into()),
-                )
-            })?;
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static("/helloworld.Greeter/SayHello");
+            let path = http::uri::PathAndQuery::from_static(
+                "/helloworld.Greeter/SayHello",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("helloworld.Greeter", "SayHello"));
@@ -117,26 +125,31 @@ pub mod greeter_client {
 }
 /// Generated server implementations.
 pub mod greeter_server {
-    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
     use tonic::codegen::*;
-
     /// Generated trait containing gRPC methods that should be implemented for use with GreeterServer.
     #[async_trait]
-    pub trait Greeter: Send + Sync + 'static {
+    pub trait Greeter: std::marker::Send + std::marker::Sync + 'static {
         async fn say_hello(
             &self,
             request: tonic::Request<super::HelloRequest>,
         ) -> std::result::Result<tonic::Response<super::HelloReply>, tonic::Status>;
     }
     #[derive(Debug)]
-    pub struct GreeterServer<T: Greeter> {
+    pub struct GreeterServer<T> {
         inner: Arc<T>,
         accept_compression_encodings: EnabledCompressionEncodings,
         send_compression_encodings: EnabledCompressionEncodings,
         max_decoding_message_size: Option<usize>,
         max_encoding_message_size: Option<usize>,
     }
-    impl<T: Greeter> GreeterServer<T> {
+    impl<T> GreeterServer<T> {
         pub fn new(inner: T) -> Self {
             Self::from_arc(Arc::new(inner))
         }
@@ -149,7 +162,10 @@ pub mod greeter_server {
                 max_encoding_message_size: None,
             }
         }
-        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> InterceptedService<Self, F>
         where
             F: tonic::service::Interceptor,
         {
@@ -187,8 +203,8 @@ pub mod greeter_server {
     impl<T, B> tonic::codegen::Service<http::Request<B>> for GreeterServer<T>
     where
         T: Greeter,
-        B: Body + Send + 'static,
-        B::Error: Into<StdError> + Send + 'static,
+        B: Body + std::marker::Send + 'static,
+        B::Error: Into<StdError> + std::marker::Send + 'static,
     {
         type Response = http::Response<tonic::body::BoxBody>;
         type Error = std::convert::Infallible;
@@ -204,16 +220,21 @@ pub mod greeter_server {
                 "/helloworld.Greeter/SayHello" => {
                     #[allow(non_camel_case_types)]
                     struct SayHelloSvc<T: Greeter>(pub Arc<T>);
-                    impl<T: Greeter> tonic::server::UnaryService<super::HelloRequest> for SayHelloSvc<T> {
+                    impl<T: Greeter> tonic::server::UnaryService<super::HelloRequest>
+                    for SayHelloSvc<T> {
                         type Response = super::HelloReply;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::HelloRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut =
-                                async move { <T as Greeter>::say_hello(&inner, request).await };
+                            let fut = async move {
+                                <T as Greeter>::say_hello(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
@@ -239,21 +260,27 @@ pub mod greeter_server {
                     };
                     Box::pin(fut)
                 }
-                _ => Box::pin(async move {
-                    Ok(http::Response::builder()
-                        .status(200)
-                        .header("grpc-status", tonic::Code::Unimplemented as i32)
-                        .header(
-                            http::header::CONTENT_TYPE,
-                            tonic::metadata::GRPC_CONTENT_TYPE,
-                        )
-                        .body(empty_body())
-                        .unwrap())
-                }),
+                _ => {
+                    Box::pin(async move {
+                        let mut response = http::Response::new(empty_body());
+                        let headers = response.headers_mut();
+                        headers
+                            .insert(
+                                tonic::Status::GRPC_STATUS,
+                                (tonic::Code::Unimplemented as i32).into(),
+                            );
+                        headers
+                            .insert(
+                                http::header::CONTENT_TYPE,
+                                tonic::metadata::GRPC_CONTENT_TYPE,
+                            );
+                        Ok(response)
+                    })
+                }
             }
         }
     }
-    impl<T: Greeter> Clone for GreeterServer<T> {
+    impl<T> Clone for GreeterServer<T> {
         fn clone(&self) -> Self {
             let inner = self.inner.clone();
             Self {
@@ -265,7 +292,9 @@ pub mod greeter_server {
             }
         }
     }
-    impl<T: Greeter> tonic::server::NamedService for GreeterServer<T> {
-        const NAME: &'static str = "helloworld.Greeter";
+    /// Generated gRPC service name
+    pub const SERVICE_NAME: &str = "helloworld.Greeter";
+    impl<T> tonic::server::NamedService for GreeterServer<T> {
+        const NAME: &'static str = SERVICE_NAME;
     }
 }

examples/src/jobs/jobs.rs

@@ -1,6 +1,5 @@
 use std::time::Duration;
 
-use base64::prelude::*;
 use dapr::client::JobBuilder;
 use dapr::dapr::proto::runtime::v1::{
     app_callback_alpha_server::AppCallbackAlphaServer, JobEventRequest, JobEventResponse,
@@ -42,19 +41,10 @@ async fn backup_job_handler(request: JobEventRequest) -> Result<JobEventResponse
     // The logic for handling the backup job request
 
     if request.data.is_some() {
-        // weird value - any type is actually put into the value
-        let any = request.data.unwrap().value;
-
-        // parse any value
-        let any_parsed: JsonAny = serde_json::from_slice(&any).unwrap();
-
-        // Decode the base64-encoded value field
-        let decoded_value = BASE64_STANDARD.decode(any_parsed.value).unwrap();
-
         // Deserialize the decoded value into a Backup struct
-        let backup_val: Backup = serde_json::from_slice(&decoded_value).unwrap();
+        let backup_val: Backup = serde_json::from_slice(&request.data.unwrap().value).unwrap();
 
-        println!("job received: {:?}", backup_val);
+        println!("job received: {backup_val:?}");
     }
 
     Ok(JobEventResponse::default())
@@ -98,9 +88,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let client_addr = "https://127.0.0.1".to_string();
 
     let port: u16 = std::env::var("DAPR_GRPC_PORT")?.parse()?;
-    let address = format!("{}:{}", client_addr, port);
+    let address = format!("{client_addr}:{port}");
 
-    println!("attempting to create a dapr client: {}", address);
+    println!("attempting to create a dapr client: {address}");
 
     // Create the client
     let mut client = DaprClient::connect(client_addr).await?;
@@ -137,7 +127,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let get_resp_backup: Backup =
         serde_json::from_slice(&get_resp.clone().job.unwrap().data.unwrap().value).unwrap();
 
-    println!("job retrieved: {:?}", get_resp_backup);
+    println!("job retrieved: {get_resp_backup:?}");
 
     let _delete_resp = client.delete_job_alpha1("prod-db-backup").await?;
 

examples/src/pubsub/publisher.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, thread, time::Duration};
+use std::{collections::HashMap, time::Duration};
 
 use tokio::time;
 
@@ -21,7 +21,7 @@ struct Refund {
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // TODO: Handle this issue in the sdk
     // Introduce delay so that dapr grpc port is assigned before app tries to connect
-    thread::sleep(Duration::from_secs(2));
+    tokio::time::sleep(Duration::from_secs(2)).await;
 
     // Set address for Dapr connection
     let addr = "https://127.0.0.1".to_string();
@@ -45,7 +45,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     for count in 0..10 {
         let order = Order {
             order_number: count,
-            order_details: format!("Count is {}", count),
+            order_details: format!("Count is {count}"),
         };
         // message metadata
         let mut metadata = HashMap::<String, String>::new();

examples/src/pubsub/subscriber.rs

@@ -18,12 +18,12 @@ struct Refund {
 
 #[topic(pub_sub_name = "pubsub", topic = "A")]
 async fn handle_a_event(order: Order) {
-    println!("Topic A - {:#?}", order)
+    println!("Topic A - {order:#?}")
 }
 
 #[topic(pub_sub_name = "pubsub", topic = "B")]
 async fn handle_b_event(refund: Refund) {
-    println!("Topic B - {:#?}", refund)
+    println!("Topic B - {refund:#?}")
 }
 
 #[tokio::main]
@@ -36,7 +36,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     callback_service.add_handler(HandleBEvent.get_handler());
 
-    println!("AppCallback server listening on: {}", addr);
+    println!("AppCallback server listening on: {addr}");
 
     // Create a gRPC server with the callback_service.
     Server::builder()

examples/src/query_state/query1.rs

@@ -3,7 +3,7 @@ use serde_json::json;
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Introduce delay so that dapr grpc port is assigned before app tries to connect
-    std::thread::sleep(std::time::Duration::new(5, 0));
+    tokio::time::sleep(std::time::Duration::new(5, 0)).await;
 
     // Set the Dapr address and create a connection
     let addr = "https://127.0.0.1".to_string();
@@ -29,7 +29,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     {
         Ok(response) => response.results,
         Err(e) => {
-            println!("Error: {:?}", e);
+            println!("Error: {e:?}");
             return Ok(());
         }
     };
@@ -43,7 +43,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             "value": value
         }));
     }
-    println!("Query results: {:?}", results);
+    println!("Query results: {results:?}");
 
     Ok(())
 }

examples/src/query_state/query2.rs

@@ -3,7 +3,7 @@ use serde_json::json;
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Introduce delay so that dapr grpc port is assigned before app tries to connect
-    std::thread::sleep(std::time::Duration::new(5, 0));
+    tokio::time::sleep(std::time::Duration::new(5, 0)).await;
 
     // Set the Dapr address and create a connection
     let addr = "https://127.0.0.1".to_string();
@@ -23,7 +23,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     {
         Ok(response) => response.results,
         Err(e) => {
-            println!("Error: {:?}", e);
+            println!("Error: {e:?}");
             return Ok(());
         }
     };
@@ -37,7 +37,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             "value": value
         }));
     }
-    println!("Query results: {:?}", results);
+    println!("Query results: {results:?}");
 
     Ok(())
 }

proto-gen/src/main.rs

@@ -51,16 +51,16 @@ fn proto_gen(
         .map(|path| format!("{}/{}", root_dir.to_str().unwrap(), path))
         .collect::<Vec<_>>();
 
-    println!("included {:?}", include_dirs);
+    println!("included {include_dirs:?}");
 
     let interface = interface
         .iter()
         .map(|path| format!("{}/{}", root_dir.to_str().unwrap(), path))
         .collect::<Vec<_>>();
-    println!("interface {:?}", interface);
+    println!("interface {interface:?}");
 
     let out_dir = root_dir.join(out_dir);
-    println!("outdir {:?}", out_dir);
+    println!("outdir {out_dir:?}");
 
     tonic_build::configure()
         .build_client(build_client)
@@ -69,6 +69,6 @@ fn proto_gen(
         .out_dir(out_dir.clone())
         .file_descriptor_set_path(out_dir.clone().join("types.bin"))
         .protoc_arg("--experimental_allow_proto3_optional")
-        .compile(&include_dirs, &interface)
+        .compile_protos(&include_dirs, &interface)
         .expect("Failed to compile protos");
 }

proto/dapr/proto/common/v1/common.proto

@@ -157,4 +157,4 @@ message ConfigurationItem {
 
   // the metadata which will be passed to/from configuration store component.
   map<string,string> metadata = 3;
-}
+}

proto/dapr/proto/runtime/v1/dapr.proto

@@ -151,25 +151,39 @@ service Dapr {
   rpc SubtleVerifyAlpha1(SubtleVerifyRequest) returns (SubtleVerifyResponse);
 
   // Starts a new instance of a workflow
-  rpc StartWorkflowAlpha1 (StartWorkflowRequest) returns (StartWorkflowResponse) {}
+  rpc StartWorkflowAlpha1 (StartWorkflowRequest) returns (StartWorkflowResponse) {
+    option deprecated = true;
+  }
 
   // Gets details about a started workflow instance
-  rpc GetWorkflowAlpha1 (GetWorkflowRequest) returns (GetWorkflowResponse) {}
+  rpc GetWorkflowAlpha1 (GetWorkflowRequest) returns (GetWorkflowResponse) {
+    option deprecated = true;
+  }
 
   // Purge Workflow
-  rpc PurgeWorkflowAlpha1 (PurgeWorkflowRequest) returns (google.protobuf.Empty) {}
+  rpc PurgeWorkflowAlpha1 (PurgeWorkflowRequest) returns (google.protobuf.Empty) {
+    option deprecated = true;
+  }
 
   // Terminates a running workflow instance
-  rpc TerminateWorkflowAlpha1 (TerminateWorkflowRequest) returns (google.protobuf.Empty) {}
+  rpc TerminateWorkflowAlpha1 (TerminateWorkflowRequest) returns (google.protobuf.Empty) {
+    option deprecated = true;
+  }
 
   // Pauses a running workflow instance
-  rpc PauseWorkflowAlpha1 (PauseWorkflowRequest) returns (google.protobuf.Empty) {}
+  rpc PauseWorkflowAlpha1 (PauseWorkflowRequest) returns (google.protobuf.Empty) {
+    option deprecated = true;
+  }
 
   // Resumes a paused workflow instance
-  rpc ResumeWorkflowAlpha1 (ResumeWorkflowRequest) returns (google.protobuf.Empty) {}
+  rpc ResumeWorkflowAlpha1 (ResumeWorkflowRequest) returns (google.protobuf.Empty) {
+    option deprecated = true;
+  }
 
   // Raise an event to a running workflow instance
-  rpc RaiseEventWorkflowAlpha1 (RaiseEventWorkflowRequest) returns (google.protobuf.Empty) {}
+  rpc RaiseEventWorkflowAlpha1 (RaiseEventWorkflowRequest) returns (google.protobuf.Empty) {
+    option deprecated = true;
+  }
 
   // Starts a new instance of a workflow
   rpc StartWorkflowBeta1 (StartWorkflowRequest) returns (StartWorkflowResponse) {}
@@ -191,6 +205,7 @@ service Dapr {
 
   // Raise an event to a running workflow instance
   rpc RaiseEventWorkflowBeta1 (RaiseEventWorkflowRequest) returns (google.protobuf.Empty) {}
+  
   // Shutdown the sidecar
   rpc Shutdown (ShutdownRequest) returns (google.protobuf.Empty) {}
 
@@ -202,6 +217,9 @@ service Dapr {
 
   // Delete a job
   rpc DeleteJobAlpha1(DeleteJobRequest) returns (DeleteJobResponse) {}
+
+  // Converse with a LLM service
+  rpc ConverseAlpha1(ConversationRequest) returns (ConversationResponse) {}
 }
 
 // InvokeServiceRequest represents the request message for Service invocation.
@@ -676,7 +694,14 @@ message GetMetadataResponse {
   string runtime_version = 8 [json_name = "runtimeVersion"];
   repeated string enabled_features = 9 [json_name = "enabledFeatures"];
   ActorRuntime actor_runtime = 10 [json_name = "actorRuntime"];
-  //TODO: Cassie: probably add scheduler runtime status
+  optional MetadataScheduler scheduler = 11 [json_name = "scheduler"];
+}
+
+// MetadataScheduler is a message that contains the list of addresses of the
+// scheduler connections.
+message MetadataScheduler {
+  // connected_addresses the list of addresses of the scheduler connections.
+  repeated string connected_addresses = 1;
 }
 
 message ActorRuntime {
@@ -1206,20 +1231,20 @@ message Job {
   //
   // Systemd timer style cron accepts 6 fields:
   // seconds | minutes | hours | day of month | month        | day of week
-  // 0-59    | 0-59    | 0-23  | 1-31         | 1-12/jan-dec | 0-7/sun-sat
+  // 0-59    | 0-59    | 0-23  | 1-31         | 1-12/jan-dec | 0-6/sun-sat
   //
   // "0 30 * * * *" - every hour on the half hour
   // "0 15 3 * * *" - every day at 03:15
   //
   // Period string expressions:
-  // Entry                  | Description                                  | Equivalent To
-  // -----                  | -----------                                  | -------------
+	// Entry                  | Description                                  | Equivalent To
+	// -----                  | -----------                                  | -------------
   // @every `<duration>`    | Run every `<duration>` (e.g. '@every 1h30m') | N/A
-  // @yearly (or @annually) | Run once a year, midnight, Jan. 1st          | 0 0 0 1 1 *
-  // @monthly               | Run once a month, midnight, first of month   | 0 0 0 1 * *
-  // @weekly                | Run once a week, midnight on Sunday          | 0 0 0 * * 0
-  // @daily (or @midnight)  | Run once a day, midnight                     | 0 0 0 * * *
-  // @hourly                | Run once an hour, beginning of hour          | 0 0 * * * *
+	// @yearly (or @annually) | Run once a year, midnight, Jan. 1st          | 0 0 0 1 1 *
+	// @monthly               | Run once a month, midnight, first of month   | 0 0 0 1 * *
+	// @weekly                | Run once a week, midnight on Sunday          | 0 0 0 * * 0
+	// @daily (or @midnight)  | Run once a day, midnight                     | 0 0 0 * * *
+	// @hourly                | Run once an hour, beginning of hour          | 0 0 * * * *
   optional string schedule = 2 [json_name = "schedule"];
 
   // repeats is the optional number of times in which the job should be
@@ -1274,4 +1299,56 @@ message DeleteJobRequest {
 // DeleteJobResponse is the message response to delete the job by name.
 message DeleteJobResponse {
   // Empty
-}
+}
+
+// ConversationRequest is the request object for Conversation.
+message ConversationRequest {
+  // The name of Conversation component
+  string name = 1;
+
+  // The ID of an existing chat (like in ChatGPT)
+  optional string contextID = 2;
+
+  // Inputs for the conversation, support multiple input in one time.
+  repeated ConversationInput inputs = 3;
+
+  // Parameters for all custom fields.
+  map<string, google.protobuf.Any> parameters = 4;
+
+  // The metadata passing to conversation components.
+  map<string, string> metadata = 5;
+
+  // Scrub PII data that comes back from the LLM
+  optional bool scrubPII = 6;
+
+  // Temperature for the LLM to optimize for creativity or predictability
+  optional double temperature = 7;
+}
+
+message ConversationInput {
+  // The content to send to the llm
+  string content = 1;
+
+  // The role to set for the message
+  optional string role = 2;
+
+  // Scrub PII data that goes into the LLM
+  optional bool scrubPII = 3;
+}
+
+// ConversationResult is the result for one input.
+message ConversationResult {
+  // Result for the one conversation input.
+  string result = 1;
+  // Parameters for all custom fields.
+  map<string, google.protobuf.Any> parameters = 2;
+}
+
+// ConversationResponse is the response for Conversation.
+message ConversationResponse {
+  // The ID of an existing chat (like in ChatGPT)
+  optional string contextID = 1;
+
+  // An array of results.
+  repeated ConversationResult outputs = 2;
+}