text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
use std::collections::HashMap;
use serde::{Deserialize, Serialize};
use serde_json::{Map, Value};
use validator::Validate;
use vllm_text::SamplingParams;
use crate::routes::openai::utils::types::{ChatLogProbs, Normalizable, StreamOptions, Usage};
/// vLLM-compatible request type for the token-in/token-out generate A... | fim | vllm-project/vllm | rust |
use super::types::GenerateRequest;
use crate::error::{ApiError, bail_invalid_request};
/// Enforce the minimal compatibility contract for the Rust token generate
/// route.
pub(super) fn validate_request_compat(
request: &GenerateRequest,
served_model_names: &[String],
) -> Result<(), ApiError> {
if let So... | fim | vllm-project/vllm | rust |
<|fim_prefix|>mod convert;
mod types;
mod validate;
use std::collections::HashMap;
use std::convert::Infallible;
use std::result::Result;
use std::sync::Arc;
use asynk_strim_attr::{TryYielder, try_stream};
use axum::Json;
use axum::extract::State;
use axum::http::HeaderMap;
use axum::response::sse::{Event, Sse<|fim_s... | fim | vllm-project/vllm | rust |
<|fim_suffix|>pub use generate::generate;
<|fim_prefix|><|fim_middle|>pub mod generate;
<|endoftext|> | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::sync::Arc;
<|fim_suffix|>e.server_load(),
})
}
<|fim_middle|>
use axum::Json;
use axum::extract::State;
use serde::Serialize;
use crate::state::AppState;
#[derive(Serialize)]
pub(crate) struct ServerLoadResponse {
server_load: u64,
}
pub async fn load(State(state): State<Arc<AppState>>... | fim | vllm-project/vllm | rust |
<|fim_suffix|>s();
let lora_path = validate_lora_path_access(&request.lora_path, allowed_prefixes.as_deref())?
.unwrap_or(request.lora_path);
let lora_name = request.lora_name;
state
.load_lora(
lora_name.clone(),
lora_path,
request.load_inplace,
... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use axum::http::header:<|fim_suffix|>ENT_TYPE,
HeaderValue::from_static(OPENMETRICS_CONTENT_TYPE),
)],
body,
)
.into_response(),
Err(error) => (
StatusCode::INTERNAL_SERVER_ERROR,
format!("failed to render metrics... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use itertools::Itertools as _;
use vllm_chat::{
AssistantContentBlock, AssistantToolCall, ChatContent, ChatContentPart,
ChatMessage as VllmChatMessage, ChatOptions, ChatRequest, ChatTool, ChatToolChoice,
GenerationPromptMode, SamplingParams,
};
use super::types::ChatCompletionRequest;
use sup... | fim | vllm-project/vllm | rust |
<|fim_suffix|>Option<Usage>,
pub prompt_token_ids: Option<Vec<u32>>,
}
impl ChatCompletionStreamResponse {
/// Create a stream response with the standard envelope fields pre-filled.
pub fn new(id: &str, model: &str, created: u64) -> Self {
Self {
id: id.to_string(),
object: ... | fim | vllm-project/vllm | rust |
<|fim_suffix|>_err());
}
#[test]
fn validate_request_compat_accepts_output_logprobs() {
let request = ChatCompletionRequest {
logprobs: true,
..base_request()
};
validate_request_compat(&request, &served(&["Qwen/Qwen1.5-0.5B-Chat"]))
.expect("logp... | fim | vllm-project/vllm | rust |
<|fim_suffix|>model".to_string(),
1,
ApiServerOptions::default(),
ResponseOptions {
include_reasoning: true,
..Default::default()
},
)
.collect::<Vec<_>>()
.await
.into_iter()
.collect::<Result<Vec<_>... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use vllm_text::{SamplingParams, TextDecodeOptions, TextRequest};
use super::types::CompletionRequest;
use crate::error::ApiError;
use crate::lora::LoraModelResolution;
use crate::routes::openai::completions::validate;
use crate::routes::openai::utils::structured_outputs::convert_from_response_format_valu... | fim | vllm-project/vllm | rust |
<|fim_suffix|>itive text
pub repetition_penalty: Option<f32>,
/// Length penalty for beam search
pub length_penalty: Option<f32>,
/// Specific token IDs to use as stop conditions
pub stop_token_ids: Option<Vec<u32>>,
/// Include stop string in output
#[serde(default)]
pub include_stop... | fim | vllm-project/vllm | rust |
<|fim_suffix|>Qwen1.5-0.5B-Chat"])
)
.is_ok()
);
}
#[test]
fn validate_request_compat_rejects_unknown_model() {
let request = base_request();
assert!(validate_request_compat(&request, &served_names(&["other-model"])).is_err());
}
#[test]
fn valid... | fim | vllm-project/vllm | rust |
<|fim_prefix|>mod convert;
mod types;
mod validate;
use std::convert::Infallible;
use std::result::Result;
use std::sync::Arc;
use asynk_strim_attr::{TryYielder, try_stream};
use axum::Json;
use axum::extract::State;
use axum::http::HeaderMap;
use axum::response::sse::{Event, Sse};
use axum::response::{IntoResponse, ... | fim | vllm-project/vllm | rust |
<|fim_suffix|>ist_models;
<|fim_prefix|>pub mod chat_completions;
mod completions;
mod models;
pub(crate) mod utils;
pub use chat_completions::chat_complet<|fim_middle|>ions;
pub use completions::completions;
pub use models::l<|endoftext|> | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::sync::Arc;
use axum::Json;
use axum::extract::State;
use crate::routes::openai::utils::types::{ListModelsResponse, ModelObject};
use crate::state::AppState;
/// Return all configured served model names in OpenAI `list models` format.
pub async fn list_models(State(state): State<Arc<AppState>>)... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::collections::HashMap;
use itertools::Itertools as _;
use vllm_text::{
CollectedTextOutput, DecodedLogprobs, DecodedPositionLogprobs, DecodedPromptLogprobs,
DecodedTokenLogprob,
};
use super::types::{ChatLogProbs, ChatLogProbsContent, LogProbs, TopLogProb};
use crate::error::{ApiError, s... | fim | vllm-project/vllm | rust |
<|fim_suffix|>validated_json;
<|fim_prefix|>pub mod logprob<|fim_middle|>s;
pub mod structured_outputs;
pub mod token_ids;
pub mod types;
pub mod usage;
pub mod <|endoftext|> | fim | vllm-project/vllm | rust |
use serde::{Deserialize, Serialize};
use serde_json::Value;
use vllm_engine_core_client::protocol::StructuredOutputsParams;
use crate::error::ApiError;
/// JSON schema specification nested inside a `json_schema` response format.
///
/// Mirrors the Python vLLM `JsonSchemaResponseFormat` class.
#[serde_with::skip_seri... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::collections::HashMap;
use vllm_text::Prompt;
use crate::error::{ApiError, bail_invalid_request};
/// Reject token-id prompt entries at or above `bound` (the highest in-vocab id is
/// `bound - 1`).
pub(crate) fn validate_prompt_token_ids(prompt: &Prompt, bound: usize) -> Result<(), ApiError> {... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::collections::HashMap;
use std::slice;
use llm_multimodal::ImageDetail;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use vllm_llm::TokenUsage;
// ============================================================================
// Constants
// ==========================================... | fim | vllm-project/vllm | rust |
<|fim_suffix|>tokens;
}
/// Add newly decoded output tokens to the running completion count.
pub(crate) fn add_output_tokens(&mut self, output_tokens: usize) {
self.output_tokens = self.output_tokens.saturating_add(output_tokens);
}
/// Replace the running counts with the final counts repo... | fim | vllm-project/vllm | rust |
<|fim_prefix|>//! Validated JSON extractor for automatic request validation.
//! Variation of https://github.com/lightseekorg/smg/blob/main/crates/protocols/src/validated.rs
use axum::Json;
use axum::extract::rejection::JsonRejection;
use axum::extract::{FromRequest, <|fim_suffix|>impl<T> std::ops::DerefMut for Valida... | fim | vllm-project/vllm | rust |
<|fim_suffix|>paused = state
.engine_core_client()
.is_scheduler_paused()
.await
.map_err(|error| utility_call_error("is_paused", error))?;
Ok(Json(IsPausedResponse { is_paused }))
}
<|fim_prefix|>use std::sync::Arc;
use axum::Json;
use axum::extract::rejection::QueryRejection;
use... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::sync::Arc;
use axum::Json;
use axum::extract::{Query, State};
use axum::http::StatusCode;
use axum::response::{IntoResponse, Response};
use serde::Deserialize;
use crate::server_info::ServerInfoConfigFormat;
use crate::state::AppState;
#[derive(Debug, Clone, Copy, Deserialize)]
#[serde(rename_... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::sync::Arc;
use axum::Json;
use axu<|fim_suffix|>y(params): Query<WakeUpParams>,
) -> Result<StatusCode, ApiError> {
state
.engine_core_client()
.wake_up(params.tags)
.await
.map_err(|error| utility_call_error("wake_up", error))?;
Ok(StatusCode::OK)
}
///... | fim | vllm-project/vllm | rust |
<|fim_suffix|>truct DetokenizeResponse {
pub prompt: String,
}
// ---- trait impls required by ValidatedJson ----
impl Validate for TokenizeRequest {
fn validate(&self) -> Result<(), ValidationErrors> {
if let Self::Chat(req) = self {
req.validate()?;
}
Ok(())
}
}
impl V... | fim | vllm-project/vllm | rust |
//! `POST /tokenize` and `POST /detokenize` (root paths, matching Python).
//!
//! Encode/decode runs entirely in-process via [`DynTokenizer`]; the inference
//! engine is not involved.
mod types;
use std::sync::Arc;
use axum::Json;
use axum::extract::State;
use axum::http::HeaderMap;
use axum::response::{IntoRespon... | fim | vllm-project/vllm | rust |
<|fim_suffix|>ponse> {
let version = state.engine_core_client().vllm_version().to_string();
Json(VersionResponse {
version,
rust_frontend_version: env!("CARGO_PKG_VERSION"),
})
}
<|fim_prefix|>use std::sync::Arc;
use axum::Json;
use axum::<|fim_middle|>extract::State;
use serde::Serialize;... | fim | vllm-project/vllm | rust |
<|fim_prefix|>mod cache;
mod collective_rpc;
mod health;
mod inference;
mod load;
mod lora;
mod metrics;
pub(crate) mod openai;
mod pause;
mod server_info;
mod sleep;
mod tokenize;
mod version;
use std::sync::Arc;
use axum::Router;
use axum::middleware::{from_fn, from_fn_with_state};
use axum::routing::{get, post};
u... | fim | vllm-project/vllm | rust |
<|fim_suffix|> assert!(is_public_vllm_env_key("VLLM_USE_MODELSCOPE"));
assert!(!is_public_vllm_env_key("OTHER_ENV"));
}
}
<|fim_prefix|>use std::collections::BTreeMap;
use serde_json::{Value, json};
use crate::config::Config;
const SENSITIVE_VLLM_ENV_PATTERNS: &[&str] =
&["KEY", "SECRET", "TOKE... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::sync::Arc;
use std::sync::atomic::{AtomicU64, Ordering};
use serde_json::Value;
use sha2::{Digest, Sha256};
use tokio::time::{Duration, Instant, sleep_until};
use tracing::warn;
use vllm_chat::ChatLlm;
use vllm_engine_core_client::EngineCoreClient;
use vllm_engine_core_client::protocol::lora::Lo... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};
use axum::http::HeaderMap;
use serde_json::Value;
use thiserror_ext::AsReport;
use uuid::Uuid;
use crate::error::ApiError;
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct ResolvedRequestContext {
pub request_id: Stri... | fim | vllm-project/vllm | rust |
<|fim_suffix|>r::ModelConfig;
#[test]
fn model_config_detects_moe_from_named_expert_fields() {
let field_names = [
"num_experts",
"moe_num_experts",
"n_routed_experts",
"num_local_experts",
];
for field_name in field_names {
l... | fim | vllm-project/vllm | rust |
<|fim_suffix|>lf) -> DynTokenizer {
self.tokenizer.clone()
}
fn is_moe(&self) -> bool {
self.model_config.is_moe()
}
fn model_vocab_size(&self) -> Option<usize> {
self.model_config.vocab_size().map(|v| v as usize)
}
fn model_id(&self) -> &str {
&self.model_id
... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::path::{Path, PathBuf};
use hf_hub::Cache;
use hf_hub::api::tokio::{Api, ApiBuilder, ApiRepo};
use thiserror_ext::AsReport as _;
use super::config::{HfTokenizerConfig, load_tokenizer_config};
use crate::error::{Error, Result};
const HF_TOKEN_ENV: &str = "HF_TOKEN";
/// The tokenizer source sel... | fim | vllm-project/vllm | rust |
<|fim_suffix|>s.
fn tokenizer_vocab_size(&self) -> usize {
self.tokenizer().vocab_size()
}
}
/// Shared trait-object form of [`TextBackend`].
pub type DynTextBackend = Arc<dyn TextBackend>;
<|fim_prefix|>pub mod hf;
use std::sync::Arc;
use vllm_tokenizer::DynTokenizer;
use crate::error::Result;
///... | fim | vllm-project/vllm | rust |
<|fim_suffix|>neCoreError),
}
pub type Result<T> = std::result::Result<T, Error>;
impl From<vllm_tokenizer::TokenizerError> for Error {
fn from(error: vllm_tokenizer::TokenizerError) -> Self {
Self::Tokenizer(error.0)
}
}
<|fim_prefix|>use thiserror::Error;
use vllm_engine_core_client::Error as Engine... | fim | vllm-project/vllm | rust |
<|fim_prefix|>//! Shared text-generation support used by chat and future raw completions.
//!
//! This crate intentionally stays bel<|fim_suffix|>and tokenizer overhead entirely.
Prompt::TokenIds(token_ids) => token_ids,
};
let mut sampling_hints = self.backend.sampling_hints()?;
sa... | fim | vllm-project/vllm | rust |
<|fim_suffix|>max_tokens = match max_model_len {
Some(max_model_len) if prompt_len >= max_model_len => {
return Err(Error::PromptTooLong {
max_model_len,
prompt_len,
});
}
Some(max_model_len) => Some(max_model_len - prompt_len),
Non... | fim | vllm-project/vllm | rust |
<|fim_suffix|>
}
#[test]
fn stop_string_not_in_new_bytes_region() {
let stops = vec!["say".to_string()];
// "say" is in the output but before the new byte region.
// new_bytes=1 means only 'r' was added; "say" ended at byte 3,
// but the search window starts at next_off - st... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use itertools::Itertools as _;
use serde::{Deserialize, Serialize};
use vllm_llm::{Logprobs, PositionLogprobs};
use vllm_tokenizer::Tokenizer;
use crate::error::Error;
/// One decoded token candidate and its logprob metadata.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DecodedT... | fim | vllm-project/vllm | rust |
<|fim_prefix|>//! Output processing helpers shared by text and chat layers.
pub use decoded::{DecodedTextEvent, Finished, TextDecodeOptions, decoded_text_event_stream};
pub use logprobs::{
DecodedLogprobs, DecodedPositionLogprobs, DecodedPromptLogprobs, DecodedTokenLogprob,
};
mod decoded;
mod logprobs;
use std:... | fim | vllm-project/vllm | rust |
<|fim_suffix|>rde(default)]
pub lora_request: Option<LoraRequest>,
}
impl TextRequest {
/// Return one minimal valid request fixture for tests.
pub fn for_test() -> Self {
Self {
request_id: "test-request".to_string(),
prompt: Prompt::Text("test".to_string()),
mm... | fim | vllm-project/vllm | rust |
<|fim_suffix|>okenizer");
let text = SAMPLE_TEXT.repeat(32);
let hf_token_ids =
hf.encode(text.as_str(), false).expect("encode sample text with hf tokenizer");
let fastokens_token_ids = fastokens
.encode(text.as_str(), false)
.expect("encode sample text with ... | fim | vllm-project/vllm | rust |
<|fim_suffix|> tiktoken_rs_token_ids);
let riptoken_decoded = riptoken
.decode(riptoken_token_ids.as_slice(), false)
.expect("decode sample token ids with riptoken");
let tiktoken_rs_decoded = tiktoken_rs
.decode(riptoken_token_ids.as_slice(), false)
.exp... | fim | vllm-project/vllm | rust |
//! Fast GPT-2 byte-level detokenization that writes into a single `Vec<u8>`,
//! avoiding the `Vec<String>` / `String::join` assembly in fastokens' generic
//! `Decoder::decode` pipeline.
/// Reverse GPT-2 byte-to-unicode mapping: codepoint → original byte. The GPT-2
/// table only emits codepoints in U+0000..U+0143,... | fim | vllm-project/vllm | rust |
<|fim_suffix|>0}")]
pub struct TokenizerError(#[message] pub String);
<|fim_prefix|>use thiserror::Error;
use thiserror_ext::Macro;
pub type Result<<|fim_middle|>T> = std::result::Result<T, TokenizerError>;
#[derive(Debug, Error, Macro)]
#[thiserror_ext(macro(path = "crate::error"))]
#[error("tokenizer error: {<|endo... | fim | vllm-project/vllm | rust |
<|fim_suffix|>lt)]
rstrip: bool,
#[serde(default)]
normalized: bool,
#[serde(default)]
special: bool,
}
impl AddedTokenConfig {
/// Return this added-token payload in `tokenizer.json` shape by filling the
/// numeric token id that came from `added_tokens_decoder`'s string key.
fn with_i... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::path::Path;
use std::sync::Arc;
use fastokens::Tokenizer as FastokensTokenizer;
use fastokens::decoders::Decoder as FastokensDecoder;
use thiserror_ext::AsReport as _;
use tokenizers::Tokenizer as HfTokenizer;
use tracing::{info, warn};
use crate::byte_level_decode::decode_byte_level;
use crate... | fim | vllm-project/vllm | rust |
<|fim_suffix|> -> Result<(Option<String>, String)> {
if !self.ids.is_empty() {
let string = self.tokenizer.decode(&self.ids, self.skip_special_tokens)?;
let prefix_len = self.prefix.len();
self.ids.clear();
self.prefix.clear();
self.prefix_index = 0;
... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::sync::Arc;
use crate::incremental::DecodeStream;
mod byte_level_decode;
#[macro_use]
mod error;
mod hf;
mod incremental;
mod tekken;
mod tiktoken;
pub use error::{Result, TokenizerError};
pub use hf::HuggingFaceTokenizer;
pub use incremental::IncrementalDecoder;
pub use tekken::TekkenTokenizer... | fim | vllm-project/vllm | rust |
<|fim_suffix|>de(token, false, false).ok()?;
if ids.len() == 1 { Some(ids[0]) } else { None }
})
}
fn id_to_token(&self, id: u32) -> Option<String> {
self.inner.id_to_piece(id).ok()
}
fn vocab_size(&self) -> usize {
self.inner.vocab_size()
}
fn is_special_i... | fim | vllm-project/vllm | rust |
<|fim_suffix|>e },
"258": { "content": "</think>", "special": false }
}
}"#,
)
.expect("write tokenizer_config.json");
fs::write(dir.path().join("config.json"), r#"{"vocab_size": 259}"#)
.expect("write config.json");
for backen... | fim | vllm-project/vllm | rust |
use std::time::Duration;
use criterion::{BatchSize, Criterion, Throughput, black_box, criterion_group, criterion_main};
use tool_parser::parsers::DeepSeekParser as ExternalDeepSeekParser;
use vllm_tool_parser::test_utils::{split_by_chars, test_tools};
use vllm_tool_parser::{DeepSeekV3ToolParser, Tool, ToolParser};
mo... | fim | vllm-project/vllm | rust |
<|fim_suffix|>nal_create_parser", |b| {
b.iter_batched(
ExternalDeepSeek31Parser::new,
|mut parser| {
let result = feed_external_parser(&mut parser, &openai_tools, black_box(&chunks));
black_box(result);
},
BatchSize::SmallInput,
... | fim | vllm-project/vllm | rust |
<|fim_suffix|>riterion) {
let tools = test_tools();
let mixed_text = mixed_fixture();
let long_normal_text = long_normal_text_fixture();
run_stream_group(
c,
"deepseek_v32/mixed_text_tool_call",
&tools,
&mixed_text,
CHUNK_CHARS,
"I will check two cities b... | fim | vllm-project/vllm | rust |
<|fim_suffix|>lt);
},
BatchSize::SmallInput,
)
});
group.finish();
}
fn bench_gemma4(c: &mut Criterion) {
let tools = test_tools();
let mixed_text = mixed_fixture();
let long_tool_argument = long_tool_argument_fixture();
let long_normal_text = long_normal_text_f... | fim | vllm-project/vllm | rust |
use std::time::Duration;
use criterion::{BatchSize, Criterion, Throughput, black_box, criterion_group, criterion_main};
use tool_parser::parsers::Glm4MoeParser as ExternalGlm4MoeParser;
use vllm_tool_parser::test_utils::{split_by_chars, test_tools};
use vllm_tool_parser::{Glm45MoeToolParser, Glm47MoeToolParser, Tool, ... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::time::Duration;
use criterion:<|fim_suffix|>ools = test_tools();
let mixed_text = mixed_fixture();
let mixed_chunks = mixed_chunks();
let long_normal_text = long_normal_text_fixture();
let long_normal_chunks = split_by_chars(&long_normal_text, CHUNK_CHARS);
run_stream_group(... | fim | vllm-project/vllm | rust |
<|fim_suffix|> &tools,
&long_normal_text,
CHUNK_CHARS,
&long_normal_text,
0,
);
}
criterion_group!(benches, bench_llama3_json);
criterion_main!(benches);
<|fim_prefix|>use std::time::Duration;
use criterion::{BatchSize, Criterion, Throughput, black_box, criterion_group, crit... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::time::Duration;
use criterion::{BatchSize, Criterion, Throughput, black_box, criterion_group, criterion_main};
use tool_parser::parsers::MinimaxM2Parser as ExternalMinimaxM2Parser;
use vllm_tool_parser::test_utils::{split_by_chars, test_tools};
use vllm_tool_parser::{MinimaxM2ToolParser, Tool, T... | fim | vllm-project/vllm | rust |
<|fim_suffix|>e answering.\n",
2,
);
run_stream_group(
c,
"qwen3_coder/long_normal_text",
&tools,
&long_normal_text,
CHUNK_CHARS,
&long_normal_text,
0,
);
}
criterion_group!(benches, bench_qwen3_coder);
criterion_main!(benches);
<|fim_prefix|... | fim | vllm-project/vllm | rust |
<|fim_suffix|>},
BatchSize::SmallInput,
)
});
group.finish();
}
fn bench_qwen3_xml(c: &mut Criterion) {
let tools = test_tools();
let mixed_text = mixed_fixture();
let long_normal_text = long_normal_text_fixture();
run_stream_group(
c,
"qwen3_xml/mixed_text... | fim | vllm-project/vllm | rust |
<|fim_prefix|>#![allow(dead_code)]
use futures::FutureExt as _;
use openai_protocol::common::{Funct<|fim_suffix|>for chunk in chunks {
let delta = parser
.parse_incremental(chunk, tools)
.now_or_never()
.expect("external parser should not suspend")
.expect("chunk... | fim | vllm-project/vllm | rust |
<|fim_prefix|>//! Thin PyO3 bindings for `vllm_tool_parser`.
//!
//! This crate exposes the Rust tool parser trait and data shapes to Python
//! while keeping parser state, grammar, and schema-aware argument conversion in
//! Rust. Python callers should use this module as a typed bridge and keep any
//! vLLM protocol a... | fim | vllm-project/vllm | rust |
<|fim_suffix|>.unwrap_err();
assert!(error.to_report_string().contains("incomplete DeepSeek DSML tool call"));
}
#[test]
fn deepseek_v32_streaming_drops_eos_after_complete_tool_calls() {
let mut parser = DeepSeekV32ToolParser::new(&test_tools());
let output = collect_stream(
... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use super::{DeepSeekDsmlToolParser, DsmlTokens};
use crate::{Result, Tool, ToolParser, ToolParserOutput};
/// Tool parser for DeepSeek V4 models.
///
/// Example tool call content:
///
/// ```text
/// <｜DSML｜tool_calls>
/// <｜DSML｜invoke name="get_weather">
/// <｜DSML｜parameter name="location" string="tr... | fim | vllm-project/vllm | rust |
<|fim_suffix|> delimited("name=\"", take_until(1.., "\""), "\"").parse_next(input)
}
<|fim_prefix|>use winnow::ascii::{multispace0 as ws0, multispace1 as ws1};
use winnow::combinator::{alt, delimited, eof, repeat, seq, terminated};
use winnow::prelude::*;
use winnow::stream::Partial;
use winnow::token::{literal, rest... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use super::{DeepSeekJsonFormat, DeepSeekJsonToolParser};
use crate::{Result, Tool, ToolParser, ToolParserOutput};
/// Tool parser for DeepSeek V3 JSON-fenced tool calls.
///
/// Example tool call content:
///
/// ````text
/// <｜tool▁calls▁begin｜><｜tool▁call▁begin｜>function<｜tool▁sep｜>get_weather
/// ```j... | fim | vllm-project/vllm | rust |
use super::{DeepSeekJsonFormat, DeepSeekJsonToolParser};
use crate::{Result, Tool, ToolParser, ToolParserOutput};
/// Tool parser for DeepSeek V3.1 raw JSON tool calls.
///
/// Example tool call content:
///
/// ```text
/// <｜tool▁calls▁begin｜><｜tool▁call▁begin｜>get_weather<｜tool▁sep｜>{"location":"Tokyo"}<｜tool▁call▁e... | fim | vllm-project/vllm | rust |
<|fim_prefix|>mod deepseek_v3;
mod deepseek_v31;
pub use deepseek_v3::DeepSeekV3ToolParser;
pub use deepseek_v31::DeepSeekV31ToolParser;
use winnow::ascii::multispace0 as ws0;
use winnow::combinator::{alt, seq};
use winnow::prelude::*;
use winnow::stream::Partial;
use winnow::token::{literal, rest, take_until};
use s... | fim | vllm-project/vllm | rust |
<|fim_suffix|>(Debug, Error, Macro)]
#[thiserror_ext(macro(path = "crate::error"))]
pub enum ToolParserError {
#[error("tool parser parsing failed: {message}")]
ParsingFailed { message: String },
}
<|fim_prefix|>use thiserror::Error;
use thiserror_ext::Macro;
/// Result alias for tool parser operations.
pub ty... | fim | vllm-project/vllm | rust |
<|fim_suffix|>ING_DELIM),
take_until(0.., STRING_DELIM),
literal(STRING_DELIM),
)
.parse_next(input)
}
/// Parse a nested Gemma4 object.
fn gemma4_object(input: &mut &str) -> ModalResult<Map<String, Value>> {
delimited(literal("{"), gemma4_args, literal("}")).parse_next(input)
}
/// Parse ... | fim | vllm-project/vllm | rust |
<|fim_suffix|> self.0.finish()
}
fn reset(&mut self) -> String {
self.0.reset()
}
}
<|fim_prefix|>use super::{GlmXmlToolParser, Separator};
use crate::{Result, Tool, ToolParser, ToolParserOutput};
/// Tool parser for GLM-4.5/4.6 MoE XML-style tool calls.
///
/// Example tool call content:
///
/// ... | fim | vllm-project/vllm | rust |
use super::{GlmXmlToolParser, Separator};
use crate::{Result, Tool, ToolParser, ToolParserOutput};
/// Tool parser for GLM-4.7 MoE XML-style tool calls.
///
/// GLM-4.7 reuses the GLM-4.5 parser with a more flexible function-name
/// separator, so the name may be followed by whitespace, a newline, or the
/// first `<a... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use winnow::ascii::multispace0 as ws0;
use winnow::combinator::{alt, eof, repeat, seq, terminated};
use winnow::prelude::*;
use winnow::stream::Partial;
use winnow::token::{literal, rest, take_until, take_while};
use super::parameters::ToolSchemas;
use super::utils::{parse_buffered_event, safe_text_len};... | fim | vllm-project/vllm | rust |
use winnow::ascii::multispace0 as ws0;
use winnow::combinator::{alt, delimited, eof, repeat, seq, terminated};
use winnow::prelude::*;
use winnow::stream::Partial;
use winnow::token::{literal, rest, take_until};
use super::parameters::ToolSchemas;
use super::utils::{parse_buffered_event, safe_text_len};
use super::{Re... | fim | vllm-project/vllm | rust |
<|fim_suffix|>? I'm a helpful assistant.",
);
let chunks = split_by_chars(input, 3);
let mut parser = Granite4ToolParser::new(&test_tools());
let output = collect_stream(&mut parser, &chunks);
expect![[r#"
ToolParserOutput {
normal_text: "Here goes t... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use super::{JsonToolCallConfig, JsonToolCallParser, JsonToolCallWhitespace};
use crate::{Result, Tool, ToolParser, ToolParserOu<|fim_suffix|>am(&mut parser, &chunks);
assert_eq!(output.normal_text, "hello ");
assert_eq!(output.calls.len(), 1);
assert_eq!(output.calls[0].arguments,... | fim | vllm-project/vllm | rust |
use super::{JsonToolCallConfig, JsonToolCallParser, JsonToolCallWhitespace};
use crate::{Result, Tool, ToolParser, ToolParserOutput};
const INTERNLM2_CONFIG: JsonToolCallConfig = JsonToolCallConfig {
parser_name: "InternLM2",
start_marker: "<|action_start|><|plugin|>",
end_marker: "<|action_end|>",
mar... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use winnow::ascii::multispace0 as ws0;
use winnow::combinator::seq;
use winnow::error::{ModalResult, StrContext};
use winnow::prelude::*;
use winnow::token::literal;
use super::{
JsonToolCallConfig, JsonToolCallEvent, JsonToolCallWhitespace, JsonToolInput,
argument_delta_event, tool_call_header_e... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use super::{JsonToolCallConfig, JsonToolCallParser, JsonToolCallWhitespace};
use crate::{Result, Tool, ToolParser, ToolParserOutput};
const MISTRAL_CONFIG: JsonToolCallConfig = JsonToolCallConfig {
parser_name: "Mistral",
start_marker: "[TOOL_CALLS] [",
end_marker: "]",
marker_whitespace:... | fim | vllm-project/vllm | rust |
<|fim_prefix|>//! Shared parser core for JSON tool calls wrapped by text markers.
pub use granite4::Granite4ToolParser;
pub use hermes::HermesToolParser;
pub use internlm2::Internlm2ToolParser;
pub use llama::Llama3JsonToolParser;
pub use mistral::MistralToolParser;
pub use phi4mini::Phi4MiniJsonToolParser;
pub use qw... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use super::{JsonToolCallConfig, JsonToolCallParser, JsonToolCallWhitespace};
use crate::{Result, Tool, ToolParser, ToolParserOutput};
const PHI4MINI_CONFIG: JsonToolCallConfig = JsonToolCallConfig {
parser_name: "Phi4Mini",
start_marker: "functools[",
end_marker: "]",
marker_whitespace: J... | fim | vllm-project/vllm | rust |
<|fim_suffix|>tool parser parsing failed: incomplete Qwen XML tool call"]
.assert_eq(&error.to_report_string());
}
#[test]
fn qwen_xml_malformed_field_order_fails_fast() {
let mut parser = Qwen3XmlToolParser::new(&test_tools());
let error = parser
.parse_chunk(
... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::collections::BTreeMap;
use winnow::ascii::{digit1, multispace0 as ws0};
use winnow::combinator::{alt, eof, repeat, seq};
use winnow::prelude::*;
use winnow::stream::Partial;
use winnow::token::{literal, rest, take_until, take_while};
use super::utils::{JsonObjectScanState, parse_buffered_event,... | fim | vllm-project/vllm | rust |
<|fim_prefix|>//! Streaming tool parsers for chat completions.
#[macro_use]
mod error;
mod deepseek_dsml;
mod deepseek_json;
mod gemma4;
mod glm_xml;
mod hy_v3;
mod json;
mod kimi_k2;
mod minimax_m2;
mod parameters;
mod qwen_coder;
#[cfg(any(test, feature = "test-util"))]
pub mod test_utils;
mod utils;
use std::colle... | fim | vllm-project/vllm | rust |
<|fim_suffix|>_call() {
let mut parser = MinimaxM2ToolParser::new(&test_tools());
let output =
parser.parse_chunk(r#"<minimax:tool_call><invoke name="get_weather">"#).unwrap();
assert!(output.normal_text.is_empty());
assert!(output.calls.is_empty());
}
#[test]
f... | fim | vllm-project/vllm | rust |
<|fim_suffix|> assert_eq!(params.convert("nothing", text("null")), json!(null));
}
#[test]
fn number_conversion_preserves_json_number_spelling_with_legacy_fallback() {
let params = ToolSchema::from_schema(&json!({
"type": "object",
"properties": {
"value": ... | fim | vllm-project/vllm | rust |
<|fim_suffix|>_in_parameter_value() {
let mut parser = Qwen3CoderToolParser::new(&test_tools());
let output = parser
.parse_complete(&build_tool_call(
"get_weather",
&[
(
"location",
"杭州 </... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use serde_json::json;
use super::{ToolParser, ToolParserOutput};
use crate::{Tool, ToolParserTestExt as _};
/// Build a reusable set of function tools for parser unit tests.
pub fn test_tools() -> Vec<Tool> {
vec![
Tool {
name: "get_weather".to_string(),
description: ... | fim | vllm-project/vllm | rust |
<|fim_suffix|> output.calls.extend([
ToolCallDelta {
tool_index: 0,
name: Some("weather".to_string()),
arguments: "{\"location\":".to_string(),
},
ToolCallDelta {
tool_index: 0,
... | fim | vllm-project/vllm | rust |
<|fim_prefix|>//! Shared helpers for tool parsers.
use winnow::error::{ContextError, ErrMode, ModalResult, Needed, StrContext, StrContextValue};
use winnow::stream::{Offset, Partial, Stream};
use super::Result;
/// Return the byte length of the longest proper prefix of `token` that is also
/// a suffix of `buffer`.
... | fim | vllm-project/vllm | rust |
<|fim_prefix|>#!/usr/bin/env python3
# SPDX-License-Identifier: Apache-2.0
# SPDX-FileCopyrightText: Co<|fim_suffix|> )
except (RuntimeError, ValueError, OSError) as e:
logger.exception(
"Failed to autotune config '%s': %s",
config_key,
... | fim | vllm-project/vllm | python |
<|fim_suffix|>ps")
fc_base_dir = os.environ.get("FETCHCONTENT_BASE_DIR", fc_base_dir)
cmake_args += ["-DFETCHCONTENT_BASE_DIR={}".format(fc_base_dir)]
#
# Setup parallelism and build tool
#
num_jobs, nvcc_threads = self.compute_num_jobs()
if nvcc_threads:
... | fim | vllm-project/vllm | python |
<|fim_prefix|># SPDX-License-Identifier: Apache-2.0
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
"""Compare the short outputs of HF and vLLM when using greedy sampling.
Run `pytest tests/basic_correctness/test_basic_correctness.py`.
"""
import os
import weakref
from unittest.mock import Mock
... | fim | vllm-project/vllm | python |
<|fim_suffix|>aph only works with UVA offloading
if disable_uva:
args.append("--enforce-eager")
compare_two_settings(
model="hmellor/tiny-random-LlamaForCausalLM",
arg1=[],
arg2=args,
env1=None,
env2=env_vars,
)
<|fim_prefix|># SPDX-License-Identifier: Apache... | fim | vllm-project/vllm | python |
<|fim_suffix|>re=0, max_tokens=10)
output = llm.generate(prompt, sampling_params)
# Put the engine to deep sleep
llm.sleep(level=2)
free_gpu_bytes_after_sleep, total = current_platform.mem_get_info()
used_bytes = total - free_gpu_bytes_after_sleep - used_bytes_baseline
assert used_bytes < 3 * ... | fim | vllm-project/vllm | python |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.