refactor: make model field required, remove resolve_model_id

crates/protocols/src/chat.rs

@@ -6,10 +6,9 @@ use validator::Validate;
 
 use super::{
     common::{
-        default_model, default_true, validate_stop, ChatLogProbs, ContentPart, Function,
-        FunctionCall, FunctionChoice, GenerationRequest, ResponseFormat, StreamOptions,
-        StringOrArray, Tool, ToolCall, ToolCallDelta, ToolChoice, ToolChoiceValue, ToolReference,
-        Usage,
+        default_true, validate_stop, ChatLogProbs, ContentPart, Function, FunctionCall,
+        FunctionChoice, GenerationRequest, ResponseFormat, StreamOptions, StringOrArray, Tool,
+        ToolCall, ToolCallDelta, ToolChoice, ToolChoiceValue, ToolReference, Usage,
     },
     sampling_params::{validate_top_k_value, validate_top_p_value},
 };
@@ -148,7 +147,6 @@ pub struct ChatCompletionRequest {
     pub messages: Vec<ChatMessage>,
 
     /// ID of the model to use
-    #[serde(default = "default_model")]
     pub model: String,
 
     /// Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing frequency in the text so far

crates/protocols/src/common.rs

@@ -4,15 +4,14 @@ use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use validator;
 
-use super::UNKNOWN_MODEL_ID;
-
 // ============================================================================
 // Default value helpers
 // ============================================================================
 
-/// Default model value when not specified
-pub(crate) fn default_model() -> String {
-    UNKNOWN_MODEL_ID.to_string()
+/// Default model for endpoints where model is optional (e.g., /generate).
+/// Uses UNKNOWN_MODEL_ID so routers treat it as "any available worker."
+pub fn default_unknown_model() -> String {
+    super::UNKNOWN_MODEL_ID.to_string()
 }
 
 /// Helper function for serde default value (returns true)

crates/protocols/src/generate.rs

@@ -21,7 +21,8 @@ pub struct GenerateRequest {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub text: Option<String>,
 
-    pub model: Option<String>,
+    #[serde(default = "super::common::default_unknown_model")]
+    pub model: String,
 
     /// Input IDs for tokenized input
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -203,12 +204,7 @@ impl GenerationRequest for GenerateRequest {
     }
 
     fn get_model(&self) -> Option<&str> {
-        // Generate requests have an optional model field
-        if let Some(s) = &self.model {
-            Some(s.as_str())
-        } else {
-            None
-        }
+        Some(self.model.as_str())
     }
 
     fn extract_text_for_routing(&self) -> String {

crates/protocols/src/interactions.rs

@@ -9,7 +9,7 @@ use serde_with::skip_serializing_none;
 use validator::{Validate, ValidationError};
 
 use super::{
-    common::{default_model, default_true, Function, GenerationRequest},
+    common::{default_true, Function, GenerationRequest},
     sampling_params::validate_top_p_value,
     validated::Normalizable,
 };
@@ -76,7 +76,7 @@ pub struct InteractionsRequest {
 impl Default for InteractionsRequest {
     fn default() -> Self {
         Self {
-            model: Some(default_model()),
+            model: None,
             agent: None,
             agent_config: None,
             input: InteractionsInput::Text(String::new()),

crates/protocols/src/rerank.rs

@@ -4,7 +4,7 @@ use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use validator::Validate;
 
-use super::common::{default_model, default_true, GenerationRequest, StringOrArray, UsageInfo};
+use super::common::{default_true, GenerationRequest, StringOrArray, UsageInfo};
 
 fn default_rerank_object() -> String {
     "rerank".to_string()
@@ -34,7 +34,6 @@ pub struct RerankRequest {
     pub documents: Vec<String>,
 
     /// Model to use for reranking
-    #[serde(default = "default_model")]
     pub model: String,
 
     /// Maximum number of documents to return (optional)
@@ -205,7 +204,7 @@ impl From<V1RerankReqInput> for RerankRequest {
         RerankRequest {
             query: v1.query,
             documents: v1.documents,
-            model: default_model(),
+            model: super::UNKNOWN_MODEL_ID.to_string(),
             top_k: None,
             return_documents: true,
             rid: None,

crates/protocols/src/responses.rs

@@ -9,7 +9,7 @@ use validator::{Validate, ValidationError};
 
 use super::{
     common::{
-        default_model, default_true, validate_stop, ChatLogProbs, Function, GenerationRequest,
+        default_true, validate_stop, ChatLogProbs, Function, GenerationRequest,
         PromptTokenUsageInfo, StringOrArray, ToolChoice, ToolChoiceValue, ToolReference, UsageInfo,
     },
     sampling_params::{validate_top_k_value, validate_top_p_value},
@@ -667,7 +667,6 @@ pub struct ResponsesRequest {
     pub metadata: Option<HashMap<String, Value>>,
 
     /// Model to use
-    #[serde(default = "default_model")]
     pub model: String,
 
     /// Optional conversation id to persist input/output as items
@@ -795,7 +794,7 @@ impl Default for ResponsesRequest {
             max_output_tokens: None,
             max_tool_calls: None,
             metadata: None,
-            model: default_model(),
+            model: String::new(),
             conversation: None,
             parallel_tool_calls: None,
             previous_response_id: None,

crates/protocols/src/tokenize.rs

@@ -5,8 +5,6 @@
 
 use serde::{Deserialize, Serialize};
 
-use super::UNKNOWN_MODEL_ID;
-
 // ============================================================================
 // Tokenize API
 // ============================================================================
@@ -17,7 +15,6 @@ use super::UNKNOWN_MODEL_ID;
 #[derive(Debug, Clone, Deserialize, Serialize, schemars::JsonSchema)]
 pub struct TokenizeRequest {
     /// Model name for tokenizer selection
-    #[serde(default = "default_model_name")]
     pub model: String,
 
     /// Text(s) to tokenize - can be a single string or array of strings
@@ -63,7 +60,6 @@ pub enum CountResult {
 #[derive(Debug, Clone, Deserialize, Serialize, schemars::JsonSchema)]
 pub struct DetokenizeRequest {
     /// Model name for tokenizer selection
-    #[serde(default = "default_model_name")]
     pub model: String,
 
     /// Token IDs to detokenize - single list or batch (list of lists)
@@ -209,10 +205,6 @@ impl StringOrArray {
 // Default Functions
 // ============================================================================
 
-fn default_model_name() -> String {
-    UNKNOWN_MODEL_ID.to_string()
-}
-
 fn default_true() -> bool {
     true
 }
@@ -222,11 +214,10 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_tokenize_request_single() {
+    fn test_tokenize_request_requires_model() {
         let json = r#"{"prompt": "Hello world"}"#;
-        let req: TokenizeRequest = serde_json::from_str(json).unwrap();
-        assert_eq!(req.model, "unknown");
-        assert!(matches!(req.prompt, StringOrArray::Single(_)));
+        let result = serde_json::from_str::<TokenizeRequest>(json);
+        assert!(result.is_err(), "Should fail without model field");
     }
 
     #[test]
@@ -238,16 +229,23 @@ mod tests {
     }
 
     #[test]
-    fn test_detokenize_request_single() {
+    fn test_detokenize_request_requires_model() {
         let json = r#"{"tokens": [1, 2, 3]}"#;
+        let result = serde_json::from_str::<DetokenizeRequest>(json);
+        assert!(result.is_err(), "Should fail without model field");
+    }
+
+    #[test]
+    fn test_detokenize_request_single() {
+        let json = r#"{"model": "test-model", "tokens": [1, 2, 3]}"#;
         let req: DetokenizeRequest = serde_json::from_str(json).unwrap();
         assert!(matches!(req.tokens, TokensInput::Single(_)));
         assert!(req.skip_special_tokens);
     }
 
     #[test]
     fn test_detokenize_request_batch() {
-        let json = r#"{"tokens": [[1, 2], [3, 4, 5]], "skip_special_tokens": false}"#;
+        let json = r#"{"model": "test-model", "tokens": [[1, 2], [3, 4, 5]], "skip_special_tokens": false}"#;
         let req: DetokenizeRequest = serde_json::from_str(json).unwrap();
         assert!(matches!(req.tokens, TokensInput::Batch(_)));
         assert!(!req.skip_special_tokens);

model_gateway/benches/request_processing.rs

@@ -38,7 +38,7 @@ fn get_bootstrap_info(worker: &BasicWorker) -> (String, Option<u16>) {
 fn default_generate_request() -> GenerateRequest {
     GenerateRequest {
         text: None,
-        model: None,
+        model: "unknown".to_string(),
         input_ids: None,
         input_embeds: None,
         image_data: None,

model_gateway/benches/wasm_middleware_latency.rs

@@ -29,7 +29,7 @@ impl RouterTrait for MockRouter {
         &self,
         _headers: Option<&HeaderMap>,
         _body: &ChatCompletionRequest,
-        _model_id: Option<&str>,
+        _model_id: &str,
     ) -> Response<Body> {
         StatusCode::OK.into_response()
     }

model_gateway/src/routers/grpc/common/responses/utils.rs

@@ -91,14 +91,7 @@ pub(crate) fn validate_worker_availability(
     let available_models = worker_registry.get_models();
 
     if !available_models.contains(&model.to_string()) {
-        return Some(error::service_unavailable(
-            "no_available_workers",
-            format!(
-                "No workers available for model '{}'. Available models: {}",
-                model,
-                available_models.join(", ")
-            ),
-        ));
+        return Some(error::model_not_found(model));
     }
 
     None

model_gateway/src/routers/grpc/common/stages/dispatch_metadata.rs

@@ -7,12 +7,9 @@ use axum::response::Response;
 use tracing::error;
 
 use super::PipelineStage;
-use crate::{
-    core::UNKNOWN_MODEL_ID,
-    routers::{
-        error,
-        grpc::context::{DispatchMetadata, RequestContext, RequestType, WorkerSelection},
-    },
+use crate::routers::{
+    error,
+    grpc::context::{DispatchMetadata, RequestContext, RequestType, WorkerSelection},
 };
 
 /// Dispatch metadata stage: Prepare metadata for dispatch
@@ -34,11 +31,8 @@ impl PipelineStage for DispatchMetadataStage {
             RequestType::Chat(req) => req.model.clone(),
             RequestType::Generate(_req) => {
                 // Generate requests don't have a model field
-                // Use model_id from input or UNKNOWN_MODEL_ID
-                ctx.input
-                    .model_id
-                    .clone()
-                    .unwrap_or_else(|| UNKNOWN_MODEL_ID.to_string())
+                // Use model_id from input
+                ctx.input.model_id.clone()
             }
             RequestType::Responses(req) => req.model.clone(),
             RequestType::Embedding(req) => req.model.clone(),