fix!: build errors

Author: Tjemmmic

Cargo.lock

@@ -74,7 +74,10 @@ async fn main() -> Result<(), blueprint_sdk::Error> {
     let result = BlueprintRunner::builder(tangle_config, env)
         .router(
             Router::new()
-                .route(PROCESS_LLM_REQUEST_JOB_ID, process_llm_request.layer(TangleLayer))
+                .route(
+                    PROCESS_LLM_REQUEST_JOB_ID,
+                    process_llm_request.layer(TangleLayer),
+                )
                 .route(REPORT_METRICS_JOB_ID, report_metrics.layer(TangleLayer))
                 .layer(FilterLayer::new(MatchesServiceId(service_id)))
                 .with_context(context),

open-router-blueprint-template-bin/src/main.rs

@@ -7,10 +7,12 @@ use tracing::info;
 use crate::config::BlueprintConfig;
 use crate::llm::{LlmClient, LocalLlmClient, LocalLlmConfig, NodeMetrics};
 use crate::load_balancer::{LoadBalancer, LoadBalancerConfig};
+use blueprint_sdk::macros::context::{KeystoreContext, ServicesContext, TangleClientContext};
 
 /// Context for the OpenRouter Blueprint
-#[derive(Clone)]
+#[derive(Clone, KeystoreContext, TangleClientContext, ServicesContext)]
 pub struct OpenRouterContext {
+    #[config]
     /// Blueprint environment configuration
     pub env: BlueprintEnvironment,
 

open-router-blueprint-template-lib/src/context.rs

@@ -6,10 +6,10 @@ use crate::context::OpenRouterContext;
 use crate::llm::{LlmClientExt, LlmRequest, LlmResponse};
 
 /// Job ID for processing LLM requests
-pub const PROCESS_LLM_REQUEST_JOB_ID: u32 = 0;
+pub const PROCESS_LLM_REQUEST_JOB_ID: u8 = 0;
 
 /// Job ID for reporting metrics
-pub const REPORT_METRICS_JOB_ID: u32 = 1;
+pub const REPORT_METRICS_JOB_ID: u8 = 1;
 
 /// Process an LLM request
 ///

open-router-blueprint-template-lib/src/jobs.rs

@@ -150,15 +150,13 @@ impl LlmClient for LocalLlmClient {
     }
 
     /// Template method for embeddings. To use, override this method in your concrete blueprint.
-    async fn embeddings(
-        &self,
-        request: EmbeddingRequest,
-    ) -> Result<EmbeddingResponse> {
+    async fn embeddings(&self, request: EmbeddingRequest) -> Result<EmbeddingResponse> {
         if !self.config.models.iter().any(|m| m.id == request.model) {
             return Err(LlmError::ModelNotSupported(request.model));
         }
         Err(LlmError::NotImplemented(
-            "embeddings must be implemented in your blueprint (see LocalLlmClient in template)".to_string(),
+            "embeddings must be implemented in your blueprint (see LocalLlmClient in template)"
+                .to_string(),
         ))
     }
 }

open-router-blueprint-template-lib/src/llm/local_llm.rs

@@ -43,6 +43,7 @@ pub enum LlmError {
 pub type Result<T> = std::result::Result<T, LlmError>;
 
 /// Trait for LLM clients
+#[allow(async_fn_in_trait)]
 #[async_trait]
 pub trait LlmClient: Send + Sync {
     /// Get information about the supported models
@@ -137,6 +138,7 @@ pub struct NodeMetrics {
 }
 
 /// Trait for LLM clients that support streaming responses
+#[allow(async_fn_in_trait)]
 #[async_trait::async_trait]
 pub trait StreamingLlmClient: LlmClient {
     /// Process a streaming chat completion request
@@ -153,6 +155,7 @@ pub trait StreamingLlmClient: LlmClient {
 }
 
 /// Extension trait for checking if an LlmClient also implements StreamingLlmClient
+#[allow(async_fn_in_trait)]
 pub trait LlmClientExt {
     /// Check if this client supports streaming
     fn supports_streaming(&self) -> bool;

open-router-blueprint-template-lib/src/llm/mod.rs

@@ -45,6 +45,20 @@ pub struct ChatCompletionRequest {
     pub additional_params: HashMap<String, serde_json::Value>,
 }
 
+impl Default for ChatCompletionRequest {
+    fn default() -> Self {
+        Self {
+            model: String::new(),
+            messages: Vec::new(),
+            max_tokens: None,
+            temperature: None,
+            top_p: None,
+            stream: None,
+            additional_params: HashMap::new(),
+        }
+    }
+}
+
 /// A chat completion choice
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ChatCompletionChoice {
@@ -110,6 +124,20 @@ pub struct TextCompletionRequest {
     pub additional_params: HashMap<String, serde_json::Value>,
 }
 
+impl Default for TextCompletionRequest {
+    fn default() -> Self {
+        Self {
+            model: String::new(),
+            prompt: String::new(),
+            max_tokens: None,
+            temperature: None,
+            top_p: None,
+            stream: None,
+            additional_params: HashMap::new(),
+        }
+    }
+}
+
 /// A text completion choice
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct TextCompletionChoice {
@@ -159,6 +187,16 @@ pub struct EmbeddingRequest {
     pub additional_params: HashMap<String, serde_json::Value>,
 }
 
+impl Default for EmbeddingRequest {
+    fn default() -> Self {
+        Self {
+            model: String::new(),
+            input: Vec::new(),
+            additional_params: HashMap::new(),
+        }
+    }
+}
+
 /// A single embedding result
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct EmbeddingData {
@@ -212,6 +250,12 @@ pub enum LlmRequest {
     Embedding(EmbeddingRequest),
 }
 
+impl Default for LlmRequest {
+    fn default() -> Self {
+        Self::ChatCompletion(ChatCompletionRequest::default())
+    }
+}
+
 /// A unified response type that can represent any LLM operation result
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(tag = "type")]

open-router-blueprint-template-lib/src/llm/models.rs

@@ -1,13 +1,13 @@
 use std::pin::Pin;
 // use std::task::{Context, Poll};
-use async_trait::async_trait;
+// Removed unused import: async_trait::async_trait
 use futures::stream::{Stream, StreamExt};
 use tokio::sync::mpsc;
 use tokio_stream::wrappers::ReceiverStream;
 
 use super::{
-    ChatCompletionChoice, ChatCompletionRequest, ChatCompletionResponse, ChatMessage, LlmError,
-    Result, TextCompletionChoice, TextCompletionRequest, TextCompletionResponse,
+    ChatCompletionChoice, ChatCompletionResponse, ChatMessage, LlmError, Result,
+    TextCompletionChoice, TextCompletionResponse,
 };
 
 /// A chunk of a streaming chat completion response
@@ -185,10 +185,13 @@ pub async fn collect_chat_completion_stream(
         .collect();
 
     Ok(ChatCompletionResponse {
-        // id,
-        // object: "chat.completion".to_string(),
-        // created,
-        // model,
+        id: "stream-collected".to_string(),
+        object: "chat.completion".to_string(),
+        created: std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_secs(),
+        model: "unknown".to_string(),
         choices: response_choices,
         usage: None, // Usage information is not available when streaming
     })
@@ -250,10 +253,13 @@ pub async fn collect_text_completion_stream(
         .collect();
 
     Ok(TextCompletionResponse {
-        // id,
-        // object: "text_completion".to_string(),
-        // created,
-        // model,
+        id: "stream-collected".to_string(),
+        object: "text_completion".to_string(),
+        created: std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_secs(),
+        model: "unknown".to_string(),
         choices: response_choices,
         usage: None, // Usage information is not available when streaming
     })

open-router-blueprint-template-lib/src/llm/streaming.rs

@@ -3,6 +3,7 @@ use blueprint_sdk::tangle::serde::to_field;
 use blueprint_sdk::testing::tempfile;
 use blueprint_sdk::testing::utils::setup_log;
 use blueprint_sdk::testing::utils::tangle::TangleTestHarness;
+use blueprint_sdk::Job;
 use open_router_blueprint_template_lib::{
     process_llm_request, OpenRouterContext, PROCESS_LLM_REQUEST_JOB_ID,
 };
@@ -23,7 +24,7 @@ async fn test_blueprint() -> color_eyre::Result<()> {
 
     test_env.initialize().await?;
     test_env
-        .add_job(PROCESS_LLM_REQUEST_JOB_ID.layer(TangleLayer))
+        .add_job(process_llm_request.layer(TangleLayer))
         .await;
 
     test_env.start(context).await?;

open-router-blueprint-template-lib/tests/e2e.rs

@@ -57,7 +57,7 @@ async fn test_process_chat_completion_request() -> color_eyre::Result<()> {
     let result = process_llm_request(Context(context), TangleArg(llm_request)).await?;
 
     // Convert the result to a JobResult
-    let job_result = result.into_job_result()?;
+    let job_result = result.into_job_result().unwrap();
 
     // Verify that the job was successful
     match job_result {
@@ -100,7 +100,7 @@ async fn test_process_text_completion_request() -> color_eyre::Result<()> {
     let result = process_llm_request(Context(context), TangleArg(llm_request)).await?;
 
     // Convert the result to a JobResult
-    let job_result = result.into_job_result()?;
+    let job_result = result.into_job_result().unwrap();
 
     // Verify that the job was successful
     match job_result {
@@ -139,7 +139,7 @@ async fn test_process_embedding_request() -> color_eyre::Result<()> {
     let result = process_llm_request(Context(context), TangleArg(llm_request)).await?;
 
     // Convert the result to a JobResult
-    let job_result = result.into_job_result()?;
+    let job_result = result.into_job_result().unwrap();
 
     // Verify that the job was successful
     match job_result {