text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>use thiserror::Error as ThisError;
#[derive(Debug, ThisError)]
pub(crate) enum TemplateError {
#[error("failed to render jinja template")]
Jinja(#[from] minijinja::Error),
#[error("failed to read chat template file")]
ReadTemplateFile(#[source] std::io::Error),
#[error("chat template ... | fim | vllm-project/vllm | rust |
use std::collections::{HashSet, VecDeque};
use std::fmt;
use std::str::FromStr;
use minijinja::machinery::ast::{Expr, ForLoop, Set, Stmt};
use minijinja::machinery::{WhitespaceConfig, parse};
use minijinja::syntax::SyntaxConfig;
use serde_with::{DeserializeFromStr, SerializeDisplay};
/// Chat template content format.... | fim | vllm-project/vllm | rust |
<|fim_suffix|>port_string()))
})
.transpose()?;
let template = override_template
.as_ref()
.or(self.default_template.as_ref())
.ok_or(Error::MissingChatTemplate)?;
self.apply_chat_template_inner(template, request)
}
fn apply_chat_temp... | fim | vllm-project/vllm | rust |
<|fim_prefix|>//! Chat template support for tokenizers using Jinja2 templates.
//!
//! This module is inlined from SMG's tokenizer crate with local adaptations:
//! - thinking-related detection/state is removed
//! - special tokens are wired to `vllm_text::backends::hf::HfSpecialTokens`
use std::collec<|fim_suffix|> ... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use minijinja::value::{Kwargs, ViaDeserialize};
use minijinja::{Error as MinijinjaError, ErrorKind, Value};
use serde::Deserialize;
use serde_json::Value as JsonValue;
use serde_json_fmt::{JsonFormat, JsonSyntaxError};
use thiserror_ext::AsReport;
/// Hugging Face-compatible `tojson` filter for chat temp... | fim | vllm-project/vllm | rust |
<|fim_suffix|><Self>) -> Enumerator {
self.mapped_rev_enumerator(|this| {
Box::new(this.0.keys().map(|key| minijinja::Value::from(key.as_str())))
})
}
fn enumerator_len(self: &Arc<Self>) -> Option<usize> {
Some(self.0.len())
}
fn call_method(
self: &Arc<Self... | fim | vllm-project/vllm | rust |
<|fim_suffix|>llm-chat`.
pub trait ChatRenderer: Send + Sync {
/// Render one chat request into the text prompt submitted to the text
/// backend.
fn render(&self, request: &ChatRequest) -> Result<RenderedPrompt>;
}
/// Shared trait-object form of [`ChatRenderer`].
pub type DynChatRenderer = Arc<dyn ChatRe... | fim | vllm-project/vllm | rust |
<|fim_suffix|>:Display for RendererSelection {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Auto => f.write_str(Self::AUTO_LITERAL),
Self::Hf => f.write_str(Self::HF_LITERAL),
Self::DeepSeekV32 => f.write_str(Self::DEEPSEEK_V32_LITERAL),
... | fim | vllm-project/vllm | rust |
<|fim_suffix|>f::Developer { content, .. }
| Self::User { content }
| Self::ToolResponse { content, .. } => content.has_multimodal(),
Self::Assistant { .. } => false,
}
}
}
impl From<AssistantMessage> for ChatMessage {
fn from(value: AssistantMessage) -> Self {
... | fim | vllm-project/vllm | rust |
<|fim_suffix|> token: "p".to_string(),
logprob: -0.1,
rank: 1,
}],
}],
}),
}),
Ok(ChatEvent::LogprobsDelta {
... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::collections::BTreeSet;
use std::fmt;
use std::sync::Arc;
use std::time::Duration;
use futures::StreamExt as _;
use tokio::time::timeout;
use vllm_chat::{
AssistantBlockKind, AssistantContentBlock, AssistantMessageExt as _, ChatBackend, ChatEvent,
ChatLlm, ChatMessage, ChatRenderer, ChatR... | fim | vllm-project/vllm | rust |
<|fim_prefix|>//! Text-level roundtrip tests for the real chat-template and output-processor pairing.
//!
//! The invariant under test is that a structured assistant message rendered as history can be
//! parsed from the generated assistant completion and then rendered back to the exact same
//! assistant-completion te... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use expect_test::expect;
use vllm_engine_core_client::TransportMode;
use vllm_server::{Config, HttpListenerMode, ParserSelection, RendererSelection};
use super::{Cli, Command};
#[test]
fn serve_args_forward_python_flags_with_separator() {
let cli = Cli::try_parse_from([
"vllm-rs",
"s... | fim | vllm-project/vllm | rust |
<|fim_prefix|>#![allow(clippy::doc_lazy_continuation)]
use std::fmt::Display;
use std::str::FromStr;
use clap::Args;
use clap::builder::{TypedValueParser, ValueParserFactory};
use itertools::Itertools;
use serde::{Deserialize, Deserializer, Serialize};
/// Marker type for frontend-owned `serve` arguments that `vllm-... | fim | vllm-project/vllm | rust |
<|fim_prefix|>//! CLI argument definitions for the `vllm-rs` binary.
//!
//! Python vLLM references:
//! - Engine args: <https://github.com/vllm-project/vllm/blob/bc2c0c86efb28e77677a3cfb8687e976914a313a/vllm/engine/arg_utils.py#L657-L1311>
//! - Environment variables: <https://github.com/vllm-project/vllm/blob/bc2c0c8... | fim | vllm-project/vllm | rust |
use std::{env, fmt, process};
use time::UtcOffset;
use time::macros::format_description;
use tracing::level_filters::LevelFilter;
use tracing::{Event, Level, Subscriber};
use tracing_subscriber::Layer as _;
use tracing_subscriber::filter::Targets;
use tracing_subscriber::fmt::format::{FormatEvent, FormatFields, Writer... | fim | vllm-project/vllm | rust |
<|fim_prefix|>mod cli;
mod logging;
use std::env;
use std::process::ExitStatus;
use anyhow::{Context, Result, anyhow, bail};
use tokio_util::sync::CancellationToken;
use tracing::{info, warn};
use vllm_managed_engine::ManagedEngineHandle;
use crate::cli::{Cli, Command};
#[global_allocator]
static GLOBAL: mimalloc::... | fim | vllm-project/vllm | rust |
use std::time::Duration;
use anyhow::{Context, Result, bail};
use clap::Parser;
use futures::StreamExt as _;
use tokio::time::timeout;
use tracing_subscriber::EnvFilter;
use vllm_engine_core_client::protocol::{
EngineCoreFinishReason, EngineCoreRequest, EngineCoreSamplingParams,
};
use vllm_engine_core_client::{
... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::time::Duration;
use anyhow::{Context, Result, bail};
use clap::Parser;
use tracing_subscriber::EnvFilter;
use vllm_engine_core_client::protocol::utility::PauseMode;
use vllm_engine_core_client::{EngineCoreClient, EngineCoreClientConfig, TransportMode};
#[derive(Debug, Parser)]
#[command(about =... | fim | vllm-project/vllm | rust |
<|fim_suffix|>in by_engine {
if let Err(error) = inner.do_abort_requests(&engine_id, &request_ids).await {
warn!(
?engine_id,
?request_ids,
error = %error.as_report(),
"failed to auto-abort request streams"
... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::collections::{BTreeMap, BTreeSet, HashMap};
use std::sync::atomic::{AtomicU64, Ordering};
use tokio::sync::{mpsc, oneshot};
use tracing::trace;
use crate::EngineId;
use crate::client::stream::EngineCoreStreamOutput;
use crate::error::{Error, Result};
use crate::protocol::stats::SchedulerStats;
... | fim | vllm-project/vllm | rust |
use std::ops::Deref;
use std::pin::Pin;
use std::task::{Context, Poll};
use futures::Stream;
use futures::stream::FusedStream;
use thiserror_ext::AsReport as _;
use tokio::sync::mpsc;
use tracing::{debug, error, warn};
use crate::client::AbortRequest;
use crate::client::state::OutputReceiver;
use crate::protocol::{En... | fim | vllm-project/vllm | rust |
<|fim_suffix|>nner.send_to_engine(engine_id, EngineCoreRequestType::Utility, request)
});
if let Err(err) = try_join_all(send_futures).await {
self.inner.unregister_utility_calls(pending_calls.iter().map(|(id, _)| *id));
return Err(err);
}
// Phase 3: wait for al... | fim | vllm-project/vllm | rust |
<|fim_suffix|>nput_socket: &mut XPubSocket) -> Result<()> {
input_socket.send(ZmqMessage::from(Bytes::from_static(b"READY"))).await?;
Ok(())
}
<|fim_prefix|>use std::time::Duration;
use bytes::Bytes;
use zeromq::prelude::{Socket, SocketRecv, SocketSend};
use zeromq::{PullSocket, XPubSocket, ZmqMessage};
use c... | fim | vllm-project/vllm | rust |
<|fim_suffix|> Deserialize_tuple)]
struct CoordinatorWakeupMessage {
/// Engine index that already has the triggering request and should be
/// excluded from the coordinator's `START_DP_WAVE` rebroadcast.
exclude_engine_index: u32,
/// DP wave number observed by the frontend when the request was admitte... | fim | vllm-project/vllm | rust |
use std::sync::Arc;
use parking_lot::Mutex;
use tokio::sync::mpsc;
use zeromq::prelude::Socket;
use zeromq::{XPubSocket, XSubSocket};
use crate::coordinator::external::ExternalCoordinatorService;
use crate::coordinator::inproc::InProcCoordinatorRunner;
use crate::error::{Error, Result, bail_control_closed};
use crate... | fim | vllm-project/vllm | rust |
<|fim_suffix|> }
Ok(())
}
/// Apply one engine-originated control output to the coordinator state
/// machine.
async fn handle_outputs(&mut self, outputs: EngineCoreOutputs) -> Result<()> {
match outputs.classify() {
ClassifiedEngineCoreOutputs::RequestBatch(batch)
... | fim | vllm-project/vllm | rust |
<|fim_suffix|>atorHandle;
<|fim_prefix|>mod bootstrap;
mod external;
mod handle;
mod inproc;
pub(crate) use bootstrap::CoordinatorBootstrap;
pub(crate) use handle::Coo<|fim_middle|>rdin<|endoftext|> | fim | vllm-project/vllm | rust |
<|fim_suffix|>Id { engine_id: Vec<u8> },
#[error("unsupported auxiliary frame(s): expected 1 frame, got {frame_count}")]
UnsupportedAuxFrames { frame_count: usize },
#[error("external coordinator mode is not implemented yet")]
UnsupportedExternalCoordinator,
#[error("unsupported field `{field}` in {... | fim | vllm-project/vllm | rust |
<|fim_suffix|>ror, Result};
pub use transport::{ENGINE_CORE_DEAD_SENTINEL, EngineId};
#[cfg(test)]
mod tests;
<|fim_prefix|>mod client;
mod coordinator;
mod error;
mod metrics;
pub mod mock_engine;
pub mod protocol;
#[cfg(any(test, feature = "test-util"))]
pub mod test_utils;
mod transport;
pub use client::{
Abor... | fim | vllm-project/vllm | rust |
<|fim_suffix|>er, names(&[]), names(&[]));
expect![[""]].assert_eq(&lora_series(&metrics.render().unwrap()));
// Two running (sorted), one waiting.
exporter.update(&metrics.scheduler, names(&["b", "a"]), names(&["c"]));
expect![[
r#"vllm:lora_requests_info{running_lora_adapt... | fim | vllm-project/vllm | rust |
<|fim_suffix|>ets: Vec<MockEngineDataSockets>,
/// Optional coordinator sockets when the client enabled the in-process
/// coordinator.
pub coordinator: Option<MockCoordinatorSockets>,
}
/// Build a HELLO or READY handshake status payload.
fn ready_message(status: &str, config: &MockEngineConfig) -> ReadyM... | fim | vllm-project/vllm | rust |
<|fim_suffix|> num_nans_in_logits: 0,
},
],
scheduler_stats: None,
timestamp: 0.0,
finished_requests: Some(
{
"req-1",
},
... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use serde::{Deserialize, Serialize};
/// Effective model dtype reported by<|fim_suffix|>at16",
Self::BFloat16 => "bfloat16",
Self::Float32 => "float32",
}
}
}
#[cfg(test)]
mod tests {
use super::ModelDtype;
#[test]
fn serde_uses_protocol_dtype_strings() {... | fim | vllm-project/vllm | rust |
<|fim_suffix|> pub parallel_config: BTreeMap<String, OpaqueValue>,
}
<|fim_prefix|>use std::collections::BTreeMap;
use serde::{Deserialize, Serialize};
use crate::protocol::{ModelDtype, OpaqueValue};
/// Decoded engine startup-handshake payload sent on the handshake socket.
///
/// Original Python payload construc... | fim | vllm-project/vllm | rust |
<|fim_suffix|>b'|') => (Endianness::Native, &dtype[1..]),
_ => (Endianness::Native, dtype),
};
let scalar = match body {
"i4" | "int32" => ScalarType::I32,
"i8" | "int64" => ScalarType::I64,
"f4" | "float32" => ScalarType::F32,
_ => {
return Err(decode_error(... | fim | vllm-project/vllm | rust |
<|fim_suffix|>_tensors
.clone()
.unwrap()
.into_direct()
.unwrap();
assert_eq!(logprobs, expected_prompt_logprobs());
}
#[test]
fn decodes_big_endian_payloads() {
let frames = vec![Bytes::from(encode_value(&output_wire_with_custom_fields(
Some(Value::Array(vec![
... | fim | vllm-project/vllm | rust |
<|fim_suffix|> any other value.
#[serde(default)]
pub cu_num_generated_tokens: Option<Vec<usize>>,
}
<|fim_prefix|>use serde_tuple::{Deserialize_tuple<|fim_middle|>, Serialize_tuple};
use crate::protocol::tensor::WireNdArray;
/// Python wire representation of `LogprobsLists` / `LogprobsTensors` before
/// aux... | fim | vllm-project/vllm | rust |
<|fim_suffix|>ed_rank) in token_ids
.data
.chunks(token_ids.cols)
.zip(logprobs.data.chunks(logprobs.cols))
.zip(token_ranks)
{
positions.push(PositionLogprobs::from_decoded_row(
token_ids_row,
logprobs_row,
... | fim | vllm-project/vllm | rust |
<|fim_suffix|>LoraRequest {
pub lora_name: String,
pub lora_int_id: u64,
pub lora_path: String,
#[serde(default)]
pub base_model_name: Option<String>,
#[serde(default)]
pub tensorizer_config_dict: Option<OpaqueValue>,
#[serde(default)]
pub load_inplace: bool,
#[serde(default)]
... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::any::type_name;
use std::collections::{BTreeMap, BTreeSet, HashMap};
use std::io::Cursor;
use bytes::Bytes;
use rmpv::Value;
use serde::{Deserialize, Serialize};
use serde_default::DefaultFromSerde;
use serde_repr::{Deserialize_repr, Serialize_repr};
use serde_tuple::{Deserialize_tuple, Serializ... | fim | vllm-project/vllm | rust |
<|fim_suffix|> panic!("field kwargs should encode as map");
};
assert!(kwargs.iter().any(|(key, _)| key.as_str() == Some("slices")));
assert!(kwargs.iter().any(|(key, _)| key.as_str() == Some("dim")));
assert!(kwargs.iter().any(|(key, _)| key.as_str() == Some("keep_on_cpu")));
... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::collections::BTreeMap;
use serde::{Deserialize, Serialize};
use crate::protocol::OpaqueValue;
/// Stores cache hit statistics.
///
/// Original Python definition:
/// <https://github.com/vllm-project/vllm/blob/bc2c0c86efb28e77677a3cfb8687e976914a313a/vllm/v1/metrics/stats.py#L18-L32>
#[derive(... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use bytemuck::allocation::pod_collect_to_vec;
use enum_as_inner::EnumAsInner;
use half::{bf16, f16};
use rmpv::Value;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde_tuple::{Deserialize_tuple, Serialize_tuple};
/// Tensors and ndarrays are encoded with this extension type in Pyth... | fim | vllm-project/vllm | rust |
<|fim_suffix|> };
assert_eq!(array.len(), 4);
assert_eq!(array[0], Value::from(7));
assert_eq!(array[1], Value::from(42));
assert_eq!(array[2], Value::from("is_sleeping"));
assert_eq!(array[3], Value::Array(Vec::new()));
}
#[test]
fn pause_mode_serializes_as_pyth... | fim | vllm-project/vllm | rust |
<|fim_suffix|><Path>) -> String {
let path = self.dir.path().join(name);
format!("ipc://{}", path.to_string_lossy())
}
/// Endpoint used for the initial READY/HELLO handshake.
pub fn handshake_endpoint(&self) -> String {
self.endpoint("handshake.sock")
}
/// Endpoint used f... | fim | vllm-project/vllm | rust |
<|fim_suffix|>next())
.await
.unwrap()
.unwrap()
.unwrap_err();
assert!(is_unexpected_dispatcher_output(&error_2));
let error_1 = timeout(Duration::from_secs(1), stream_1.next())
.await
.unwrap()
.unwrap()
.unwrap_err();
assert!(is_unexpected_... | fim | vllm-project/vllm | rust |
<|fim_prefix|><|fim_suffix|>ent;
<|fim_middle|>mod cli<|endoftext|> | fim | vllm-project/vllm | rust |
<|fim_prefix|>#!/usr/bin/env -S uv run
# SPDX-License-Identifier: Apache-2.0
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
# /// script
# requires-python = ">=3.11"
# dependencies = [
# "msgspec>=0.19,<1",
# "msgpack>=1,<2",
# "numpy>=2,<3",
# ]
# ///
from enum import Enum, IntEnum
import... | fim | vllm-project/vllm | python |
<|fim_suffix|> the output loop to receive messages from the engine and send them to the
/// provided channel.
pub async fn run_output_loop(
mut output_socket: PullSocket,
tx: mpsc::Sender<Result<EngineCoreOutputs>>,
) {
loop {
let message = match output_socket.recv().await {
Ok(message) ... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::time::Duration;
use anyhow::{Context, Result, bail};
use clap::Parser;
use futures::StreamExt as _;
use tokio::time::timeout;
use tracing_subscriber::EnvFilter;
use vllm_engine_core_client::protocol::EngineCoreSamplingParams;
use vllm_engine_core_client::{EngineCoreClient, EngineCoreClientConfig... | fim | vllm-project/vllm | rust |
<|fim_suffix|>s { request_id: String },
#[error("engine-core error")]
EngineCoreClient(#[from] vllm_engine_core_client::Error),
}
<|fim_prefix|>use thiserror::Error;
pub type Result<T> = std::result::Result<T, Error>;
/// Public error type for the Rust `llm` facade.
#[de<|fim_middle|>rive(Debug, Error)]
pub e... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use tracing::Span;
use vllm_engine_core_client::EngineCoreClient;
mod error;
mod log_stats;
mod output;
mod request;
mod request_metrics;
pub use error::{Error, Result};
pub use output::{
CollectedGenerateOutput, FinishReason, GenerateOutput, GenerateOutputStream,
GenerateOutputStreamExt, Genera... | fim | vllm-project/vllm | rust |
<|fim_suffix|>cache_queries: 0,
prefix_cache_hits: 0,
};
for e in engines {
snap.prompt_tokens += e.prompt_tokens_computed.get();
snap.generation_tokens += e.generation_tokens.get();
snap.prefix_cache_queries += e.prefix_cache_queries.get();
snap.prefix_cache_hits += e.pr... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::future::Future;
use std::pin::Pin;
use std::sync::Arc;
use std::task::{Context, Poll, ready};
use enum_as_inner::EnumAsInner;
use futures::stream::FusedStream;
use futures::{Stream, StreamExt as _, pin_mut};
use serde::{Deserialize, Serialize};
use vllm_engine_core_client::protocol::logprobs::Lo... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::collections::BTreeMap;
use std::time::{SystemTime, UNIX_EPOCH};
use uuid::Uuid;
use vllm_engine_core_client::protocol::lora::LoraRequest;
use vllm_engine_core_client::protocol::multimodal::MmFeatures;
use vllm_engine_core_client::protocol::{EngineCoreRequest, EngineCoreSamplingParams};
use crat... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::time::{SystemTime, UNIX_EPOCH};
use vllm_engine_core_client::protocol::stats::PrefillStats;
use vllm_engine_core_client::protocol::{EngineCoreEvent, EngineCoreEventType, EngineCoreOutput};
use vllm_metrics::{
EngineLabels, FinishedReasonLabels, METRICS, PromptTokenSourceLabels, RequestMetric... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::collections::BTreeSet;
use std::sync::Once;
use std::time::Duration;
use futures::StreamExt as _;
use tokio::time::timeout;
use tracing_subscriber::EnvFilter;
use uuid::Uuid;
use vllm_engine_core_client::protocol::logprobs::{
Logprobs, MaybeWireLogprobs, PositionLogprobs, TokenLogprob,
};
us... | fim | vllm-project/vllm | rust |
<|fim_suffix|>&mut python_chunks,
std::mem::take(&mut current_chunk),
&long_flags,
&short_flags,
);
}
current_chunk.push(arg);
}
if !current_chunk.is_empty() {
push_chunk(
&mut frontend_chunks,
&mut pytho... | fim | vllm-project/vllm | rust |
pub mod cli;
mod process;
pub use process::{ManagedEngineConfig, ManagedEngineHandle, allocate_handshake_port};
<|endoftext|> | fim | vllm-project/vllm | rust |
<|fim_suffix|> pid,
?shutdown_timeout,
"shutting down managed engine with SIGTERM"
);
process_group::terminate(pid)?;
// Wait for the process to exit on its own.
if tokio::time::timeout(shutdown_timeout, self.wait_for_exit()).await.is_ok() {
r... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use prometheus_client::encoding::EncodeLabelSet;
use prometheus_client::metrics::family::Family;
use prometheus_client::metrics::histogram::Histogram;
use prometheus_client::registry::Registry;
use crate::U64Counter;
const HTTP_REQUEST_DURATION_BUCKETS: [f64; 3] = [0.1, 0.5, 1.0];
const HTTP_REQUEST_DUR... | fim | vllm-project/vllm | rust |
<|fim_suffix|>tatic METRICS: LazyLock<Metrics> = LazyLock::new(Metrics::new);
<|fim_prefix|>use std::fmt;
use std::sync::LazyLock;
use std::sync::atomic::AtomicU64;
use prometheus_client::encoding::text::encode;
use prometheus_client::metrics::counter::Counter;
use prometheus_client::metrics::family::Family;
use prome... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use prometheus_client::encoding::EncodeLabelSet;
use prometheus_client::metrics::family::Family;
use prometheus_client::metrics::histogram::Histogram;
use prometheus_client::registry::Registry;
use crate::{EngineLabels, HistogramFamily, U64Counter};
const TTFT_BUCKETS: [f64; 22] = [
0.001, 0.005, 0.... | fim | vllm-project/vllm | rust |
<|fim_suffix|> "vllm:estimated_read_bytes_per_gpu_total{model_name=\"model\",engine=\"0\"} 1"
));
assert!(rendered.contains(
"vllm:estimated_write_bytes_per_gpu_total{model_name=\"model\",engine=\"0\"} 1"
));
assert!(!rendered.contains("vllm:estimated_flops_per_gpu_total_to... | fim | vllm-project/vllm | rust |
<|fim_suffix|>arn!(
engine_index = self.engine_index,
request_id, "duplicate mock request id"
);
return Ok(vec![EngineOutput {
client_index,
outputs: empty_finish_outputs(
... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use anyhow::{Context as _, Result, anyhow, bail};
use futures::{Stream, StreamExt as _, stream};
use tokio::sync::mpsc;
use tokio_util::sync::CancellationToken;
use tracing::warn;
use vllm_engine_core_client::mock_engine::MockEngineDataSockets;
use vllm_engine_core_client::protocol::utility::EngineCoreUti... | fim | vllm-project/vllm | rust |
<|fim_suffix|>ne_loop.abort();
io_loop.await.ok();
engine_loop.await.ok();
}
result = &mut io_loop => {
error!(engine_index, "mock engine IO loop exited unexpectedly");
engine_loop.abort();
engine_loop.await.ok();
result??;
... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use anyhow::{Context, Result};
use clap::Parser as _;
use tokio_util::sync::CancellationToken;
use tracing::{Le<|fim_suffix|>ct("failed to install Ctrl-C signal handler");
info!("received shutdown signal (Ctrl-C), shutting down...");
shutdown.cancel();
});
token
}
fn main() -> Re... | fim | vllm-project/vllm | rust |
<|fim_suffix|>g,
engine_count: usize,
output_token_chunk_size: usize,
) -> (
EngineCoreClient,
CancellationToken,
tokio::task::JoinHandle<Result<()>>,
) {
let shutdown = CancellationToken::new();
let task = tokio::spawn(run(
Opt {
handshake_address: handshake_address.clon... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use vllm_tokenizer::DynTokenizer;
use super::{DelimitedReasoningParser, ReasoningDelta, ReasoningParser, Result};
/// Reasoning parser for Cohere Command models that use explicit START/END tags.
pub struct CohereCmdReasoningParser {
inner: DelimitedReasoningParser,
}
impl CohereCmdReasoningParser {... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use vllm_tokenizer::DynTokenizer;
use super::{DelimitedReasoningParser, ReasoningDelta, ReasoningParser, Result};
/// Reasoning parser for<|fim_suffix|> fn push(&mut self, delta: &str) -> Result<ReasoningDelta> {
Ok(self.inner.push(delta))
}
fn finish(&mut self) -> Result<ReasoningDelt... | fim | vllm-project/vllm | rust |
<|fim_suffix|>suffix that could still complete a
/// delimiter.
fn partial_suffix_len(&self, text: &str) -> usize {
let mut best = 0;
for idx in text.char_indices().map(|(idx, _)| idx).skip(1) {
let suffix = &text[idx..];
if self.start_token.starts_with(suffix) && self.st... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use vllm_tokenizer::DynTokenizer;
use super::{DelimitedReasoningParser, ReasoningDelta, ReasoningParser, Result};
const THOUGHT_PREFIX: &str = "thought\n";
/// Reasoning parser for Google Gemma4 thinking models.
///
/// Gemma4 emits reasoning inside `<|channel> ... <channel|>` spans and adds a
/// stru... | fim | vllm-project/vllm | rust |
<|fim_suffix|>r) -> Result<Box<dyn ReasoningParser>>
where
Self: Sized + 'static,
{
Ok(Box::new(Self::new(tokenizer)?))
}
fn initialize(&mut self, prompt_token_ids: &[u32]) -> Result<()> {
self.inner.initialize(prompt_token_ids);
Ok(())
}
fn push(&mut self, delt... | fim | vllm-project/vllm | rust |
<|fim_suffix|>ltas
/// arrive.
fn initialize(&mut self, _prompt_token_ids: &[u32]) -> Result<()> {
Ok(())
}
/// Return whether decoded output must preserve tokenizer special tokens.
///
/// Some model families emit reasoning sentinels as special tokens. Those
/// parsers need `skip_... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use vllm_tokenizer::DynTokenizer;
use super::{DelimitedReasoningParser, ReasoningDelta, ReasoningParser, Result};
/// Reasoning parser for the Qwen3/Qwen3.5 family.
///
/// This parser uses standard `<think>...</think>` delimit<|fim_suffix|> Create a Qwen3 parser backed by the shared delimited state mac... | fim | vllm-project/vllm | rust |
<|fim_suffix|>tr(&c);
}
}
assert_eq!(reasoning, "Some reasoning content");
assert_eq!(content, "Final answer");
}
#[test]
fn handles_partial_delimiters_across_pushes() {
let tokenizer = Arc::new(FakeTokenizer);
let mut parser = SeedOssReasoningParser::new... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use vllm_tokenizer::DynTokenizer;
use super::{DelimitedReasoningParser, ReasoningDelta, ReasoningParser, Result};
/// Reasoning parser for Step3p5 outputs.
///
/// Step3p5 uses standard `<think>`/`</think>` delimiters but emits a `\n`
/// immediately before and/or after `</think>`. The parser drops thes... | fim | vllm-project/vllm | rust |
use std::sync::Arc;
use vllm_tokenizer::Tokenizer;
use super::{
DeepSeekR1ReasoningParser, DelimitedReasoningParser, Qwen3ReasoningParser, ReasoningParser,
};
pub(crate) struct FakeTokenizer;
impl Tokenizer for FakeTokenizer {
fn encode(&self, text: &str, _add_special_tokens: bool) -> vllm_tokenizer::Result... | fim | vllm-project/vllm | rust |
<|fim_suffix|>be compatible with old compilers
.compile_protos(&[format!("{proto_dir}/vllm_grpc.proto")], &[proto_dir])?;
Ok(())
}
<|fim_prefix|>fn main() -> Result<(), Box<dyn std::error::Error>> {
let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").unwrap();
let proto_dir = format!("{manifest_... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::time::Duration;
use anyhow::{Context, Result, bail};
use async_openai::Client;
use async_openai::config::OpenAIConfig;
use async_openai::types::chat::{
ChatCompletionRequestUserMessageArgs, CreateChatCompletionRequest,
CreateChatCompletionRequestArgs,
};
use async_openai::types::models::... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::collections::HashMap;
use std::fmt;
use std::time::Duration;
use anyhow::Result;
use educe::Educe;
use serde::Serialize;
use serde_json::Value;
use vllm_chat::{ChatTemplateContentFormatOption, ParserSelection, RendererSelection};
use vllm_<|fim_suffix|> override, as a file path or inline
///... | fim | vllm-project/vllm | rust |
<|fim_suffix|>ram: None,
code: Some("server_error".to_string()),
},
Self::JsonParseError { message } => ErrorDetail {
message: message.clone(),
error_type: "invalid_request_error".to_string(),
param: None,
code: Some... | fim | vllm-project/vllm | rust |
<|fim_suffix|> Some(first) = pos.entries.first() {
logprobs.push(first.logprob);
ranks.push(first.rank);
}
// Extra candidates beyond the first.
let entries = pos.entries.iter().skip(1);
candidates.push(pb::CandidateTokenInfo {
tokens: entries
... | fim | vllm-project/vllm | rust |
<|fim_suffix|>onse_opts,
)),
}),
};
if tx.send(response).await.is_err() {
// Client disconnected.
break;
}
}
});
let response_stream = ReceiverStream::new(rx)... | fim | vllm-project/vllm | rust |
<|fim_suffix|>()
}),
..Default::default()
})
.await
.expect("generate with sampling params")
.into_inner();
// Verify the request was accepted and produced output.
let outputs = response.outputs.expect("outputs present");
assert_eq!(outputs.text, "hi"... | fim | vllm-project/vllm | rust |
<|fim_prefix|>//! Minimal OpenAI-compatible HTTP server above [`vllm_chat`].
mod config;
mod error;
mod grpc;
mod listener;
mod lora;
mod middleware;
mod routes;
mod server_info;
mod state;
mod utils;
use std::sync::{Arc, OnceLock};
use anyhow::{Context as _, Result};
use axum::Router;
use axum::serve::ListenerExt a... | fim | vllm-project/vllm | rust |
<|fim_suffix|>derive(Debug)]
pub enum Listener {
Tcp(TcpListener),
Unix(UnixListener),
}
impl Listener {
/// Bind or adopt the listener described by the frontend configuration.
///
/// For inherited sockets, the concrete listener kind is detected from the
/// socket family of the supplied file ... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::collections::BTreeMap;
use std::sync::atomic::{AtomicU64, Ordering};
use tokio::sync::{Mutex, RwLock};
use vllm_engine_core_client::EngineCoreClient;
use vllm_engine_core_client::protocol::lora::LoraRequest;
/// Snapshot of the currently served model names plus the requested LoRA, if
/// the mo... | fim | vllm-project/vllm | rust |
<|fim_suffix|>q;
use crate::state::hash_api_key;
#[test]
fn constant_time_eq_checks_sha256_digests() {
assert!(constant_time_eq(
&hash_api_key("secret"),
&hash_api_key("secret")
));
assert!(!constant_time_eq(
&hash_api_key("secret"),
&... | fim | vllm-project/vllm | rust |
<|fim_suffix|>sumed and dropped.
struct LoadTrackedBody {
inner: Body,
_guard: ServerLoadGuard,
}
// Simply delegate all `HttpBody` methods to the inner body.
impl HttpBody for LoadTrackedBody {
type Data = Bytes;
type Error = axum::Error;
fn poll_frame(
mut self: Pin<&mut Self>,
c... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use std::time::Instant;
use axum::extract::{MatchedPath, Request};
use axum::middleware::Next;
use axum::response::Response;
use vllm_metrics::{HttpHandlerLabels, HttpRequestLabels, METRICS};
/// Endpoints that will be excluded from HTTP metrics tracking.
///
/// Original Python definition:
/// <https:/... | fim | vllm-project/vllm | rust |
<|fim_prefix|>mod auth;
mod load;
mod metrics;
mod request_id;
pub use auth::authenticate_api_key;
pub use load::track_server_lo<|fim_suffix|>t_id_header;
<|fim_middle|>ad;
pub use metrics::track_http_metrics;
pub use request_id::set_reques<|endoftext|> | fim | vllm-project/vllm | rust |
<|fim_prefix|>use axum::extract::Request;
use axum::http::HeaderValue;
use axum::http::header::HeaderName;
use ax<|fim_suffix|>entrypoints.openai.server_utils.XRequestIdMiddleware`.
pub async fn set_request_id_header(req: Request, next: Next) -> Response {
let incoming = req.headers().get(&X_REQUEST_ID).cloned();
... | fim | vllm-project/vllm | rust |
use std::sync::Arc;
use axum::extract::{Query, State};
use axum::http::StatusCode;
use serde::Deserialize;
use crate::error::ApiError;
use crate::state::AppState;
use crate::utils::utility_call_error;
#[derive(Debug, Default, Deserialize)]
pub(crate) struct ResetPrefixCacheParams {
#[serde(default)]
reset_ru... | fim | vllm-project/vllm | rust |
<|fim_suffix|>dy) = body.map_err(|error| ApiError::json_parse_error(error.body_text()))?;
let method = body.method.ok_or_else(|| {
ApiError::invalid_request(
"Missing 'method' in request body".to_string(),
Some("method"),
)
})?;
let results = state
.engine_co... | fim | vllm-project/vllm | rust |
<|fim_suffix|>::OK
} else {
StatusCode::SERVICE_UNAVAILABLE
}
}
<|fim_prefix|>use std::sync<|fim_middle|>::Arc;
use axum::extract::State;
use axum::http::StatusCode;
use crate::state::AppState;
pub async fn health(State(state): State<Arc<AppState>>) -> StatusCode {
if state.chat.engine_core_clien... | fim | vllm-project/vllm | rust |
<|fim_suffix|> ChatBackend, ChatLlm, ChatRenderer, ChatRequest, ChatTextBackend, DefaultChatOutputProcessor,
DynChatOutputProcessor, DynChatRenderer, NewChatOutputProcessorOptions, RenderedPrompt,
};
use vllm_engine_core_client::protocol::{
EngineCoreFinishReason, EngineCoreOutput, EngineCoreOutputs, EngineCore... | fim | vllm-project/vllm | rust |
<|fim_prefix|>use vllm_text::{Prompt, TextDecodeOptions, TextRequest};
use super::types::GenerateRequest;
use super::validate;
use crate::error::ApiError;
use crate::lora::LoraModelResolution;
use crate::utils::{ResolvedRequestContext, merge_kv_transfer_params};
/// Lowered generate request plus the response request ... | fim | vllm-project/vllm | rust |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.