Switchyard lets LLM applications route traffic across models and providers while preserving native OpenAI and Anthropic API compatibility - enabling flexible model selection, benchmarking, and cost/performance optimization.
Rust
refactor(intake): remove legacy sink pipeline (#238)
nachiketb-nvidia3b9fbd5d9b2c
diff --git a/AGENTS.md b/AGENTS.mdindex 3408ad17b..3a542c3d1 100644--- a/AGENTS.md+++ b/AGENTS.md@@ -191,11 +191,7 @@ switchyard/│ │ ├── format_translate.py│ │ ├── random_routing_request_processor.py│ │ ├── stats_request_processor.py-│ │ ├── stats_response_processor_accumulator.py-│ │ ├── intake_request_processor.py-│ │ ├── intake_response_processor.py-│ │ ├── intake_payload_builder.py-│ │ └── intake_client.py+│ │ └── stats_response_processor_accumulator.py│ ├── endpoints/ # FastAPI endpoint wrappers (require `nemo-switchyard[server]`)│ │ ├── openai_chat_endpoint.py # OpenAIChatEndpoint│ │ ├── anthropic_messages_endpoint.py # AnthropicMessagesEndpoint@@ -203,8 +199,6 @@ switchyard/│ │ ├── stats_endpoint.py # StatsEndpoint│ │ ├── sse_helpers.py│ │ └── base.py-│ └── config/-│ └── intake_sink_config.py├── cli/ # CLI (requires `nemo-switchyard[cli]`)│ ├── switchyard_cli.py # `switchyard` entry point│ ├── launch_command.py # `switchyard launch`@@ -325,7 +319,6 @@ uvicorn.run(build_switchyard_app(switchyard), port=4000)| `ANTHROPIC_API_KEY` | API key for Anthropic Claude || `NVIDIA_API_KEY` | API key for NVIDIA NIM / Inference Hub || `OPENROUTER_API_KEY` | OpenRouter key used by the packaged launcher deployment |-| `SWITCHYARD_INTAKE_CAPTURE_CONTENT` | Set truthy to include prompt/response text in intake; default off (metadata-only) |## Code Stylediff --git a/INSTALLATION.md b/INSTALLATION.mdindex bb83dfdef..4b88767f6 100644--- a/INSTALLATION.md+++ b/INSTALLATION.md@@ -62,7 +62,7 @@ Install all optional dependencies:pip install nemo-switchyard[all]```-Equivalent to: `nemo-switchyard[server,cli,tracing,intake,affinity-redis]`+Equivalent to: `nemo-switchyard[server,cli,tracing,affinity-redis]`### Common Combinationsdiff --git a/crates/switchyard-components/src/intake.rs b/crates/switchyard-components/src/intake.rsdeleted file mode 100644index 475f567db..000000000--- a/crates/switchyard-components/src/intake.rs+++ /dev/null@@ -1,22 +0,0 @@-// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-// SPDX-License-Identifier: Apache-2.0--//! Intake sink support shared by request and response processors.--pub mod client;-pub mod config;-pub mod context;-pub mod payload;--pub use client::{HttpIntakeSink, IntakeSink};-pub use config::{IntakeFormat, IntakeQueueFullPolicy, IntakeSinkConfig, IntakeTarget};-pub use context::{- INTAKE_APP_HEADER, INTAKE_ENABLED_HEADER, INTAKE_TASK_HEADER, IntakeRequestMetadata,- IntakeRequestState, PROXY_SESSION_ID_HEADER, RequestMetadata, SubModelCall, SubModelCalls,-};-pub use payload::{- IntakePayloadBuilder, IntakePayloadContext, IntakeStreamCapture, IntakeStreamFormat,- SYNTHETIC_STREAM_RESPONSE_IDS, UNKNOWN_MODEL, anthropic_response_from_stream, now_millis,- openai_chat_response_from_stream, request_type_value, responses_response_from_stream,- to_flat_document,-};diff --git a/crates/switchyard-components/src/intake/client.rs b/crates/switchyard-components/src/intake/client.rsdeleted file mode 100644index b6960c206..000000000--- a/crates/switchyard-components/src/intake/client.rs+++ /dev/null@@ -1,338 +0,0 @@-// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-// SPDX-License-Identifier: Apache-2.0--//! Intake payload sinks.--use std::fmt;-use std::sync::Arc;-use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};-use std::time::Duration;--use crate::{Result, SwitchyardError};-use async_trait::async_trait;-use parking_lot::Mutex;-use serde_json::Value;-use tokio::sync::mpsc;-use tokio::task::JoinHandle;--use crate::intake::config::{IntakeQueueFullPolicy, IntakeSinkConfig};--/// Async sink contract for intake payload delivery.-#[async_trait]-pub trait IntakeSink: Send + Sync {- /// Enqueues or delivers one intake payload.- async fn enqueue(&self, payload: Value) -> Result<()>;-- /// Flushes background resources before shutdown.- async fn shutdown(&self) -> Result<()> {- Ok(())- }-}--/// HTTP-backed intake sink with an internal async worker queue.-#[derive(Clone)]-pub struct HttpIntakeSink {- inner: Arc<HttpIntakeSinkInner>,-}--/// Shared sink state so cloned processors send into the same queue.-struct HttpIntakeSinkInner {- config: IntakeSinkConfig,- client: reqwest::Client,- sender: mpsc::Sender<WorkerMessage>,- receiver: Mutex<Option<mpsc::Receiver<WorkerMessage>>>,- handle: Mutex<Option<JoinHandle<()>>>,- closed: AtomicBool,- dropped: AtomicU64,-}--/// Messages consumed by the intake background worker.-enum WorkerMessage {- /// Payload to POST to the intake service.- Payload(Value),- /// Graceful shutdown request.- Shutdown,-}--impl HttpIntakeSink {- /// Creates an HTTP intake sink and validates queue/client configuration.- pub fn new(config: IntakeSinkConfig) -> Result<Self> {- validate_config(&config)?;- let client = reqwest::Client::builder()- .timeout(Duration::from_secs_f64(config.request_timeout_s))- .build()- .map_err(|error| {- SwitchyardError::InvalidConfig(format!(- "failed to build intake HTTP client: {error}"- ))- })?;- let (sender, receiver) = mpsc::channel(config.max_queue_size);- Ok(Self {- inner: Arc::new(HttpIntakeSinkInner {- config,- client,- sender,- receiver: Mutex::new(Some(receiver)),- handle: Mutex::new(None),- closed: AtomicBool::new(false),- dropped: AtomicU64::new(0),- }),- })- }-- /// Returns the sink configuration.- pub fn config(&self) -> &IntakeSinkConfig {- &self.inner.config- }-- /// Starts the worker lazily so unused intake configs do not spawn tasks.- fn ensure_worker(&self) -> Result<()> {- if self.inner.closed.load(Ordering::Acquire) {- return Err(SwitchyardError::InvalidConfig(- "HttpIntakeSink is closed".to_string(),- ));- }-- let mut handle = self.inner.handle.lock();- if handle.as_ref().is_some_and(|handle| !handle.is_finished()) {- return Ok(());- }- if handle.as_ref().is_some_and(JoinHandle::is_finished) {- return Err(SwitchyardError::Other(- "intake worker stopped unexpectedly".to_string(),- ));- }-- let receiver = self.inner.receiver.lock().take().ok_or_else(|| {- SwitchyardError::Other("intake worker receiver is unavailable".to_string())- })?;- let config = self.inner.config.clone();- let client = self.inner.client.clone();- let runtime = tokio::runtime::Handle::try_current().map_err(|error| {- SwitchyardError::InvalidConfig(format!(- "HttpIntakeSink enqueue requires a Tokio runtime: {error}"- ))- })?;- *handle = Some(runtime.spawn(worker_loop(config, client, receiver)));- Ok(())- }-}--impl fmt::Debug for HttpIntakeSink {- fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {- formatter- .debug_struct("HttpIntakeSink")- .field("config", &self.inner.config)- .finish_non_exhaustive()- }-}--#[async_trait]-impl IntakeSink for HttpIntakeSink {- async fn enqueue(&self, payload: Value) -> Result<()> {- self.ensure_worker()?;- match self.inner.config.on_queue_full {- IntakeQueueFullPolicy::Block => self- .inner- .sender- .send(WorkerMessage::Payload(payload))- .await- .map_err(|_| SwitchyardError::Other("intake worker is closed".to_string())),- IntakeQueueFullPolicy::Drop => {- match self.inner.sender.try_send(WorkerMessage::Payload(payload)) {- Ok(()) => Ok(()),- Err(mpsc::error::TrySendError::Full(_)) => {- let dropped = self.inner.dropped.fetch_add(1, Ordering::Relaxed) + 1;- tracing::warn!(- max_queue_size = self.inner.config.max_queue_size,- dropped,- "intake queue full; dropping payload"- );- Ok(())- }- Err(mpsc::error::TrySendError::Closed(_)) => Err(SwitchyardError::Other(- "intake worker is closed".to_string(),- )),- }- }- }- }-- async fn shutdown(&self) -> Result<()> {- if self.inner.closed.swap(true, Ordering::AcqRel) {- return Ok(());- }-- let handle = self.inner.handle.lock().take();- if handle.is_none() {- self.inner.receiver.lock().take();- return Ok(());- }-- let _ignored = self.inner.sender.send(WorkerMessage::Shutdown).await;- if let Some(handle) = handle {- handle.await.map_err(|error| {- SwitchyardError::Other(format!("intake worker join failed: {error}"))- })?;- }- Ok(())- }-}--async fn worker_loop(- config: IntakeSinkConfig,- client: reqwest::Client,- mut receiver: mpsc::Receiver<WorkerMessage>,-) {- // The worker is fail-open: individual POST failures are logged and dropped- // so intake availability never blocks the LLM response path.- while let Some(message) = receiver.recv().await {- match message {- WorkerMessage::Payload(payload) => {- if let Err(error) = post_with_retries(&config, &client, &payload).await {- tracing::warn!(- error = %error,- "intake worker failed while posting payload; dropping"- );- }- }- WorkerMessage::Shutdown => return,- }- }-}--/// Posts a payload, retrying transient failures according to config.-async fn post_with_retries(- config: &IntakeSinkConfig,- client: &reqwest::Client,- payload: &Value,-) -> Result<()> {- let mut attempt = 0;- loop {- match post_once(config, client, payload).await {- Ok(()) => return Ok(()),- Err(error) if attempt < config.max_retries => {- attempt += 1;- tracing::debug!(- error = %error,- attempt,- max_retries = config.max_retries,- "retrying intake payload POST"- );- }- Err(error) => return Err(error),- }- }-}--/// Posts one payload to the intake API.-async fn post_once(- config: &IntakeSinkConfig,- client: &reqwest::Client,- payload: &Value,-) -> Result<()> {- // A configured target posts to its own URL with its own auth mode; otherwise- // fall back to the authenticated nemo-platform chat-completions ingest.- let (url, authenticated) = match &config.target {- Some(target) => (target.url.clone(), target.authenticated),- None => (chat_completions_ingest_url(config), true),- };- let mut request = client.post(url).json(payload);- if authenticated && let Some(api_key) = config.api_key.as_deref() {- request = request.bearer_auth(api_key);- }- let response = request.send().await.map_err(|error| {- SwitchyardError::Upstream(format!("intake payload POST failed: {error}"))- })?;- let status = response.status();- if status.is_success() {- return Ok(());- }- let body = match response.text().await {- Ok(body) => body,- Err(error) => format!("<failed to read intake error body: {error}>"),- };- Err(SwitchyardError::Upstream(format!(- "intake payload POST returned HTTP {status}: {body}"- )))-}--/// Validates sink configuration before any background worker is started.-fn validate_config(config: &IntakeSinkConfig) -> Result<()> {- // A configured target carries its own URL; only the nemo-platform fallback- // needs intake_base_url to build the ingest URL.- if config.target.is_none()- && !matches!(config.intake_base_url.as_deref(), Some(base_url) if !base_url.is_empty())- {- return Err(SwitchyardError::InvalidConfig(- "intake_base_url is required for HttpIntakeSink".to_string(),- ));- }- if config.max_queue_size == 0 {- return Err(SwitchyardError::InvalidConfig(- "intake max_queue_size must be positive".to_string(),- ));- }- if !config.request_timeout_s.is_finite() || config.request_timeout_s <= 0.0 {- return Err(SwitchyardError::InvalidConfig(format!(- "intake request_timeout_s must be finite and positive, got {:?}",- config.request_timeout_s- )));- }- Ok(())-}--/// Builds the chat-completions ingest URL from base URL and workspace.-fn chat_completions_ingest_url(config: &IntakeSinkConfig) -> String {- let base_url = config- .intake_base_url- .as_deref()- .unwrap_or_default()- .trim_end_matches('/');- format!(- "{base_url}/apis/intake/v2/workspaces/{}/ingest/chat-completions",- percent_encode_path_segment(config.workspace_or_default()),- )-}--/// Percent-encodes one URL path segment without pulling in another dependency.-fn percent_encode_path_segment(value: &str) -> String {- let mut encoded = String::with_capacity(value.len());- for byte in value.bytes() {- match byte {- b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'.' | b'_' | b'~' => {- encoded.push(char::from(byte));- }- _ => {- encoded.push('%');- encoded.push(nibble_to_hex(byte >> 4));- encoded.push(nibble_to_hex(byte & 0x0f));- }- }- }- encoded-}--/// Converts a 4-bit value into uppercase hex.-fn nibble_to_hex(value: u8) -> char {- match value {- 0..=9 => char::from(b'0' + value),- 10..=15 => char::from(b'A' + (value - 10)),- _ => '?',- }-}--#[cfg(test)]-mod tests {- use crate::Result;-- use super::*;-- // Workspace names are path segments, so reserved characters must be encoded.- #[test]- fn percent_encodes_workspace_path_segment() -> Result<()> {- assert_eq!(percent_encode_path_segment("team space"), "team%20space");- assert_eq!(percent_encode_path_segment("a/b"), "a%2Fb");- Ok(())- }-}diff --git a/crates/switchyard-components/src/intake/config.rs b/crates/switchyard-components/src/intake/config.rsdeleted file mode 100644index ed8ae2839..000000000--- a/crates/switchyard-components/src/intake/config.rs+++ /dev/null@@ -1,113 +0,0 @@-// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-// SPDX-License-Identifier: Apache-2.0--//! Intake sink configuration.--use std::fmt;--use serde::{Deserialize, Serialize};--/// Behavior when the async intake queue is full.-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]-#[serde(rename_all = "snake_case")]-pub enum IntakeQueueFullPolicy {- /// Drop the payload and keep serving the user response.- #[default]- Drop,- /// Wait for queue capacity before returning from enqueue.- Block,-}--/// Payload shape a configured intake target expects.-#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]-#[serde(rename_all = "snake_case")]-pub enum IntakeFormat {- /// Nested OpenAI chat-completions JSON (the nemo-platform ingest shape).- ChatCompletions,- /// Flat, top-level type-prefixed telemetry document (data-lake posting shape).- FlatDocument,-}--/// A configurable intake destination.-///-/// When a sink has no target it posts nested chat-completions documents to the-/// authenticated nemo-platform ingest URL built from `intake_base_url` +-/// `workspace`. Set a target to post a chosen payload shape to an explicit URL.-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]-pub struct IntakeTarget {- /// Full posting URL. The caller builds it; the sink POSTs to it verbatim.- pub url: String,- /// Payload shape to emit.- pub format: IntakeFormat,- /// Send the sink's `api_key` as a bearer token with each POST.- pub authenticated: bool,-}--/// Runtime configuration for the HTTP intake sink.-#[derive(Clone, PartialEq, Serialize, Deserialize)]-pub struct IntakeSinkConfig {- /// Base URL of the intake API service.- pub intake_base_url: Option<String>,- /// Workspace path segment for the intake API.- pub workspace: Option<String>,- /// User ID attached to every intake payload.- pub user_id: String,- /// Bearer token used when posting intake payloads.- pub api_key: Option<String>,- /// Optional explicit destination. Unset posts nested chat-completions- /// documents to the authenticated nemo-platform ingest.- pub target: Option<IntakeTarget>,- /// Maximum buffered payloads before applying `on_queue_full`.- pub max_queue_size: usize,- /// Per-request HTTP timeout in seconds.- pub request_timeout_s: f64,- /// Number of retry attempts after the first failed POST.- pub max_retries: u32,- /// Queue pressure behavior.- pub on_queue_full: IntakeQueueFullPolicy,- /// Capture prompt/response text. Off by default (metadata-only).- #[serde(default)]- pub capture_content: bool,-}--impl fmt::Debug for IntakeSinkConfig {- fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {- formatter- .debug_struct("IntakeSinkConfig")- .field("intake_base_url", &self.intake_base_url)- .field("workspace", &self.workspace)- .field("user_id", &self.user_id)- .field("api_key", &self.api_key.as_ref().map(|_| "<redacted>"))- .field("target", &self.target)- .field("max_queue_size", &self.max_queue_size)- .field("request_timeout_s", &self.request_timeout_s)- .field("max_retries", &self.max_retries)- .field("on_queue_full", &self.on_queue_full)- .field("capture_content", &self.capture_content)- .finish()- }-}--impl Default for IntakeSinkConfig {- fn default() -> Self {- Self {- intake_base_url: None,- workspace: None,- user_id: "switchyard".to_string(),- api_key: None,- target: None,- max_queue_size: 1000,- request_timeout_s: 10.0,- max_retries: 2,- on_queue_full: IntakeQueueFullPolicy::Drop,- capture_content: false,- }- }-}--impl IntakeSinkConfig {- /// Returns the configured workspace or the Python-compatible default.- pub fn workspace_or_default(&self) -> &str {- self.workspace.as_deref().unwrap_or("default")- }-}diff --git a/crates/switchyard-components/src/intake/context.rs b/crates/switchyard-components/src/intake/context.rsdeleted file mode 100644index 34a4a5e7d..000000000--- a/crates/switchyard-components/src/intake/context.rs+++ /dev/null@@ -1,120 +0,0 @@-// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-// SPDX-License-Identifier: Apache-2.0--//! Typed intake request metadata and per-request intake state.--use std::collections::BTreeMap;--use crate::{ChatRequest, ChatRequestType};-use serde::{Deserialize, Serialize};--/// Header carrying the client session ID used by intake.-pub const PROXY_SESSION_ID_HEADER: &str = "proxy_x_session_id";-/// Header that explicitly enables or disables intake capture.-pub const INTAKE_ENABLED_HEADER: &str = "x-switchyard-intake-enabled";-/// Header carrying the intake app label.-pub const INTAKE_APP_HEADER: &str = "x-switchyard-intake-app";-/// Header carrying the intake task label.-pub const INTAKE_TASK_HEADER: &str = "x-switchyard-intake-task";--/// Intake-specific metadata extracted from request headers.-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]-pub struct IntakeRequestMetadata {- /// Optional explicit opt-in or opt-out flag.- pub enabled: Option<bool>,- /// Optional application label.- pub app: Option<String>,- /// Optional task label.- pub task: Option<String>,-}--/// Per-request metadata shared across processors.-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]-pub struct RequestMetadata {- /// Client session ID when provided.- pub session_id: Option<String>,- /// Intake-specific request controls.- pub intake: IntakeRequestMetadata,-}--impl RequestMetadata {- /// Extracts metadata from a case-insensitive header map.- pub fn from_headers(headers: &BTreeMap<String, String>) -> Self {- let normalized = headers- .iter()- .map(|(name, value)| (name.to_ascii_lowercase(), value.as_str()))- .collect::<BTreeMap<_, _>>();- Self {- session_id: header_value(&normalized, PROXY_SESSION_ID_HEADER),- intake: IntakeRequestMetadata {- enabled: parse_bool(header_value(&normalized, INTAKE_ENABLED_HEADER).as_deref()),- app: header_value(&normalized, INTAKE_APP_HEADER),- task: header_value(&normalized, INTAKE_TASK_HEADER),- },- }- }-}--/// Request-side state consumed by the response-side intake processor.-#[derive(Clone, Debug, PartialEq)]-pub struct IntakeRequestState {- /// Request start timestamp in milliseconds since epoch.- pub started_at_ms: i64,- /// Original inbound wire format.- pub inbound_format: ChatRequestType,- /// Session ID copied from request metadata.- pub session_id: Option<String>,- /// Whether response capture should be skipped.- pub skip: bool,- /// Request body snapshot used when constructing the intake payload.- pub request_snapshot: Option<ChatRequest>,-}--impl IntakeRequestState {- /// Returns true when the response processor should leave the response alone.- pub fn skipped(&self) -> bool {- self.skip- }-}--/// One routing-strategy sub-model call captured for intake: the model a router-/// called to pick a route, plus that call's token usage. Never message content.-#[derive(Clone, Debug, PartialEq, Eq)]-pub struct SubModelCall {- /// Model the router called to make its routing decision.- pub model: String,- /// Prompt tokens the routing call spent.- pub prompt_tokens: i64,- /// Completion tokens the routing call spent.- pub completion_tokens: i64,- /// Cached prompt tokens the routing call reused.- pub cached_tokens: i64,- /// Router family that made the call (e.g. `deterministic`, `stage_router`).- pub router_type: String,- /// Route label the router produced (e.g. `classifier`, `judge`).- pub routed_to: String,-}--/// Routing-strategy sub-model calls made while serving one request. Routers-/// append one entry per call; the response-side intake processor emits each as-/// its own anonymous record.-#[derive(Clone, Debug, Default, PartialEq, Eq)]-pub struct SubModelCalls(pub Vec<SubModelCall>);--// Header extraction treats empty strings as absent to match Python behavior.-fn header_value(headers: &BTreeMap<String, &str>, name: &str) -> Option<String> {- headers- .get(name)- .copied()- .filter(|value| !value.is_empty())- .map(str::to_string)-}--// Only exact true/false strings are accepted; malformed values are ignored.-fn parse_bool(raw: Option<&str>) -> Option<bool> {- match raw.map(str::trim).map(str::to_ascii_lowercase).as_deref() {- Some("true") => Some(true),- Some("false") => Some(false),- _ => None,- }-}diff --git a/crates/switchyard-components/src/intake/payload.rs b/crates/switchyard-components/src/intake/payload.rsdeleted file mode 100644index 3bf2e9a73..000000000--- a/crates/switchyard-components/src/intake/payload.rs+++ /dev/null@@ -1,1643 +0,0 @@-// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-// SPDX-License-Identifier: Apache-2.0--//! Intake payload construction.--use std::collections::BTreeMap;-use std::sync::Arc;-use std::time::{SystemTime, UNIX_EPOCH};--use crate::{- ChatRequest, ChatRequestType, ChatResponse, ChatResponseType, ProxyContext, Result,- StreamEvent, SwitchyardError,-};-use serde_json::{Map, Value, json};-use switchyard_translation::{TranslationEngine, TranslationPolicy, WireFormat};--use crate::backends::BackendSelection;-use crate::intake::config::{IntakeFormat, IntakeSinkConfig};-use crate::intake::context::{IntakeRequestState, RequestMetadata, SubModelCall};-use crate::request_processors::RandomRoutingDecision;-use crate::stats::{StatsRouteLabel, estimate_model_cost, usage_from_body};-use crate::telemetry::switchyard_version;--/// Placeholder model label used when no backend selected model is available.-pub const UNKNOWN_MODEL: &str = "unknown";-/// Synthetic stream IDs should not be used as external intake IDs.-pub const SYNTHETIC_STREAM_RESPONSE_IDS: &[&str] = &[- "chatcmpl-intake-stream",- "chatcmpl-switchyard-stream",- "msg_switchyard_stream",- "resp_switchyard_stream",-];--/// Snapshot of request context needed to construct one intake payload.-#[derive(Clone, Debug)]-pub struct IntakePayloadContext {- /// Request metadata extracted from headers or typed context.- pub request_metadata: RequestMetadata,- /// Request start timestamp in milliseconds.- pub started_at_ms: Option<i64>,- /// Original inbound wire format.- pub inbound_format: Option<ChatRequestType>,- /// Client session ID, if available.- pub session_id: Option<String>,- /// Request snapshot captured by `IntakeRequestProcessor`.- pub request_snapshot: Option<ChatRequest>,- /// Backend-selected served model, if known.- pub served_model: Option<String>,- /// Routing label to include in the intake payload.- pub routing: Option<IntakeRoutingMetadata>,- /// Response end timestamp in milliseconds.- pub ended_at_ms: Option<i64>,-}--impl IntakePayloadContext {- /// Extracts the intake payload context from the typed proxy context.- pub fn from_proxy_context(ctx: &ProxyContext, ended_at_ms: Option<i64>) -> Self {- let request_state = ctx.get::<IntakeRequestState>();- Self {- request_metadata: ctx.get::<RequestMetadata>().cloned().unwrap_or_default(),- started_at_ms: request_state.map(|state| state.started_at_ms),- inbound_format: request_state.map(|state| state.inbound_format),- session_id: request_state.and_then(|state| state.session_id.clone()),- request_snapshot: request_state.and_then(|state| state.request_snapshot.clone()),- served_model: ctx- .get::<BackendSelection>()- .map(|selection| selection.model.as_str().to_string())- .filter(|model| !model.is_empty()),- routing: routing_from_context(ctx),- ended_at_ms,- }- }-}--/// Minimal routing metadata attached to intake payloads.-#[derive(Clone, Debug, Eq, PartialEq)]-pub struct IntakeRoutingMetadata {- /// Router family that produced the decision.- pub router_type: String,- /// Tier or route label selected by the router.- pub routed_to: String,-}--/// Builds Intake chat-completions payloads from normalized request/response data.-#[derive(Clone)]-pub struct IntakePayloadBuilder {- /// Sink config values needed in the payload context block.- config: IntakeSinkConfig,- /// Translation engine used to normalize all formats to OpenAI Chat.- translation: Arc<TranslationEngine>,- /// Translation policy used for request and response normalization.- policy: TranslationPolicy,-}--impl IntakePayloadBuilder {- /// Creates a payload builder for one intake sink config.- pub fn new(config: IntakeSinkConfig) -> Self {- Self {- config,- translation: Arc::new(TranslationEngine::default()),- policy: TranslationPolicy::default(),- }- }-- /// Returns the intake sink config backing this builder.- pub fn config(&self) -> &IntakeSinkConfig {- &self.config- }-- /// Returns the request snapshot or a processor error if intake state is missing.- pub fn request_from_state<'a>(&self, ctx: &'a IntakePayloadContext) -> Result<&'a ChatRequest> {- ctx.request_snapshot.as_ref().ok_or_else(|| {- SwitchyardError::Processor("missing intake request snapshot in context".to_string())- })- }-- /// Builds a payload from native Switchyard request and response values.- pub fn build(- &self,- ctx: &IntakePayloadContext,- request_snapshot: &ChatRequest,- response: &ChatResponse,- stream: bool,- ) -> Result<Value> {- let openai_request = self.translate_request_to_openai(request_snapshot)?;- let openai_response = self.translate_response_to_openai(response)?;- self.build_from_openai(ctx, openai_request, openai_response, stream, None)- }-- /// Builds a payload from an already-normalized OpenAI Chat response body.- pub fn build_from_openai_response_body(- &self,- ctx: &IntakePayloadContext,- request_snapshot: &ChatRequest,- openai_response: Value,- stream: bool,- ) -> Result<Value> {- let openai_request = self.translate_request_to_openai(request_snapshot)?;- self.build_from_openai(ctx, openai_request, openai_response, stream, None)- }-- /// Builds an anonymous intake record for one routing-strategy sub-model call.- ///- /// The record carries only the router's own model, token usage, and route- /// label — never message content. It reuses the turn's session, task, and- /// timestamps but overrides the routing label with this call's own. `index`- /// yields a per-call id suffix so several calls in one turn stay distinct as- /// separate flat documents instead of overwriting one another.- pub fn build_submodel_record(- &self,- ctx: &IntakePayloadContext,- call: &SubModelCall,- index: usize,- ) -> Result<Value> {- let openai_request = json!({ "model": call.model });- let openai_response = json!({- "model": call.model,- "object": "chat.completion",- "choices": [],- "usage": {- "prompt_tokens": call.prompt_tokens,- "completion_tokens": call.completion_tokens,- "total_tokens": call.prompt_tokens.saturating_add(call.completion_tokens),- "prompt_tokens_details": { "cached_tokens": call.cached_tokens },- },- });- let mut call_ctx = ctx.clone();- call_ctx.routing = Some(IntakeRoutingMetadata {- router_type: call.router_type.clone(),- routed_to: call.routed_to.clone(),- });- // A routing call's latency isn't the turn's, so drop the start stamp:- // no misleading latency_ms is derived and created_at falls back to the- // turn end (≈ now), matching the Python record this replaces.- call_ctx.started_at_ms = None;- let discriminator = format!("{}-{index}", call.routed_to);- self.build_from_openai(- &call_ctx,- openai_request,- openai_response,- false,- Some(&discriminator),- )- }-- /// Assembles the final intake API JSON payload.- ///- /// `id_discriminator` makes a flat document's `_id` unique among- /// records built for the same turn (same session + timestamp); the primary- /// per-turn record passes `None`.- fn build_from_openai(- &self,- ctx: &IntakePayloadContext,- openai_request: Value,- openai_response: Value,- stream: bool,- id_discriminator: Option<&str>,- ) -> Result<Value> {- let mut request_entry = object_from_value(openai_request, "OpenAI intake request")?;- normalize_logged_stream_request(&mut request_entry, stream);- request_entry.insert(- "switchyard".to_string(),- Value::Object(self.switchyard_request_metadata(ctx, stream)),- );- let mut response_entry = object_from_value(openai_response, "OpenAI intake response")?;- strip_synthetic_response_id(&mut response_entry);-- // Metadata-only unless content capture is explicitly enabled.- if !self.config.capture_content {- redact_prompt_content(&mut request_entry, &mut response_entry);- }-- let session_id = ctx- .session_id- .clone()- .filter(|session_id| !session_id.is_empty());-- let mut payload = Map::new();- payload.insert("request".to_string(), Value::Object(request_entry));- payload.insert("response".to_string(), Value::Object(response_entry));- add_cost_fields(&mut payload);- if let Some(evaluation_context) = self.evaluation_context(ctx) {- payload.insert(- "evaluation_context".to_string(),- Value::Object(evaluation_context),- );- }- if let Some(session_id) = session_id {- payload.insert("session_id".to_string(), Value::String(session_id));- }- payload.insert(- "provider".to_string(),- Value::String("switchyard".to_string()),- );- let payload = Value::Object(payload);- let flat = self- .config()- .target- .as_ref()- .is_some_and(|target| target.format == IntakeFormat::FlatDocument);- if flat {- return Ok(to_flat_document(- &payload,- ctx.ended_at_ms,- id_discriminator,- ));- }- Ok(payload)- }-- /// Normalizes the captured request into OpenAI Chat payload shape.- fn translate_request_to_openai(&self, request: &ChatRequest) -> Result<Value> {- match request.request_type() {- ChatRequestType::OpenAiChat => Ok(request.body().clone()),- source => self- .translation- .translate_request(- request_wire_format(source),- WireFormat::OpenAiChat,- request.body(),- &self.policy,- )- .map(|output| output.body)- .map_err(|error| {- SwitchyardError::Processor(format!(- "failed to translate intake request to OpenAI Chat: {error}"- ))- }),- }- }-- /// Normalizes buffered responses into OpenAI Chat completion shape.- fn translate_response_to_openai(&self, response: &ChatResponse) -> Result<Value> {- let Some(body) = response.body() else {- return Err(SwitchyardError::Processor(- "intake payload builder requires a buffered response".to_string(),- ));- };- match response.response_type() {- ChatResponseType::OpenAiCompletion => Ok(body.clone()),- ChatResponseType::OpenAiResponsesCompletion => self- .translation- .translate_response(- WireFormat::OpenAiResponses,- WireFormat::OpenAiChat,- body,- &self.policy,- )- .map(|output| output.body)- .map_err(|error| {- SwitchyardError::Processor(format!(- "failed to translate Responses intake response to OpenAI Chat: {error}"- ))- }),- ChatResponseType::AnthropicCompletion => self- .translation- .translate_response(- WireFormat::AnthropicMessages,- WireFormat::OpenAiChat,- body,- &self.policy,- )- .map(|output| output.body)- .map_err(|error| {- SwitchyardError::Processor(format!(- "failed to translate Anthropic intake response to OpenAI Chat: {error}"- ))- }),- ChatResponseType::OpenAiStream- | ChatResponseType::OpenAiResponsesStream- | ChatResponseType::AnthropicStream => Err(SwitchyardError::Processor(- "intake payload builder requires a buffered response".to_string(),- )),- }- }-- /// Adds Switchyard-specific request metadata under the request body.- fn switchyard_request_metadata(- &self,- ctx: &IntakePayloadContext,- stream: bool,- ) -> Map<String, Value> {- let mut metadata = Map::new();- metadata.insert("version".to_string(), Value::String(switchyard_version()));- metadata.insert(- "inbound_format".to_string(),- ctx.inbound_format- .map(|request_type| Value::String(request_type_value(request_type).to_string()))- .unwrap_or(Value::Null),- );- metadata.insert("stream".to_string(), Value::Bool(stream));- metadata.insert(- "user_id".to_string(),- Value::String(self.config.user_id.clone()),- );- if let Some(session_id) = ctx- .session_id- .as_deref()- .filter(|session_id| !session_id.is_empty())- {- metadata.insert(- "session_id".to_string(),- Value::String(session_id.to_string()),- );- }- metadata.insert(- "created_at".to_string(),- Value::String(created_at_iso(ctx.started_at_ms, ctx.ended_at_ms)),- );- if let Some(latency_ms) = ctx- .started_at_ms- .zip(ctx.ended_at_ms)- .map(|(started, ended)| ended - started)- {- metadata.insert("latency_ms".to_string(), Value::from(latency_ms));- }- if let Some(routing) = &ctx.routing {- metadata.insert(- "routing".to_string(),- json!({- "router_type": routing.router_type.as_str(),- "routed_to": routing.routed_to.as_str(),- }),- );- }- metadata- }-- /// Returns the intake task name, defaulting to chat.- fn task_name(&self, ctx: &IntakePayloadContext) -> String {- ctx.request_metadata- .intake- .task- .clone()- .unwrap_or_else(|| "chat".to_string())- }-- /// Builds top-level Intake evaluation context from request labels.- fn evaluation_context(&self, ctx: &IntakePayloadContext) -> Option<Map<String, Value>> {- let evaluation_run_id = ctx- .session_id- .as_deref()- .filter(|s| !s.is_empty())?- .to_string();- let test_case_id = self.task_name(ctx);- let mut evaluation_context = Map::new();- evaluation_context.insert(- "evaluation_run_id".to_string(),- Value::String(evaluation_run_id),- );- evaluation_context.insert("test_case_id".to_string(), Value::String(test_case_id));- Some(evaluation_context)- }-}--/// Returns current wall-clock time in milliseconds since Unix epoch.-pub fn now_millis() -> i64 {- match SystemTime::now().duration_since(UNIX_EPOCH) {- Ok(duration) => {- let millis = duration.as_millis();- if millis > i64::MAX as u128 {- i64::MAX- } else {- millis as i64- }- }- Err(_) => 0,- }-}--/// Returns the stable intake string value for a request wire type.-pub fn request_type_value(request_type: ChatRequestType) -> &'static str {- match request_type {- ChatRequestType::OpenAiChat => "openai_chat",- ChatRequestType::OpenAiResponses => "openai_responses",- ChatRequestType::Anthropic => "anthropic",- }-}--/// Stream format captured by intake.-#[derive(Clone, Copy, Debug)]-pub enum IntakeStreamFormat {- /// OpenAI Chat Completions stream.- OpenAiChat,- /// OpenAI Responses API stream.- OpenAiResponses,- /// Anthropic Messages stream.- Anthropic,-}--/// Format-specific stream capture state.-pub enum IntakeStreamCapture {- /// OpenAI Chat stream capture.- OpenAiChat(OpenAiChatStreamCapture),- /// OpenAI Responses stream capture.- OpenAiResponses(ResponsesStreamCapture),- /// Anthropic stream capture.- Anthropic(AnthropicStreamCapture),-}--impl IntakeStreamCapture {- /// Creates a capture adapter for the outbound stream format.- pub fn new(format: IntakeStreamFormat, served_model: Option<&str>) -> Self {- match format {- IntakeStreamFormat::OpenAiChat => {- Self::OpenAiChat(OpenAiChatStreamCapture::new(served_model))- }- IntakeStreamFormat::OpenAiResponses => {- Self::OpenAiResponses(ResponsesStreamCapture::new(served_model))- }- IntakeStreamFormat::Anthropic => {- Self::Anthropic(AnthropicStreamCapture::new(served_model))- }- }- }-- /// Observes one stream event while preserving the caller-visible stream.- pub fn observe(&mut self, event: &StreamEvent) {- match self {- Self::OpenAiChat(capture) => capture.observe(event),- Self::OpenAiResponses(capture) => capture.observe(event),- Self::Anthropic(capture) => capture.observe(event),- }- }-- /// Converts captured stream state into an OpenAI Chat completion body.- pub fn finish(self) -> Result<Value> {- match self {- Self::OpenAiChat(capture) => Ok(capture.finish()),- Self::OpenAiResponses(capture) => capture.finish(),- Self::Anthropic(capture) => Ok(capture.finish()),- }- }-}--/// Reconstructs an OpenAI Chat completion from OpenAI stream chunks.-pub fn openai_chat_response_from_stream(- events: &[StreamEvent],- served_model: Option<&str>,-) -> Value {- let mut capture = OpenAiChatStreamCapture::new(served_model);- for event in events {- capture.observe(event);- }- capture.finish()-}--/// Reconstructs an OpenAI Chat completion from Anthropic stream events.-pub fn anthropic_response_from_stream(events: &[StreamEvent], served_model: Option<&str>) -> Value {- let mut capture = AnthropicStreamCapture::new(served_model);- for event in events {- capture.observe(event);- }- capture.finish()-}--/// Reconstructs an OpenAI Chat completion from Responses stream events.-pub fn responses_response_from_stream(- events: &[StreamEvent],- served_model: Option<&str>,-) -> Result<Value> {- let mut capture = ResponsesStreamCapture::new(served_model);- for event in events {- capture.observe(event);- }- capture.finish()-}--/// Capture state for OpenAI Responses streaming.-pub struct ResponsesStreamCapture {- /// Backend-selected model fallback.- served_model: Option<String>,- /// Response ID from the stream, if observed.- response_id: Option<String>,- /// Response creation timestamp from the stream, if observed.- created_at: Option<f64>,- /// Accumulated output text.- content: String,- /// Tool calls keyed by Responses output index.- tool_calls: BTreeMap<usize, ResponsesToolCallState>,- /// Usage block captured from response metadata.- usage: Option<Value>,- /// Full completed response when the stream provides one.- completed_response: Option<Value>,-}--impl ResponsesStreamCapture {- /// Creates empty Responses stream capture state.- fn new(served_model: Option<&str>) -> Self {- Self {- served_model: served_model.map(str::to_string),- response_id: None,- created_at: None,- content: String::new(),- tool_calls: BTreeMap::new(),- usage: None,- completed_response: None,- }- }-- /// Merges one Responses stream event into the capture state.- fn observe(&mut self, event: &StreamEvent) {- let StreamEvent::Json(value) = event else {- return;- };- if let Some(response) = value- .get("response")- .filter(|response| response.is_object())- {- self.capture_response_metadata(response);- }-- match value.get("type").and_then(Value::as_str) {- Some("response.output_text.delta") => {- if let Some(delta) = value.get("delta").and_then(Value::as_str) {- self.content.push_str(delta);- }- }- Some("response.output_item.added" | "response.output_item.done") => {- self.merge_output_item(- value.get("item"),- coerce_usize(value.get("output_index")).unwrap_or(0),- );- }- Some("response.function_call_arguments.delta") => {- let tool_call = self- .tool_calls- .entry(coerce_usize(value.get("output_index")).unwrap_or(0))- .or_default();- if let Some(delta) = value.get("delta").and_then(Value::as_str) {- tool_call.arguments.push_str(delta);- }- }- Some("response.completed") => {- if let Some(response) = value.get("response").cloned() {- self.completed_response = Some(response);- }- }- _ => {}- }- }-- /// Captures response-level metadata from in-progress or completed events.- fn capture_response_metadata(&mut self, response: &Value) {- if let Some(response_id) = response.get("id").and_then(Value::as_str) {- self.response_id = Some(response_id.to_string());- }- if let Some(model) = response.get("model").and_then(Value::as_str) {- self.served_model = Some(model.to_string());- }- if let Some(created_at) = response- .get("created_at")- .or_else(|| response.get("created"))- .and_then(Value::as_f64)- {- self.created_at = Some(created_at);- }- if let Some(usage) = response.get("usage").filter(|usage| usage.is_object()) {- self.usage = Some(usage.clone());- }- }-- /// Merges a Responses output item into the final synthetic response.- fn merge_output_item(&mut self, item: Option<&Value>, output_index: usize) {- let Some(item) = item.and_then(Value::as_object) else {- return;- };- match item.get("type").and_then(Value::as_str) {- Some("message") => {- let text = extract_responses_message_text(item.get("content"));- if !text.is_empty() && self.content.is_empty() {- self.content = text;- }- }- Some("function_call") => {- let tool_call = self.tool_calls.entry(output_index).or_default();- if let Some(id) = item- .get("id")- .or_else(|| item.get("call_id"))- .and_then(Value::as_str)- {- tool_call.id = Some(id.to_string());- }- if let Some(call_id) = item.get("call_id").and_then(Value::as_str) {- tool_call.call_id = Some(call_id.to_string());- }- if let Some(name) = item.get("name").and_then(Value::as_str) {- tool_call.name = Some(name.to_string());- }- if let Some(arguments) = item.get("arguments").and_then(Value::as_str) {- tool_call.arguments = arguments.to_string();- }- }- _ => {}- }- }-- /// Finishes capture and translates Responses output back to OpenAI Chat.- fn finish(self) -> Result<Value> {- let response =- self.completed_response.unwrap_or_else(|| {- let mut output = Vec::new();- if !self.content.is_empty() {- output.push(json!({- "type": "message",- "role": "assistant",- "status": "completed",- "content": [{"type": "output_text", "text": self.content}],- }));- }- output.extend(self.tool_calls.into_iter().enumerate().filter_map(- |(fallback_index, (_, call))| call.into_response_item(fallback_index),- ));- let mut response = json!({- "id": self.response_id.unwrap_or_else(|| "resp_switchyard_stream".to_string()),- "object": "response",- "created_at": self.created_at.unwrap_or(0.0),- "status": "completed",- "model": self.served_model.unwrap_or_else(|| UNKNOWN_MODEL.to_string()),- "output": output,- "parallel_tool_calls": false,- "tool_choice": "auto",- "tools": [],- });- if let (Value::Object(object), Some(usage)) = (&mut response, self.usage) {- object.insert("usage".to_string(), usage);- }- response- });-- TranslationEngine::default()- .translate_response(- WireFormat::OpenAiResponses,- WireFormat::OpenAiChat,- &response,- &TranslationPolicy::default(),- )- .map(|output| output.body)- .map_err(|error| {- SwitchyardError::Processor(format!(- "failed to translate Responses stream for intake: {error}"- ))- })- }-}--#[derive(Default)]-struct ResponsesToolCallState {- /// Stable item ID when the stream provides one.- id: Option<String>,- /// Provider call ID when separate from item ID.- call_id: Option<String>,- /// Function name.- name: Option<String>,- /// Incrementally assembled JSON arguments string.- arguments: String,-}--impl ResponsesToolCallState {- /// Converts captured tool-call state into a Responses function_call item.- fn into_response_item(self, fallback_index: usize) -> Option<Value> {- (self.name.is_some() || !self.arguments.is_empty()).then(|| {- let id = self- .id- .or_else(|| self.call_id.clone())- .unwrap_or_else(|| format!("fc_switchyard_{fallback_index}"));- json!({- "type": "function_call",- "id": id,- "call_id": self.call_id.unwrap_or_else(|| format!("fc_switchyard_{fallback_index}")),- "name": self.name.unwrap_or_default(),- "arguments": self.arguments,- "status": "completed",- })- })- }-}--/// Converts Switchyard request type into translation wire format.-fn request_wire_format(request_type: ChatRequestType) -> WireFormat {- match request_type {- ChatRequestType::OpenAiChat => WireFormat::OpenAiChat,- ChatRequestType::OpenAiResponses => WireFormat::OpenAiResponses,- ChatRequestType::Anthropic => WireFormat::AnthropicMessages,- }-}--/// Ensures a normalized request or response is a JSON object.-fn object_from_value(value: Value, label: &str) -> Result<Map<String, Value>> {- match value {- Value::Object(object) => Ok(object),- other => Err(SwitchyardError::Processor(format!(- "{label} must be a JSON object, got {other:?}"- ))),- }-}--/// Adds queryable cost fields for models with known Switchyard pricing.-fn add_cost_fields(payload: &mut Map<String, Value>) {- let Some(response) = payload.get("response") else {- return;- };- let Some(model) = response.get("model").and_then(Value::as_str) else {- return;- };- let usage = usage_from_body(response);- if usage.is_zero() {- return;- }- let breakdown = estimate_model_cost(- model,- usage.prompt_tokens,- usage.completion_tokens,- usage.cached_tokens,- usage.cache_creation_tokens,- );- if breakdown.total_cost <= 0.0 {- return;- }- payload.insert("cost_usd".to_string(), json!(breakdown.total_cost));- payload.insert("cost_input_usd".to_string(), json!(breakdown.input_cost));- payload.insert("cost_output_usd".to_string(), json!(breakdown.output_cost));- payload.insert(- "cost_details".to_string(),- json!({- "base_input": breakdown.base_input_cost,- "cached_input": breakdown.cached_input_cost,- "cache_write": breakdown.cache_write_cost,- }),- );-}--/// Logs completed stream responses as non-streaming chat-completion captures.-fn normalize_logged_stream_request(request_entry: &mut Map<String, Value>, stream: bool) {- if stream || matches!(request_entry.get("stream"), Some(Value::Bool(true))) {- request_entry.insert("stream".to_string(), Value::Bool(false));- }-}--/// Synthetic stream response IDs would collide in Intake's span ID field.-fn strip_synthetic_response_id(response_entry: &mut Map<String, Value>) {- let Some(response_id) = response_entry.get("id").and_then(Value::as_str) else {- return;- };- if SYNTHETIC_STREAM_RESPONSE_IDS.contains(&response_id) {- response_entry.remove("id");- }-}--/// Strips prompt/response text so intake captures metadata only; model/usage stay.-fn redact_prompt_content(- request_entry: &mut Map<String, Value>,- response_entry: &mut Map<String, Value>,-) {- for key in [- "messages",- "system",- "prompt",- "input",- "tools",- "tool_choice",- "functions",- "function_call",- ] {- request_entry.remove(key);- }- if let Some(Value::Array(choices)) = response_entry.get_mut("choices") {- for choice in choices.iter_mut() {- let Some(choice) = choice.as_object_mut() else {- continue;- };- choice.remove("logprobs");- for shape in ["message", "delta"] {- if let Some(part) = choice.get_mut(shape).and_then(Value::as_object_mut) {- // Allowlist: keep only role; drop content and any other field.- part.retain(|key, _| key == "role");- }- }- }- }-}--/// Extracts routing metadata from typed context extensions.-fn routing_from_context(ctx: &ProxyContext) -> Option<IntakeRoutingMetadata> {- if let Some(decision) = ctx.get::<RandomRoutingDecision>() {- return Some(IntakeRoutingMetadata {- router_type: "random".to_string(),- routed_to: decision.tier.as_str().to_string(),- });- }- if let Some(label) = ctx.get::<StatsRouteLabel>() {- return route_label_metadata(label.0.trim());- }- None-}--/// Converts a non-empty route label into custom intake routing metadata.-fn route_label_metadata(label: &str) -> Option<IntakeRoutingMetadata> {- (!label.is_empty()).then(|| IntakeRoutingMetadata {- router_type: "custom".to_string(),- routed_to: label.to_string(),- })-}--/// Coerces JSON token counters into signed integers like Python did.-fn coerce_i64(value: Option<&Value>) -> Option<i64> {- match value {- Some(Value::Bool(value)) => Some(i64::from(*value)),- Some(Value::Number(value)) => value- .as_i64()- .or_else(|| value.as_u64().and_then(|value| i64::try_from(value).ok()))- .or_else(|| value.as_f64().map(|value| value as i64)),- _ => None,- }-}--/// Coerces JSON indexes into `usize` for stream reconstruction maps.-fn coerce_usize(value: Option<&Value>) -> Option<usize> {- value- .and_then(Value::as_u64)- .and_then(|value| usize::try_from(value).ok())-}--/// Converts streamed tool-call arguments to their string representation.-fn json_argument_string(value: Option<&Value>) -> String {- match value {- Some(Value::String(value)) => value.clone(),- Some(Value::Object(_)) => value- .and_then(|value| serde_json::to_string(value).ok())- .unwrap_or_default(),- _ => String::new(),- }-}--/// Pulls visible text out of a Responses message output item.-fn extract_responses_message_text(content: Option<&Value>) -> String {- let Some(parts) = content.and_then(Value::as_array) else {- return String::new();- };- let mut text = String::new();- for part in parts {- let Some(part) = part.as_object() else {- continue;- };- if !matches!(- part.get("type").and_then(Value::as_str),- Some("output_text" | "text")- ) {- continue;- }- if let Some(part_text) = part.get("text").and_then(Value::as_str) {- text.push_str(part_text);- }- }- text-}--/// Chooses the OpenAI finish reason for synthesized chat completions.-fn default_openai_finish_reason(has_tools: bool) -> Value {- Value::String(if has_tools { "tool_calls" } else { "stop" }.to_string())-}--/// Maps Anthropic stop reasons onto OpenAI Chat finish reasons.-fn anthropic_stop_reason_to_openai(reason: Value) -> Value {- let Some(reason) = reason.as_str() else {- return reason;- };- Value::String(- match reason {- "tool_use" => "tool_calls",- "end_turn" => "stop",- "max_tokens" => "length",- other => other,- }- .to_string(),- )-}--/// Flattens a chat-completions intake payload into a top-level, type-prefixed-/// (`s_`/`l_`/`f_`/`b_`/`text_`) flat document, since flat posting endpoints-/// only index top-level fields. The raw record is kept in-/// `text_switchyard_record_json`.-pub fn to_flat_document(- payload: &Value,- ts_created_ms: Option<i64>,- id_discriminator: Option<&str>,-) -> Value {- let request = payload.get("request");- let response = payload.get("response");- let switchyard = request.and_then(|value| value.get("switchyard"));- let routing = switchyard.and_then(|value| value.get("routing"));- let usage = response.and_then(|value| value.get("usage"));- let session_id = payload.get("session_id").and_then(Value::as_str);- let ts = ts_created_ms.unwrap_or_default();-- let mut doc = Map::new();- let id = match session_id {- Some(session_id) => format!("{session_id}-{ts}"),- None => format!("switchyard-{ts}"),- };- // Several records can share one session + timestamp (the primary turn plus- // each routing sub-model call); the discriminator keeps their `_id`s unique.- let id = match id_discriminator {- Some(discriminator) => format!("{id}-{discriminator}"),- None => id,- };- doc.insert("_id".to_string(), Value::String(id));- doc.insert("ts_created".to_string(), Value::from(ts));- doc.insert(- "s_source".to_string(),- Value::String("switchyard".to_string()),- );- doc.insert(- "s_record_type".to_string(),- Value::String("switchyard_request".to_string()),- );- doc.insert("l_schema_version".to_string(), Value::from(1));-- insert_str(&mut doc, "s_switchyard_session_id", session_id);- insert_str(- &mut doc,- "s_switchyard_user_id",- switchyard- .and_then(|value| value.get("user_id"))- .and_then(Value::as_str),- );- insert_str(- &mut doc,- "s_switchyard_served_model",- response- .and_then(|value| value.get("model"))- .and_then(Value::as_str),- );- insert_str(- &mut doc,- "s_switchyard_requested_model",- request- .and_then(|value| value.get("model"))- .and_then(Value::as_str),- );- insert_str(- &mut doc,- "s_switchyard_inbound_format",- switchyard- .and_then(|value| value.get("inbound_format"))- .and_then(Value::as_str),- );- insert_str(- &mut doc,- "s_switchyard_router_type",- routing- .and_then(|value| value.get("router_type"))- .and_then(Value::as_str),- );- insert_str(- &mut doc,- "s_switchyard_routed_to",- routing- .and_then(|value| value.get("routed_to"))- .and_then(Value::as_str),- );- doc.insert(- "b_switchyard_routed".to_string(),- Value::Bool(routing.is_some()),- );-- insert_long(- &mut doc,- "l_switchyard_input_tokens",- usage.and_then(|value| value.get("prompt_tokens")),- );- insert_long(- &mut doc,- "l_switchyard_output_tokens",- usage.and_then(|value| value.get("completion_tokens")),- );- insert_long(- &mut doc,- "l_switchyard_total_tokens",- usage.and_then(|value| value.get("total_tokens")),- );- insert_long(- &mut doc,- "l_switchyard_cached_tokens",- usage- .and_then(|value| value.get("prompt_tokens_details"))- .and_then(|value| value.get("cached_tokens")),- );- insert_long(- &mut doc,- "l_switchyard_latency_ms",- switchyard.and_then(|value| value.get("latency_ms")),- );-- insert_float(&mut doc, "f_switchyard_cost_usd", payload.get("cost_usd"));- insert_float(- &mut doc,- "f_switchyard_cost_input_usd",- payload.get("cost_input_usd"),- );- insert_float(- &mut doc,- "f_switchyard_cost_output_usd",- payload.get("cost_output_usd"),- );-- if let Ok(raw) = serde_json::to_string(payload) {- doc.insert(- "text_switchyard_record_json".to_string(),- Value::String(raw),- );- }-- Value::Object(doc)-}--/// Inserts a non-empty string field, skipping absent values.-fn insert_str(doc: &mut Map<String, Value>, key: &str, value: Option<&str>) {- if let Some(value) = value.filter(|value| !value.is_empty()) {- doc.insert(key.to_string(), Value::String(value.to_string()));- }-}--/// Inserts an integer field, skipping absent / non-integer values.-fn insert_long(doc: &mut Map<String, Value>, key: &str, value: Option<&Value>) {- if let Some(number) = value.and_then(Value::as_i64) {- doc.insert(key.to_string(), Value::from(number));- }-}--/// Inserts a float field, skipping absent / non-numeric values.-fn insert_float(doc: &mut Map<String, Value>, key: &str, value: Option<&Value>) {- if let Some(number) = value.and_then(Value::as_f64) {- doc.insert(key.to_string(), Value::from(number));- }-}--/// Chooses the best timestamp for the intake context creation time.-fn created_at_iso(started_at_ms: Option<i64>, ended_at_ms: Option<i64>) -> String {- started_at_ms- .or(ended_at_ms)- .map(ms_to_iso)- .unwrap_or_else(|| ms_to_iso(now_millis()))-}--/// Formats milliseconds since epoch in Python-compatible UTC ISO form.-fn ms_to_iso(value_ms: i64) -> String {- let seconds = value_ms.div_euclid(1000);- let millis = value_ms.rem_euclid(1000);- let days = seconds.div_euclid(86_400);- let seconds_of_day = seconds.rem_euclid(86_400);- let (year, month, day) = civil_from_days(days);- let hour = seconds_of_day / 3600;- let minute = seconds_of_day % 3600 / 60;- let second = seconds_of_day % 60;- if millis == 0 {- format!("{year:04}-{month:02}-{day:02}T{hour:02}:{minute:02}:{second:02}+00:00")- } else {- format!(- "{year:04}-{month:02}-{day:02}T{hour:02}:{minute:02}:{second:02}.{millis:03}000+00:00"- )- }-}--/// Converts days since Unix epoch to a civil date without chrono.-fn civil_from_days(days: i64) -> (i64, u32, u32) {- let z = days + 719_468;- let era = if z >= 0 { z } else { z - 146_096 } / 146_097;- let doe = z - era * 146_097;- let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;- let y = yoe + era * 400;- let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);- let mp = (5 * doy + 2) / 153;- let d = doy - (153 * mp + 2) / 5 + 1;- let m = mp + if mp < 10 { 3 } else { -9 };- let year = y + if m <= 2 { 1 } else { 0 };- (year, m as u32, d as u32)-}--/// Capture state for OpenAI Chat Completions streaming.-pub struct OpenAiChatStreamCapture {- /// Backend-selected model fallback.- served_model: Option<String>,- /// Completion ID from stream chunks.- id: Option<String>,- /// Model reported by stream chunks.- model: Option<String>,- /// Creation timestamp from stream chunks.- created: Option<i64>,- /// Accumulated visible assistant content.- content: String,- /// Accumulated reasoning content when providers stream it separately.- reasoning_content: String,- /// Tool calls keyed by OpenAI stream index.- tool_calls: Vec<OpenAiToolCallState>,- /// Last non-null finish reason seen in the stream.- finish_reason: Option<Value>,- /// First usage block seen in the stream.- usage: Option<Value>,-}--impl OpenAiChatStreamCapture {- /// Creates empty OpenAI Chat stream capture state.- fn new(served_model: Option<&str>) -> Self {- Self {- served_model: served_model.map(str::to_string),- id: None,- model: None,- created: None,- content: String::new(),- reasoning_content: String::new(),- tool_calls: Vec::new(),- finish_reason: None,- usage: None,- }- }-- /// Merges one OpenAI Chat stream chunk into the capture state.- fn observe(&mut self, event: &StreamEvent) {- let StreamEvent::Json(value) = event else {- return;- };- if self.id.is_none() {- self.id = value.get("id").and_then(Value::as_str).map(str::to_string);- }- if self.model.is_none() {- self.model = value- .get("model")- .and_then(Value::as_str)- .map(str::to_string);- }- if self.created.is_none() {- self.created = value.get("created").and_then(Value::as_i64);- }- if let Some(usage) = value.get("usage").filter(|usage| usage.is_object()) {- self.usage = Some(usage.clone());- }- let Some(choice) = value- .get("choices")- .and_then(Value::as_array)- .and_then(|choices| choices.first())- else {- return;- };- if let Some(delta) = choice- .get("delta")- .and_then(|delta| delta.get("content"))- .and_then(Value::as_str)- {- self.content.push_str(delta);- }- for reasoning_key in ["reasoning_content", "reasoning"] {- if let Some(reasoning) = choice- .get("delta")- .and_then(|delta| delta.get(reasoning_key))- .and_then(Value::as_str)- {- self.reasoning_content.push_str(reasoning);- }- }- if let Some(tool_calls) = choice- .get("delta")- .and_then(|delta| delta.get("tool_calls"))- .and_then(Value::as_array)- {- for tool_call in tool_calls {- self.merge_tool_call(tool_call);- }- }- if let Some(reason) = choice- .get("finish_reason")- .filter(|reason| !reason.is_null())- {- self.finish_reason = Some(reason.clone());- }- }-- /// Merges a possibly-partial tool-call delta by stream index.- fn merge_tool_call(&mut self, tool_call: &Value) {- let index = tool_call- .get("index")- .and_then(Value::as_u64)- .and_then(|index| usize::try_from(index).ok())- .unwrap_or(self.tool_calls.len());- while self.tool_calls.len() <= index {- self.tool_calls.push(OpenAiToolCallState::default());- }- let existing = &mut self.tool_calls[index];- if let Some(id) = tool_call- .get("id")- .and_then(Value::as_str)- .filter(|id| !id.is_empty())- {- existing.id = Some(id.to_string());- }- let Some(function) = tool_call.get("function").and_then(Value::as_object) else {- return;- };- if let Some(name) = function- .get("name")- .and_then(Value::as_str)- .filter(|name| !name.is_empty())- {- existing.name = Some(name.to_string());- }- if let Some(arguments) = function- .get("arguments")- .and_then(Value::as_str)- .filter(|arguments| !arguments.is_empty())- {- existing.arguments.push_str(arguments);- }- }-- /// Builds a buffered OpenAI Chat completion from captured stream state.- fn finish(self) -> Value {- let has_tool_calls = self.tool_calls.iter().any(OpenAiToolCallState::has_payload);- let content = if self.content.is_empty() {- Value::Null- } else {- Value::String(self.content)- };- let mut message = json!({- "role": "assistant",- "content": content,- });- if !self.reasoning_content.is_empty()- && let Value::Object(object) = &mut message- {- object.insert(- "reasoning_content".to_string(),- Value::String(self.reasoning_content),- );- }- if has_tool_calls && let Value::Object(object) = &mut message {- object.insert(- "tool_calls".to_string(),- Value::Array(- self.tool_calls- .into_iter()- .enumerate()- .filter_map(|(index, tool_call)| tool_call.into_openai(index))- .collect(),- ),- );- }- let mut response = json!({- "id": self.id.unwrap_or_else(|| "chatcmpl-switchyard-stream".to_string()),- "object": "chat.completion",- "created": self.created.unwrap_or(0),- "model": self- .model- .or(self.served_model)- .unwrap_or_else(|| UNKNOWN_MODEL.to_string()),- "choices": [{- "index": 0,- "message": message,- "finish_reason": self- .finish_reason- .unwrap_or_else(|| default_openai_finish_reason(has_tool_calls)),- }],- });- if let Some(usage) = self.usage- && let Value::Object(object) = &mut response- {- object.insert("usage".to_string(), usage);- }- response- }-}--#[derive(Default)]-struct OpenAiToolCallState {- /// Provider tool-call ID.- id: Option<String>,- /// Function name.- name: Option<String>,- /// Incrementally assembled JSON arguments string.- arguments: String,-}--impl OpenAiToolCallState {- /// Returns true when this partial tool call carries useful data.- fn has_payload(&self) -> bool {- self.id.is_some() || self.name.is_some() || !self.arguments.is_empty()- }-- /// Converts captured tool-call state into OpenAI Chat tool_call shape.- fn into_openai(self, index: usize) -> Option<Value> {- self.has_payload().then(|| {- json!({- "id": self.id.unwrap_or_else(|| format!("call_switchyard_{index}")),- "type": "function",- "function": {- "name": self.name.unwrap_or_default(),- "arguments": self.arguments,- },- })- })- }-}--/// Capture state for Anthropic Messages streaming.-pub struct AnthropicStreamCapture {- /// Backend-selected model fallback.- served_model: Option<String>,- /// Message ID from the stream.- id: Option<String>,- /// Model reported by the stream.- model: Option<String>,- /// Content blocks keyed by Anthropic content index.- content_blocks: BTreeMap<usize, AnthropicContentBlockState>,- /// Input tokens from usage events.- input_tokens: i64,- /// Output tokens from usage events.- output_tokens: i64,- /// Cache-read input tokens from usage events.- cache_read_input_tokens: i64,- /// Cache-creation input tokens from usage events.- cache_creation_input_tokens: i64,- /// Anthropic stop reason from the stream.- stop_reason: Option<Value>,- /// Whether any usage event was seen.- saw_usage: bool,-}--impl AnthropicStreamCapture {- /// Creates empty Anthropic stream capture state.- fn new(served_model: Option<&str>) -> Self {- Self {- served_model: served_model.map(str::to_string),- id: None,- model: None,- content_blocks: BTreeMap::new(),- input_tokens: 0,- output_tokens: 0,- cache_read_input_tokens: 0,- cache_creation_input_tokens: 0,- stop_reason: None,- saw_usage: false,- }- }-- /// Merges one Anthropic Messages stream event into the capture state.- fn observe(&mut self, event: &StreamEvent) {- let StreamEvent::Json(value) = event else {- return;- };- match value.get("type").and_then(Value::as_str) {- Some("message_start") => {- if let Some(message) = value.get("message") {- if self.id.is_none() {- self.id = message- .get("id")- .and_then(Value::as_str)- .map(str::to_string);- }- if self.model.is_none() {- self.model = message- .get("model")- .and_then(Value::as_str)- .map(str::to_string);- }- if let Some(usage) = message.get("usage") {- self.merge_usage(usage);- }- }- }- Some("content_block_start") => {- let index = coerce_usize(value.get("index")).unwrap_or(0);- let Some(block) = value.get("content_block").and_then(Value::as_object) else {- return;- };- if block.get("type").and_then(Value::as_str) == Some("tool_use") {- self.content_blocks.insert(- index,- AnthropicContentBlockState {- kind: AnthropicContentKind::ToolUse,- text: String::new(),- id: block.get("id").and_then(Value::as_str).map(str::to_string),- name: block- .get("name")- .and_then(Value::as_str)- .map(str::to_string),- arguments: json_argument_string(block.get("input")),- },- );- return;- }- self.content_blocks.insert(- index,- AnthropicContentBlockState {- kind: AnthropicContentKind::Text,- text: block- .get("text")- .and_then(Value::as_str)- .unwrap_or_default()- .to_string(),- id: None,- name: None,- arguments: String::new(),- },- );- }- Some("content_block_delta") => {- let index = coerce_usize(value.get("index")).unwrap_or(0);- let Some(delta) = value.get("delta").and_then(Value::as_object) else {- return;- };- let block = self- .content_blocks- .entry(index)- .or_insert_with(AnthropicContentBlockState::text);- if delta.get("type").and_then(Value::as_str) == Some("input_json_delta") {- block.kind = AnthropicContentKind::ToolUse;- if let Some(partial_json) = delta.get("partial_json").and_then(Value::as_str) {- block.arguments.push_str(partial_json);- }- return;- }- if block.kind != AnthropicContentKind::Text {- return;- }- if let Some(text) = delta.get("text").and_then(Value::as_str) {- block.text.push_str(text);- return;- }- if let Some(thinking) = delta.get("thinking").and_then(Value::as_str) {- block.text.push_str(thinking);- }- }- Some("message_delta") => {- if let Some(usage) = value.get("usage") {- self.merge_usage(usage);- }- if let Some(reason) = value- .get("delta")- .and_then(|delta| delta.get("stop_reason"))- .filter(|reason| !reason.is_null())- {- self.stop_reason = Some(reason.clone());- }- }- _ => {}- }- }-- /// Merges Anthropic usage counters, preserving the latest delta semantics.- fn merge_usage(&mut self, usage: &Value) {- if !usage.is_object() {- return;- }- self.saw_usage = true;- if let Some(value) = coerce_i64(usage.get("input_tokens")) {- self.input_tokens = value;- }- if let Some(value) = coerce_i64(usage.get("output_tokens")) {- self.output_tokens = value;- }- if let Some(value) = coerce_i64(usage.get("cache_read_input_tokens")) {- self.cache_read_input_tokens = value;- }- if let Some(value) = coerce_i64(usage.get("cache_creation_input_tokens")) {- self.cache_creation_input_tokens = value;- }- }-- /// Builds a buffered OpenAI Chat completion from captured Anthropic state.- fn finish(self) -> Value {- let prompt_tokens = self- .input_tokens- .saturating_add(self.cache_read_input_tokens)- .saturating_add(self.cache_creation_input_tokens);- let content = self- .content_blocks- .values()- .filter(|block| block.kind == AnthropicContentKind::Text)- .map(|block| block.text.as_str())- .collect::<String>();- let tool_calls = self- .content_blocks- .values()- .filter(|block| block.kind == AnthropicContentKind::ToolUse)- .enumerate()- .map(|(index, block)| block.to_openai_tool_call(index))- .collect::<Vec<_>>();- let has_tool_calls = !tool_calls.is_empty();- let mut message = json!({- "role": "assistant",- "content": if content.is_empty() { Value::Null } else { Value::String(content) },- });- if has_tool_calls && let Value::Object(object) = &mut message {- object.insert("tool_calls".to_string(), Value::Array(tool_calls));- }- let mut response = json!({- "id": self.id.unwrap_or_else(|| "msg_switchyard_stream".to_string()),- "object": "chat.completion",- "model": self- .model- .or(self.served_model)- .unwrap_or_else(|| UNKNOWN_MODEL.to_string()),- "choices": [{- "index": 0,- "message": message,- "finish_reason": self- .stop_reason- .map(anthropic_stop_reason_to_openai)- .unwrap_or_else(|| default_openai_finish_reason(has_tool_calls)),- }],- });- if self.saw_usage {- let mut usage = Map::new();- usage.insert("prompt_tokens".to_string(), Value::from(prompt_tokens));- usage.insert(- "completion_tokens".to_string(),- Value::from(self.output_tokens),- );- usage.insert(- "total_tokens".to_string(),- Value::from(prompt_tokens.saturating_add(self.output_tokens)),- );- if self.cache_read_input_tokens != 0 || self.cache_creation_input_tokens != 0 {- usage.insert(- "prompt_tokens_details".to_string(),- json!({- "cached_tokens": self.cache_read_input_tokens,- "cache_creation_tokens": self.cache_creation_input_tokens,- }),- );- }- if let Value::Object(object) = &mut response {- object.insert("usage".to_string(), Value::Object(usage));- }- }- response- }-}--#[derive(Clone, Copy, Eq, PartialEq)]-enum AnthropicContentKind {- /// Text or thinking block that should become assistant content.- Text,- /// Tool-use block that should become an OpenAI tool call.- ToolUse,-}--struct AnthropicContentBlockState {- /// Captured block kind.- kind: AnthropicContentKind,- /// Accumulated text content for text blocks.- text: String,- /// Anthropic tool-use ID for tool blocks.- id: Option<String>,- /// Tool name for tool-use blocks.- name: Option<String>,- /// Incrementally assembled tool input JSON.- arguments: String,-}--impl AnthropicContentBlockState {- /// Creates an empty text block for deltas that arrive before a start event.- fn text() -> Self {- Self {- kind: AnthropicContentKind::Text,- text: String::new(),- id: None,- name: None,- arguments: String::new(),- }- }-- /// Converts an Anthropic tool-use block into OpenAI Chat tool-call shape.- fn to_openai_tool_call(&self, index: usize) -> Value {- json!({- "id": self- .id- .clone()- .unwrap_or_else(|| format!("toolu_switchyard_{index}")),- "type": "function",- "function": {- "name": self.name.clone().unwrap_or_default(),- "arguments": self.arguments.clone(),- },- })- }-}--#[cfg(test)]-mod tests {- use super::*;- use crate::Result;-- // Timestamp formatting should match the Python intake payloads exactly.- #[test]- fn formats_python_style_utc_iso_timestamps() -> Result<()> {- assert_eq!(ms_to_iso(1_700_000_000_000), "2023-11-14T22:13:20+00:00");- assert_eq!(- ms_to_iso(1_700_000_001_840),- "2023-11-14T22:13:21.840000+00:00"- );- Ok(())- }-}diff --git a/crates/switchyard-components/src/lib.rs b/crates/switchyard-components/src/lib.rsindex 72ce5c705..e9c6983be 100644--- a/crates/switchyard-components/src/lib.rs+++ b/crates/switchyard-components/src/lib.rs@@ -9,7 +9,6 @@pub mod backends;mod contracts;pub mod dimension_collector;-pub mod intake;pub mod request_processors;pub mod response_processors;pub mod stage_router;@@ -24,18 +23,11 @@ pub use contracts::*;pub use dimension_collector::{ResponseFlag, ResponseSignals, ToolResultSignal, extract_tool_signals,};-pub use intake::{- HttpIntakeSink, IntakeFormat, IntakePayloadBuilder, IntakeQueueFullPolicy,- IntakeRequestMetadata, IntakeRequestState, IntakeSink, IntakeSinkConfig, IntakeTarget,- RequestMetadata, SubModelCall, SubModelCalls,-};pub use request_processors::{- DimensionCollector, IntakeRequestProcessor, RandomRoutingDecision, RandomRoutingEngine,- RandomRoutingProcessorConfig, RandomRoutingTier, StatsRequestProcessor,-};-pub use response_processors::{- IntakeResponseProcessor, ResponseSignalCollector, StatsResponseProcessor,+ DimensionCollector, RandomRoutingDecision, RandomRoutingEngine, RandomRoutingProcessorConfig,+ RandomRoutingTier, StatsRequestProcessor,};+pub use response_processors::{ResponseSignalCollector, StatsResponseProcessor};pub use stats::{ClassifierStatsSnapshot, CostBreakdown, CostEstimate, LatencyHistogramSnapshot,ModelStatsSnapshot, PrefixProbe, StatsAccumulator, StatsBackendLatency, StatsRequestStart,diff --git a/crates/switchyard-components/src/request_processors/intake.rs b/crates/switchyard-components/src/request_processors/intake.rsdeleted file mode 100644index 319c88a70..000000000--- a/crates/switchyard-components/src/request_processors/intake.rs+++ /dev/null@@ -1,47 +0,0 @@-// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-// SPDX-License-Identifier: Apache-2.0--//! Request-side intake processor.--use crate::{ChatRequest, ProxyContext, Result};-use serde_json::Value;--use crate::intake::context::{IntakeRequestState, RequestMetadata};-use crate::intake::payload::now_millis;--/// Captures request-side intake state for the response processor.-#[derive(Clone, Copy, Debug, Default)]-pub struct IntakeRequestProcessor;--impl IntakeRequestProcessor {- /// Captures request metadata needed for response-side intake emission.- pub async fn process(- &self,- ctx: &mut ProxyContext,- request: ChatRequest,- ) -> Result<ChatRequest> {- let metadata = ctx.get::<RequestMetadata>().cloned().unwrap_or_default();- let client_opt_in = metadata- .intake- .enabled- .or_else(|| extract_store_toggle(&request));- let skip = client_opt_in != Some(true);- let request_snapshot = (!skip).then(|| request.clone());- ctx.insert(IntakeRequestState {- started_at_ms: now_millis(),- inbound_format: request.request_type(),- session_id: metadata.session_id,- skip,- request_snapshot,- });- Ok(request)- }-}--// The OpenAI `store` flag is treated as an intake opt-in when headers are absent.-fn extract_store_toggle(request: &ChatRequest) -> Option<bool> {- match request.body() {- Value::Object(object) => object.get("store").and_then(Value::as_bool),- _ => None,- }-}diff --git a/crates/switchyard-components/src/request_processors/mod.rs b/crates/switchyard-components/src/request_processors/mod.rsindex 72d3b653f..3855c81c3 100644--- a/crates/switchyard-components/src/request_processors/mod.rs+++ b/crates/switchyard-components/src/request_processors/mod.rs@@ -4,11 +4,9 @@//! Built-in request processor implementations.pub mod dimension_collector;-pub mod intake;pub mod random_routing;pub mod stats;pub use dimension_collector::DimensionCollector;-pub use intake::*;pub use random_routing::*;pub use stats::*;diff --git a/crates/switchyard-components/src/response_processors/intake.rs b/crates/switchyard-components/src/response_processors/intake.rsdeleted file mode 100644index 44ea87bea..000000000--- a/crates/switchyard-components/src/response_processors/intake.rs+++ /dev/null@@ -1,204 +0,0 @@-// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-// SPDX-License-Identifier: Apache-2.0--//! Response-side intake processor.--use std::sync::Arc;--use crate::{BoxResponseStream, ChatResponse, ProxyContext, Result};-use async_stream::try_stream;-use futures_util::StreamExt;--use crate::intake::{- HttpIntakeSink, IntakePayloadBuilder, IntakePayloadContext, IntakeRequestState, IntakeSink,- IntakeSinkConfig, IntakeStreamCapture, IntakeStreamFormat, SubModelCalls, now_millis,-};--/// Response processor that converts completed responses into intake payloads.-#[derive(Clone)]-pub struct IntakeResponseProcessor {- /// Payload builder shared by buffered and streaming responses.- builder: IntakePayloadBuilder,- /// Sink used to deliver payloads without blocking response correctness.- sink: Arc<dyn IntakeSink>,-}--impl IntakeResponseProcessor {- /// Creates an intake response processor with an injected sink.- pub fn new(config: IntakeSinkConfig, sink: Arc<dyn IntakeSink>) -> Self {- Self {- builder: IntakePayloadBuilder::new(config),- sink,- }- }-- /// Creates an intake response processor backed by the default HTTP sink.- pub fn with_http_sink(config: IntakeSinkConfig) -> Result<Self> {- let sink = Arc::new(HttpIntakeSink::new(config.clone())?);- Ok(Self::new(config, sink))- }-- /// Returns the payload builder for tests and diagnostics.- pub fn builder(&self) -> &IntakePayloadBuilder {- &self.builder- }-- /// Emits intake payloads for buffered responses or wraps streams for deferred emission.- pub async fn process(- &self,- ctx: &mut ProxyContext,- response: ChatResponse,- ) -> Result<ChatResponse> {- if ctx- .get::<IntakeRequestState>()- .map(IntakeRequestState::skipped)- == Some(true)- {- return Ok(response);- }-- // Routing sub-model records don't depend on the response body — the- // router already made its call at request time — so emit them here,- // gated by the same opt-in, instead of threading through the- // buffered/streaming split below.- self.emit_submodel_records(ctx, Arc::clone(&self.sink))- .await;-- match response {- ChatResponse::OpenAiCompletion(_)- | ChatResponse::OpenAiResponsesCompletion(_)- | ChatResponse::AnthropicCompletion(_) => {- let payload = self.buffered_payload(ctx, &response);- enqueue_payload(Arc::clone(&self.sink), payload).await;- Ok(response)- }- ChatResponse::OpenAiStream(stream) => Ok(ChatResponse::OpenAiStream(wrap_stream(- stream,- self.builder.clone(),- Arc::clone(&self.sink),- IntakePayloadContext::from_proxy_context(ctx, None),- IntakeStreamFormat::OpenAiChat,- ))),- ChatResponse::OpenAiResponsesStream(stream) => {- Ok(ChatResponse::OpenAiResponsesStream(wrap_stream(- stream,- self.builder.clone(),- Arc::clone(&self.sink),- IntakePayloadContext::from_proxy_context(ctx, None),- IntakeStreamFormat::OpenAiResponses,- )))- }- ChatResponse::AnthropicStream(stream) => {- Ok(ChatResponse::AnthropicStream(wrap_stream(- stream,- self.builder.clone(),- Arc::clone(&self.sink),- IntakePayloadContext::from_proxy_context(ctx, None),- IntakeStreamFormat::Anthropic,- )))- }- }- }-- /// Flushes and shuts down the configured intake sink.- pub async fn shutdown(&self) -> Result<()> {- self.sink.shutdown().await- }-}--impl IntakeResponseProcessor {- /// Emits one anonymous record per routing sub-model call stashed on context.- async fn emit_submodel_records(&self, ctx: &ProxyContext, sink: Arc<dyn IntakeSink>) {- // Clone the calls out before the await so no context borrow is held- // across it.- let calls = match ctx.get::<SubModelCalls>() {- Some(calls) if !calls.0.is_empty() => calls.0.clone(),- _ => return,- };- let payload_ctx = IntakePayloadContext::from_proxy_context(ctx, Some(now_millis()));- for (index, call) in calls.iter().enumerate() {- let payload = self- .builder- .build_submodel_record(&payload_ctx, call, index);- enqueue_payload(Arc::clone(&sink), payload).await;- }- }-- /// Builds a payload for a buffered response using request state from context.- fn buffered_payload(- &self,- ctx: &ProxyContext,- response: &ChatResponse,- ) -> Result<serde_json::Value> {- let payload_ctx = IntakePayloadContext::from_proxy_context(ctx, Some(now_millis()));- self.builder- .request_from_state(&payload_ctx)- .and_then(|request| self.builder.build(&payload_ctx, request, response, false))- }-}--// Wraps a response stream, mirrors all events to the caller, and emits intake-// after the upstream stream finishes.-fn wrap_stream(- mut stream: BoxResponseStream,- builder: IntakePayloadBuilder,- sink: Arc<dyn IntakeSink>,- mut payload_ctx: IntakePayloadContext,- format: IntakeStreamFormat,-) -> BoxResponseStream {- Box::pin(try_stream! {- let mut capture = IntakeStreamCapture::new(format, payload_ctx.served_model.as_deref());- while let Some(event) = stream.next().await {- let event = event?;- capture.observe(&event);- yield event;- }-- payload_ctx.ended_at_ms = Some(now_millis());- let payload = capture- .finish()- .and_then(|openai_response| {- builder- .request_from_state(&payload_ctx)- .and_then(|request| {- builder.build_from_openai_response_body(- &payload_ctx,- request,- openai_response,- true,- )- })- });- enqueue_payload(sink, payload).await;- })-}--// Intake is deliberately fail-open: build and enqueue failures are logged but-// never replace the user-visible LLM response.-async fn enqueue_payload(sink: Arc<dyn IntakeSink>, payload: Result<serde_json::Value>) {- match payload {- Ok(payload) => {- if let Err(error) = sink.enqueue(payload).await {- tracing::warn!(- error = %error,- "failed to enqueue intake payload"- );- }- }- Err(error) => {- tracing::warn!(- error = %error,- "failed to build intake payload"- );- }- }-}--impl std::fmt::Debug for IntakeResponseProcessor {- fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {- formatter- .debug_struct("IntakeResponseProcessor")- .field("config", self.builder.config())- .finish_non_exhaustive()- }-}diff --git a/crates/switchyard-components/src/response_processors/mod.rs b/crates/switchyard-components/src/response_processors/mod.rsindex 457f179cd..453e0978f 100644--- a/crates/switchyard-components/src/response_processors/mod.rs+++ b/crates/switchyard-components/src/response_processors/mod.rs@@ -3,10 +3,8 @@//! Built-in response processor implementations.-pub mod intake;pub mod response_signals;pub mod stats;-pub use intake::*;pub use response_signals::ResponseSignalCollector;pub use stats::*;diff --git a/crates/switchyard-components/src/telemetry.rs b/crates/switchyard-components/src/telemetry.rsindex 2804a59a2..10b7dfd66 100644--- a/crates/switchyard-components/src/telemetry.rs+++ b/crates/switchyard-components/src/telemetry.rs@@ -11,11 +11,6 @@ const SWITCHYARD_VERSION_ENV: &str = "SWITCHYARD_VERSION";const SWITCHYARD_TELEMETRY_OPT_OUT_ENV: &str = "SWITCHYARD_TELEMETRY_OPT_OUT";const NEMO_SWITCHYARD_TELEMETRY_OPT_OUT_ENV: &str = "NEMO_SWITCHYARD_TELEMETRY_OPT_OUT";-pub(crate) fn switchyard_version() -> String {- configured_version(env::var(SWITCHYARD_VERSION_ENV).ok().as_deref())- .unwrap_or_else(|| env!("CARGO_PKG_VERSION").to_string())-}-pub(crate) fn telemetry_header_value() -> Option<String> {telemetry_header_value_from_values(env::var(SWITCHYARD_TELEMETRY_OPT_OUT_ENV).ok().as_deref(),diff --git a/crates/switchyard-components/tests/flat_target_live.rs b/crates/switchyard-components/tests/flat_target_live.rsdeleted file mode 100644index ff868edf7..000000000--- a/crates/switchyard-components/tests/flat_target_live.rs+++ /dev/null@@ -1,115 +0,0 @@-// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-// SPDX-License-Identifier: Apache-2.0--//! Live flat-document posting test. Ignored by default (needs a reachable-//! posting endpoint, typically on the NVIDIA internal network / VPN). Run:-//!-//! SWITCHYARD_INTAKE_TARGET_URL=<full posting url> \-//! cargo test -p switchyard-components --test flat_target_live -- --ignored-//!-//! Posting is fail-open, so this drives records through the real sink; verify-//! they landed by querying the target store. No-ops when the env var is unset.--use std::time::{SystemTime, UNIX_EPOCH};--use serde_json::{Value, json};-use switchyard_components::Result;-use switchyard_components::intake::to_flat_document;-use switchyard_components::{- HttpIntakeSink, IntakeFormat, IntakeSink, IntakeSinkConfig, IntakeTarget,-};--// A representative chat-completions intake payload, the input the production-// builder produces before flattening.-fn sample_chat_payload(- session: &str,- served: &str,- routed_to: &str,- prompt: i64,- completion: i64,- cost: f64,-) -> Value {- json!({- "request": {- "model": "openai/openai/gpt-5.2",- "switchyard": {- "user_id": "0badf00d",- "inbound_format": "openai_chat",- "latency_ms": 1840,- "routing": {"router_type": "random", "routed_to": routed_to}- }- },- "response": {- "model": served,- "usage": {- "prompt_tokens": prompt,- "completion_tokens": completion,- "total_tokens": prompt + completion- }- },- "session_id": session,- "cost_usd": cost,- "cost_input_usd": cost * 0.7,- "cost_output_usd": cost * 0.3,- "provider": "switchyard"- })-}--#[tokio::test]-#[ignore = "live: posts to a real flat-document endpoint; requires VPN. run with --ignored"]-async fn posts_flat_documents_to_live_target() -> Result<()> {- // No endpoint configured means nothing to exercise; keep the test a no-op.- let Ok(url) = std::env::var("SWITCHYARD_INTAKE_TARGET_URL") else {- return Ok(());- };- let sink = HttpIntakeSink::new(IntakeSinkConfig {- target: Some(IntakeTarget {- url,- format: IntakeFormat::FlatDocument,- authenticated: false,- }),- ..IntakeSinkConfig::default()- })?;-- let samples = [- (- "claude-live-0001",- "nvidia/moonshotai/kimi-k2.5",- "weak",- 25_000,- 6_580,- 0.0142,- ),- (- "claude-live-0002",- "openai/openai/gpt-5.2",- "strong",- 41_000,- 9_100,- 0.2300,- ),- (- "codex-live-0003",- "nvidia/nvidia/nemotron-3-super-v3",- "weak",- 18_000,- 3_200,- 0.0061,- ),- ];- // The target store may reject backdated documents per retention policy, so- // stamp now.- let base_ts = SystemTime::now()- .duration_since(UNIX_EPOCH)- .map(|elapsed| elapsed.as_millis() as i64)- .unwrap_or_default();- for (index, (session, served, routed_to, prompt, completion, cost)) in- samples.iter().enumerate()- {- let chat = sample_chat_payload(session, served, routed_to, *prompt, *completion, *cost);- let doc = to_flat_document(&chat, Some(base_ts + index as i64), None);- sink.enqueue(doc).await?;- }- sink.shutdown().await?;- Ok(())-}diff --git a/crates/switchyard-components/tests/intake_http_sink.rs b/crates/switchyard-components/tests/intake_http_sink.rsdeleted file mode 100644index 32e4afe19..000000000--- a/crates/switchyard-components/tests/intake_http_sink.rs+++ /dev/null@@ -1,188 +0,0 @@-// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-// SPDX-License-Identifier: Apache-2.0--mod support;--use serde_json::json;-use switchyard_components::{- HttpIntakeSink, IntakeFormat, IntakeSink, IntakeSinkConfig, IntakeTarget,-};-use switchyard_components::{Result, SwitchyardError};--use support::{OneShotServer, SequenceServer};--#[tokio::test]-async fn http_intake_sink_posts_to_workspace_chat_completions_path_with_bearer_auth() -> Result<()>-{- let server = OneShotServer::json(200, json!({"ok": true}))?;- let sink = HttpIntakeSink::new(IntakeSinkConfig {- intake_base_url: Some(server.base_url().to_string()),- workspace: Some("team space".to_string()),- api_key: Some("secret-token".to_string()),- ..IntakeSinkConfig::default()- })?;-- sink.enqueue(json!({"request": {"ok": true}, "response": {"choices": []}}))- .await?;- sink.shutdown().await?;- let request = server.captured()?;-- assert_eq!(request.method, "POST");- assert_eq!(- request.path,- "/apis/intake/v2/workspaces/team%20space/ingest/chat-completions"- );- assert_eq!(request.header("authorization"), Some("Bearer secret-token"));- assert_eq!(request.body["request"]["ok"], true);- Ok(())-}--#[test]-fn intake_sink_config_debug_redacts_api_key() -> Result<()> {- let config = IntakeSinkConfig {- api_key: Some("secret-token".to_string()),- ..IntakeSinkConfig::default()- };-- let debug = format!("{config:?}");-- assert!(debug.contains("<redacted>"));- assert!(!debug.contains("secret-token"));- Ok(())-}--#[test]-fn http_intake_sink_rejects_missing_base_url_at_construction() -> Result<()> {- let error = HttpIntakeSink::new(IntakeSinkConfig::default())- .err()- .ok_or_else(|| SwitchyardError::Other("missing base URL should fail".to_string()))?;-- match error {- SwitchyardError::InvalidConfig(message) => {- assert!(message.contains("intake_base_url is required"));- }- other => {- return Err(SwitchyardError::Other(format!(- "expected invalid config error, got {other:?}"- )));- }- }- Ok(())-}--#[tokio::test]-async fn http_intake_sink_error_status_is_fail_open() -> Result<()> {- let server = OneShotServer::json(503, json!({"error": "down"}))?;- let sink = HttpIntakeSink::new(IntakeSinkConfig {- intake_base_url: Some(server.base_url().to_string()),- workspace: Some("default".to_string()),- ..IntakeSinkConfig::default()- })?;-- sink.enqueue(json!({"request": {"ok": true}, "response": {"choices": []}}))- .await?;- sink.shutdown().await?;- let request = server.captured()?;-- assert_eq!(request.method, "POST");- assert_eq!(request.body["request"]["ok"], true);- Ok(())-}--#[tokio::test]-async fn http_intake_sink_retries_transient_status_failures() -> Result<()> {- let server = SequenceServer::json(vec![- (503, json!({"error": "try again"})),- (200, json!({"ok": true})),- ])?;- let sink = HttpIntakeSink::new(IntakeSinkConfig {- intake_base_url: Some(server.base_url().to_string()),- max_retries: 1,- ..IntakeSinkConfig::default()- })?;-- sink.enqueue(json!({"request": {"retry": true}, "response": {"choices": []}}))- .await?;- sink.shutdown().await?;- let requests = server.captured()?;-- assert_eq!(requests.len(), 2);- assert_eq!(requests[0].body["request"]["retry"], true);- assert_eq!(requests[1].body["request"]["retry"], true);- Ok(())-}--#[test]-fn http_intake_sink_rejects_non_positive_timeout() -> Result<()> {- let error = HttpIntakeSink::new(IntakeSinkConfig {- intake_base_url: Some("http://localhost:1".to_string()),- request_timeout_s: 0.0,- ..IntakeSinkConfig::default()- })- .err()- .ok_or_else(|| SwitchyardError::Other("zero timeout should fail".to_string()))?;-- match error {- SwitchyardError::InvalidConfig(message) => {- assert!(message.contains("request_timeout_s must be finite and positive"));- }- other => {- return Err(SwitchyardError::Other(format!(- "expected invalid config error, got {other:?}"- )));- }- }- Ok(())-}--#[test]-fn http_intake_sink_rejects_zero_queue_size() -> Result<()> {- let error = HttpIntakeSink::new(IntakeSinkConfig {- intake_base_url: Some("http://localhost:1".to_string()),- max_queue_size: 0,- ..IntakeSinkConfig::default()- })- .err()- .ok_or_else(|| SwitchyardError::Other("zero queue size should fail".to_string()))?;-- match error {- SwitchyardError::InvalidConfig(message) => {- assert!(message.contains("max_queue_size must be positive"));- }- other => {- return Err(SwitchyardError::Other(format!(- "expected invalid config error, got {other:?}"- )));- }- }- Ok(())-}--// An unauthenticated flat-document target posts to its full URL and must not-// send the bearer token even when an api_key is configured.-#[tokio::test]-async fn http_intake_sink_posts_to_flat_target_url_without_auth() -> Result<()> {- let server = OneShotServer::json(201, json!({"status": "Created"}))?;- let sink = HttpIntakeSink::new(IntakeSinkConfig {- target: Some(IntakeTarget {- url: format!("{}/lake/switchyard/posting", server.base_url()),- format: IntakeFormat::FlatDocument,- authenticated: false,- }),- // Set but must not be sent for an unauthenticated target.- api_key: Some("secret-token".to_string()),- ..IntakeSinkConfig::default()- })?;-- sink.enqueue(json!({"_id": "x", "s_source": "switchyard", "l_switchyard_input_tokens": 19}))- .await?;- sink.shutdown().await?;- let request = server.captured()?;-- assert_eq!(request.method, "POST");- assert_eq!(request.path, "/lake/switchyard/posting");- assert_eq!(request.header("authorization"), None);- assert_eq!(request.body["s_source"], "switchyard");- assert_eq!(request.body["l_switchyard_input_tokens"], 19);- Ok(())-}diff --git a/crates/switchyard-components/tests/intake_payload.rs b/crates/switchyard-components/tests/intake_payload.rsdeleted file mode 100644index 0d91c1301..000000000--- a/crates/switchyard-components/tests/intake_payload.rs+++ /dev/null@@ -1,561 +0,0 @@-// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-// SPDX-License-Identifier: Apache-2.0--//! Intake payload tests for chat-completions ingest payload shape and metadata.--mod support;--use serde_json::{Value, json};-use switchyard_components::{- ChatRequest, ChatRequestType, LlmTargetId, ModelId, ProxyContext, Result,-};-use switchyard_components::{- IntakeFormat, IntakePayloadBuilder, IntakeRequestMetadata, IntakeRequestState,- IntakeSinkConfig, IntakeTarget, RandomRoutingDecision, RandomRoutingTier, RequestMetadata,- StatsRouteLabel, SubModelCall,-};--use support::intake::{- completion, completion_with_usage, openai_chat_request, record_backend_selection,-};--// Test helper mirrors runtime telemetry version resolution.-fn expected_switchyard_version() -> String {- std::env::var("SWITCHYARD_VERSION")- .ok()- .map(|value| value.trim().to_string())- .filter(|value| !value.is_empty())- .unwrap_or_else(|| env!("CARGO_PKG_VERSION").to_string())-}--fn assert_chat_completions_ingest_shape(payload: &Value) {- assert!(payload.get("request").is_some());- assert!(payload.get("response").is_some());- assert_eq!(payload["provider"], "switchyard");-- // The nemo-platform chat-completions ingest schema is strict. These legacy- // entry-envelope fields do not belong on chat-completions ingest payloads.- for key in ["data", "context", "external_id", "usage"] {- assert!(payload.get(key).is_none(), "unexpected top-level key {key}");- }-}--// Responses requests are normalized to Chat payloads and synthetic stream IDs are hidden.-#[test]-fn payload_builder_normalizes_responses_request_and_strips_synthetic_response_id() -> Result<()> {- let builder = IntakePayloadBuilder::new(IntakeSinkConfig {- workspace: Some("default".to_string()),- capture_content: true,- ..IntakeSinkConfig::default()- });- let request = ChatRequest::openai_responses(json!({- "model": "gpt-4o",- "input": "say hi"- }));- let mut ctx = ProxyContext::new();- record_backend_selection(&mut ctx, ModelId::from_static("gpt-4o"));- ctx.insert(RequestMetadata {- intake: IntakeRequestMetadata {- app: Some("codex".to_string()),- task: Some("developer-session".to_string()),- ..IntakeRequestMetadata::default()- },- ..RequestMetadata::default()- });- ctx.insert(IntakeRequestState {- started_at_ms: 1_700_000_000_000,- inbound_format: ChatRequestType::OpenAiResponses,- session_id: Some("session-123".to_string()),- skip: false,- request_snapshot: Some(request.clone()),- });- let payload_ctx = switchyard_components::intake::IntakePayloadContext::from_proxy_context(- &ctx,- Some(1_700_000_001_840),- );-- let payload = builder.build(- &payload_ctx,- &request,- &completion("chatcmpl-switchyard-stream", "hello"),- true,- )?;-- assert_eq!(payload["request"]["messages"][0]["content"], "say hi");- assert_eq!(- payload["request"]["switchyard"]["inbound_format"],- "openai_responses"- );- assert_eq!(payload["request"]["stream"], false);- assert_eq!(payload["request"]["switchyard"]["stream"], true);- assert!(payload["request"]["switchyard"].get("app").is_none());- assert!(payload["request"]["switchyard"].get("task").is_none());- assert_eq!(- payload["evaluation_context"]["evaluation_run_id"],- "session-123"- );- assert_eq!(- payload["evaluation_context"]["test_case_id"],- "developer-session"- );- assert_eq!(payload["request"]["switchyard"]["latency_ms"], 1840);- assert!(payload["response"].get("id").is_none());- assert_eq!(payload["provider"], "switchyard");- assert!(payload["response"].get("switchyard").is_none());- Ok(())-}--// Response payloads carry token usage; Switchyard timing stays under request metadata.-#[test]-fn payload_carries_response_usage_and_switchyard_timing() -> Result<()> {- let builder = IntakePayloadBuilder::new(IntakeSinkConfig {- workspace: Some("default".to_string()),- ..IntakeSinkConfig::default()- });- let request = openai_chat_request("openai/openai/gpt-5.2");- let mut ctx = ProxyContext::new();- record_backend_selection(&mut ctx, ModelId::from_static("openai/openai/gpt-5.2"));- ctx.insert(IntakeRequestState {- started_at_ms: 1_700_000_000_000,- inbound_format: ChatRequestType::OpenAiChat,- session_id: None,- skip: false,- request_snapshot: Some(request.clone()),- });- let payload_ctx = switchyard_components::intake::IntakePayloadContext::from_proxy_context(- &ctx,- Some(1_700_000_001_840),- );-- let payload = builder.build(- &payload_ctx,- &request,- &completion_with_usage(- "chatcmpl-test",- "openai/openai/gpt-5.2",- "hello",- Some(json!({"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15})),- ),- false,- )?;-- assert_eq!(payload["response"]["model"], "openai/openai/gpt-5.2");- assert_eq!(payload["response"]["usage"]["prompt_tokens"], 10);- assert_eq!(payload["response"]["usage"]["completion_tokens"], 5);- assert_eq!(payload["cost_usd"], 0.000088);- assert_eq!(payload["cost_input_usd"], 0.000018);- assert_eq!(payload["cost_output_usd"], 0.00007);- assert_eq!(payload["cost_details"]["base_input"], 0.000018);- assert_eq!(payload["cost_details"]["cached_input"], 0.0);- assert_eq!(payload["cost_details"]["cache_write"], 0.0);- assert_chat_completions_ingest_shape(&payload);- let request_switchyard = &payload["request"]["switchyard"];- assert!(request_switchyard.get("served_model").is_none());- assert!(request_switchyard.get("started_at_ms").is_none());- assert!(request_switchyard.get("ended_at_ms").is_none());- assert!(request_switchyard.get("duration_ms").is_none());- assert_eq!(request_switchyard["latency_ms"], 1840);- assert_eq!(request_switchyard["stream"], false);- assert_eq!(request_switchyard["inbound_format"], "openai_chat");- assert_eq!(request_switchyard["version"], expected_switchyard_version());- assert!(payload["response"].get("switchyard").is_none());- Ok(())-}--// Random routing decisions should survive into intake routing metadata.-#[test]-fn payload_carries_random_routing_metadata_from_typed_context() -> Result<()> {- let builder = IntakePayloadBuilder::new(IntakeSinkConfig::default());- let request = openai_chat_request("client-model");- let mut ctx = ProxyContext::new();- record_backend_selection(&mut ctx, ModelId::from_static("weak-model"));- ctx.insert(RandomRoutingDecision {- tier: RandomRoutingTier::Weak,- selected_target: LlmTargetId::from_static("weak"),- selected_model: ModelId::from_static("weak-model"),- original_model: Some("client-model".to_string()),- strong_probability: 0.5,- draw: 0.75,- });- ctx.insert(IntakeRequestState {- started_at_ms: 1_700_000_000_000,- inbound_format: ChatRequestType::OpenAiChat,- session_id: None,- skip: false,- request_snapshot: Some(request.clone()),- });- let payload_ctx =- switchyard_components::intake::IntakePayloadContext::from_proxy_context(&ctx, None);-- let payload = builder.build(- &payload_ctx,- &request,- &completion_with_usage("chatcmpl-test", "weak-model", "hello", None),- false,- )?;-- let routing = &payload["request"]["switchyard"]["routing"];- assert_eq!(routing["router_type"], "random");- assert_eq!(routing["routed_to"], "weak");- Ok(())-}--// Generic stats route labels fill the routing payload when no router decision exists.-#[test]-fn payload_carries_custom_route_label_when_no_random_decision_exists() -> Result<()> {- let builder = IntakePayloadBuilder::new(IntakeSinkConfig::default());- let request = openai_chat_request("client-model");- let mut ctx = ProxyContext::new();- ctx.insert(StatsRouteLabel::new("plugin-tier"));- ctx.insert(IntakeRequestState {- started_at_ms: 1_700_000_000_000,- inbound_format: ChatRequestType::OpenAiChat,- session_id: None,- skip: false,- request_snapshot: Some(request.clone()),- });- let payload_ctx =- switchyard_components::intake::IntakePayloadContext::from_proxy_context(&ctx, None);-- let payload = builder.build(- &payload_ctx,- &request,- &completion_with_usage("chatcmpl-test", "plugin-model", "hello", None),- false,- )?;-- let routing = &payload["request"]["switchyard"]["routing"];- assert_eq!(routing["router_type"], "custom");- assert_eq!(routing["routed_to"], "plugin-tier");- Ok(())-}--// Unknown models still report token usage but do not invent chat-completions cost fields.-#[test]-fn payload_usage_omits_cost_for_unknown_model_even_with_tokens() -> Result<()> {- let builder = IntakePayloadBuilder::new(IntakeSinkConfig {- workspace: Some("default".to_string()),- ..IntakeSinkConfig::default()- });- let request = openai_chat_request("made-up-model");- let mut ctx = ProxyContext::new();- record_backend_selection(&mut ctx, ModelId::from_static("made-up-model"));- ctx.insert(IntakeRequestState {- started_at_ms: 1_700_000_000_000,- inbound_format: ChatRequestType::OpenAiChat,- session_id: None,- skip: false,- request_snapshot: Some(request.clone()),- });- let payload_ctx =- switchyard_components::intake::IntakePayloadContext::from_proxy_context(&ctx, None);-- let payload = builder.build(- &payload_ctx,- &request,- &completion_with_usage(- "chatcmpl-test",- "made-up-model",- "hello",- Some(json!({"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15})),- ),- false,- )?;-- assert_eq!(payload["response"]["model"], "made-up-model");- assert_eq!(payload["response"]["usage"]["prompt_tokens"], 10);- assert_eq!(payload["response"]["usage"]["completion_tokens"], 5);- assert!(payload.get("cost_usd").is_none());- assert!(payload.get("cost_input_usd").is_none());- assert!(payload.get("cost_output_usd").is_none());- assert!(payload.get("cost_details").is_none());- assert_chat_completions_ingest_shape(&payload);- Ok(())-}--// Known models without token usage should not produce partial chat-completions cost fields.-#[test]-fn payload_usage_omits_cost_when_tokens_are_missing_for_known_model() -> Result<()> {- let builder = IntakePayloadBuilder::new(IntakeSinkConfig {- workspace: Some("default".to_string()),- ..IntakeSinkConfig::default()- });- let request = openai_chat_request("openai/openai/gpt-5.2");- let mut ctx = ProxyContext::new();- record_backend_selection(&mut ctx, ModelId::from_static("openai/openai/gpt-5.2"));- ctx.insert(IntakeRequestState {- started_at_ms: 1_700_000_000_000,- inbound_format: ChatRequestType::OpenAiChat,- session_id: None,- skip: false,- request_snapshot: Some(request.clone()),- });- let payload_ctx =- switchyard_components::intake::IntakePayloadContext::from_proxy_context(&ctx, None);-- let payload = builder.build(- &payload_ctx,- &request,- &completion_with_usage("chatcmpl-test", "openai/openai/gpt-5.2", "hello", None),- false,- )?;-- assert_eq!(payload["response"]["model"], "openai/openai/gpt-5.2");- assert!(payload["response"].get("usage").is_none());- assert_chat_completions_ingest_shape(&payload);- Ok(())-}--// Missing backend selection should be represented as null, not as the request model.-#[test]-fn payload_usage_uses_null_model_when_served_model_is_missing() -> Result<()> {- let builder = IntakePayloadBuilder::new(IntakeSinkConfig {- workspace: Some("default".to_string()),- ..IntakeSinkConfig::default()- });- let request = openai_chat_request("openai/openai/gpt-5.2");- let mut ctx = ProxyContext::new();- ctx.insert(IntakeRequestState {- started_at_ms: 1_700_000_000_000,- inbound_format: ChatRequestType::OpenAiChat,- session_id: None,- skip: false,- request_snapshot: Some(request.clone()),- });- let payload_ctx =- switchyard_components::intake::IntakePayloadContext::from_proxy_context(&ctx, None);-- let payload = builder.build(- &payload_ctx,- &request,- &completion_with_usage(- "chatcmpl-test",- "openai/openai/gpt-5.2",- "hello",- Some(json!({"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15})),- ),- false,- )?;-- assert!(- payload["request"]["switchyard"]- .get("served_model")- .is_none()- );- Ok(())-}--// A flat-document target flattens the record into top-level, type-prefixed fields.-#[test]-fn payload_builds_flat_document_when_target_is_flat() -> Result<()> {- let builder = IntakePayloadBuilder::new(IntakeSinkConfig {- user_id: "0badf00d".to_string(),- target: Some(IntakeTarget {- url: "https://example.invalid/posting".to_string(),- format: IntakeFormat::FlatDocument,- authenticated: false,- }),- ..IntakeSinkConfig::default()- });- let request = openai_chat_request("openai/openai/gpt-5.2");- let mut ctx = ProxyContext::new();- record_backend_selection(&mut ctx, ModelId::from_static("openai/openai/gpt-5.2"));- ctx.insert(RandomRoutingDecision {- tier: RandomRoutingTier::Weak,- selected_target: LlmTargetId::from_static("weak"),- selected_model: ModelId::from_static("openai/openai/gpt-5.2"),- original_model: Some("openai/openai/gpt-5.2".to_string()),- strong_probability: 0.5,- draw: 0.75,- });- ctx.insert(IntakeRequestState {- started_at_ms: 1_700_000_000_000,- inbound_format: ChatRequestType::OpenAiChat,- session_id: Some("claude-smoke-0001".to_string()),- skip: false,- request_snapshot: Some(request.clone()),- });- let payload_ctx = switchyard_components::intake::IntakePayloadContext::from_proxy_context(- &ctx,- Some(1_700_000_001_840),- );-- let payload = builder.build(- &payload_ctx,- &request,- &completion_with_usage(- "chatcmpl-test",- "openai/openai/gpt-5.2",- "hello",- Some(json!({"prompt_tokens": 25000, "completion_tokens": 6580, "total_tokens": 31580})),- ),- false,- )?;-- // Flat schema: no nested request/response envelope, all metrics top-level.- assert!(payload.get("request").is_none());- assert!(payload.get("response").is_none());- assert_eq!(payload["s_source"], "switchyard");- assert_eq!(payload["s_record_type"], "switchyard_request");- assert_eq!(payload["l_schema_version"], 1);- assert_eq!(payload["ts_created"], 1_700_000_001_840i64);- assert_eq!(payload["_id"], "claude-smoke-0001-1700000001840");- assert_eq!(payload["s_switchyard_session_id"], "claude-smoke-0001");- assert_eq!(payload["s_switchyard_user_id"], "0badf00d");- assert_eq!(- payload["s_switchyard_served_model"],- "openai/openai/gpt-5.2"- );- assert_eq!(payload["s_switchyard_inbound_format"], "openai_chat");- assert_eq!(payload["s_switchyard_router_type"], "random");- assert_eq!(payload["s_switchyard_routed_to"], "weak");- assert_eq!(payload["b_switchyard_routed"], true);- assert_eq!(payload["l_switchyard_input_tokens"], 25000);- assert_eq!(payload["l_switchyard_output_tokens"], 6580);- assert_eq!(payload["l_switchyard_total_tokens"], 31580);- assert_eq!(payload["l_switchyard_latency_ms"], 1840);- assert!(payload["f_switchyard_cost_usd"].is_number());- assert!(payload["text_switchyard_record_json"].is_string());- Ok(())-}--// Sub-model routing records reuse the turn's context but carry the router's own-// model/usage/route, and each gets a distinct flat-document _id so the primary-// record and every routing call coexist instead of overwriting one another.-#[test]-fn submodel_records_get_distinct_flat_ids_and_router_fields() -> Result<()> {- let builder = IntakePayloadBuilder::new(IntakeSinkConfig {- user_id: "0badf00d".to_string(),- target: Some(IntakeTarget {- url: "https://example.invalid/posting".to_string(),- format: IntakeFormat::FlatDocument,- authenticated: false,- }),- ..IntakeSinkConfig::default()- });- let request = openai_chat_request("openai/openai/gpt-5.2");- let mut ctx = ProxyContext::new();- record_backend_selection(&mut ctx, ModelId::from_static("openai/openai/gpt-5.2"));- ctx.insert(IntakeRequestState {- started_at_ms: 1_700_000_000_000,- inbound_format: ChatRequestType::OpenAiChat,- session_id: Some("sess-1".to_string()),- skip: false,- request_snapshot: Some(request.clone()),- });- let payload_ctx = switchyard_components::intake::IntakePayloadContext::from_proxy_context(- &ctx,- Some(1_700_000_001_840),- );-- // Primary turn record and two routing calls share one session + timestamp.- let primary = builder.build(- &payload_ctx,- &request,- &completion_with_usage(- "chatcmpl-test",- "openai/openai/gpt-5.2",- "hello",- Some(json!({"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15})),- ),- false,- )?;- let call = SubModelCall {- model: "gcp/google/gemini-3.5-flash".to_string(),- prompt_tokens: 1200,- completion_tokens: 80,- cached_tokens: 0,- router_type: "deterministic".to_string(),- routed_to: "classifier".to_string(),- };- let first = builder.build_submodel_record(&payload_ctx, &call, 0)?;- let second = builder.build_submodel_record(&payload_ctx, &call, 1)?;-- // Distinct _id per record so nothing overwrites another in the data lake.- assert_eq!(primary["_id"], "sess-1-1700000001840");- assert_eq!(first["_id"], "sess-1-1700000001840-classifier-0");- assert_eq!(second["_id"], "sess-1-1700000001840-classifier-1");-- // The routing record carries the router's own model, usage, and route label.- assert_eq!(- first["s_switchyard_requested_model"],- "gcp/google/gemini-3.5-flash"- );- assert_eq!(- first["s_switchyard_served_model"],- "gcp/google/gemini-3.5-flash"- );- assert_eq!(first["s_switchyard_router_type"], "deterministic");- assert_eq!(first["s_switchyard_routed_to"], "classifier");- assert_eq!(first["l_switchyard_input_tokens"], 1200);- assert_eq!(first["l_switchyard_output_tokens"], 80);- // Start stamp is dropped for routing calls, so no turn-wide latency leaks in.- assert!(first.get("l_switchyard_latency_ms").is_none());- Ok(())-}--// Default is metadata-only: no prompt/response text in the document, metrics kept.-#[test]-fn flat_document_is_metadata_only_by_default() -> Result<()> {- let builder = IntakePayloadBuilder::new(IntakeSinkConfig {- target: Some(IntakeTarget {- url: "https://example.invalid/posting".to_string(),- format: IntakeFormat::FlatDocument,- authenticated: false,- }),- ..IntakeSinkConfig::default()- });- let request = ChatRequest::openai_chat(json!({- "model": "openai/openai/gpt-5.2",- "messages": [- {"role": "system", "content": "SENTINEL_SYSTEM_PROMPT"},- {"role": "user", "content": "SENTINEL_USER_PROMPT"}- ],- "tools": [{"type": "function", "function": {"name": "SENTINEL_TOOL"}}],- "functions": [{"name": "SENTINEL_LEGACY_FUNCTION"}],- "function_call": {"name": "SENTINEL_FUNCTION_CALL"}- }));- let mut ctx = ProxyContext::new();- record_backend_selection(&mut ctx, ModelId::from_static("openai/openai/gpt-5.2"));- ctx.insert(IntakeRequestState {- started_at_ms: 1_700_000_000_000,- inbound_format: ChatRequestType::OpenAiChat,- session_id: Some("sess-1".to_string()),- skip: false,- request_snapshot: Some(request.clone()),- });- let payload_ctx = switchyard_components::intake::IntakePayloadContext::from_proxy_context(- &ctx,- Some(1_700_000_001_840),- );-- let doc = builder.build(- &payload_ctx,- &request,- &completion_with_usage(- "chatcmpl-test",- "openai/openai/gpt-5.2",- "SENTINEL_RESPONSE_TEXT",- Some(json!({"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15})),- ),- false,- )?;-- let serialized = serde_json::to_string(&doc).unwrap();- for sentinel in [- "SENTINEL_SYSTEM_PROMPT",- "SENTINEL_USER_PROMPT",- "SENTINEL_TOOL",- "SENTINEL_LEGACY_FUNCTION",- "SENTINEL_FUNCTION_CALL",- "SENTINEL_RESPONSE_TEXT",- ] {- assert!(!serialized.contains(sentinel), "leaked content: {sentinel}");- }-- assert_eq!(doc["s_switchyard_served_model"], "openai/openai/gpt-5.2");- assert_eq!(doc["l_switchyard_input_tokens"], 10);- assert_eq!(doc["l_switchyard_output_tokens"], 5);- assert!(doc["f_switchyard_cost_usd"].is_number());- Ok(())-}diff --git a/crates/switchyard-components/tests/intake_request_processor.rs b/crates/switchyard-components/tests/intake_request_processor.rsdeleted file mode 100644index 88a873afc..000000000--- a/crates/switchyard-components/tests/intake_request_processor.rs+++ /dev/null@@ -1,156 +0,0 @@-// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-// SPDX-License-Identifier: Apache-2.0--mod support;--use std::collections::BTreeMap;--use serde_json::json;-use switchyard_components::{ChatRequest, ChatRequestType, ProxyContext, Result, SwitchyardError};-use switchyard_components::{- IntakeRequestMetadata, IntakeRequestProcessor, IntakeRequestState, RequestMetadata,-};--use support::intake::request;--#[test]-fn request_metadata_extracts_only_explicit_intake_fields_case_insensitively() -> Result<()> {- let headers = BTreeMap::from([- ("Proxy_X_Session_ID".to_string(), "sess-1".to_string()),- (- "X-Switchyard-Intake-Enabled".to_string(),- "true".to_string(),- ),- (- "x-switchyard-intake-app".to_string(),- "log2/codex".to_string(),- ),- (- "x-switchyard-intake-task".to_string(),- "developer-session".to_string(),- ),- ("authorization".to_string(), "Bearer secret".to_string()),- ]);-- let metadata = RequestMetadata::from_headers(&headers);-- assert_eq!(metadata.session_id.as_deref(), Some("sess-1"));- assert_eq!(metadata.intake.enabled, Some(true));- assert_eq!(metadata.intake.app.as_deref(), Some("log2/codex"));- assert_eq!(metadata.intake.task.as_deref(), Some("developer-session"));- Ok(())-}--#[tokio::test]-async fn request_processor_skips_by_default_and_stamps_session() -> Result<()> {- let processor = IntakeRequestProcessor;- let mut ctx = ProxyContext::new();- ctx.insert(RequestMetadata {- session_id: Some("session-123".to_string()),- ..RequestMetadata::default()- });-- let processed = processor.process(&mut ctx, request()).await?;-- assert_eq!(processed.model(), Some("gpt-4o"));- let state = ctx- .get::<IntakeRequestState>()- .ok_or_else(|| SwitchyardError::Other("intake state missing".to_string()))?;- assert_eq!(state.session_id.as_deref(), Some("session-123"));- assert_eq!(state.inbound_format, ChatRequestType::OpenAiChat);- assert!(state.skip);- assert!(state.request_snapshot.is_none());- Ok(())-}--#[tokio::test]-async fn request_processor_store_true_opts_in_when_header_absent() -> Result<()> {- let processor = IntakeRequestProcessor;- let mut ctx = ProxyContext::new();- let original = ChatRequest::openai_chat(json!({- "model": "gpt-4o",- "messages": [{"role": "user", "content": "hi"}],- "store": true- }));-- let processed = processor.process(&mut ctx, original.clone()).await?;- let state = ctx- .get::<IntakeRequestState>()- .ok_or_else(|| SwitchyardError::Other("intake state missing".to_string()))?;-- assert_eq!(processed, original);- assert!(!state.skip);- assert_eq!(state.request_snapshot.as_ref(), Some(&original));- Ok(())-}--#[tokio::test]-async fn request_processor_header_overrides_store_toggle() -> Result<()> {- let processor = IntakeRequestProcessor;- let mut ctx = ProxyContext::new();- ctx.insert(RequestMetadata {- intake: IntakeRequestMetadata {- enabled: Some(false),- ..IntakeRequestMetadata::default()- },- ..RequestMetadata::default()- });- let request = ChatRequest::openai_chat(json!({- "model": "gpt-4o",- "messages": [],- "store": true- }));-- processor.process(&mut ctx, request).await?;-- let state = ctx- .get::<IntakeRequestState>()- .ok_or_else(|| SwitchyardError::Other("intake state missing".to_string()))?;- assert!(state.skip);- assert!(state.request_snapshot.is_none());- Ok(())-}--#[tokio::test]-async fn request_processor_header_true_opts_in_without_store_toggle() -> Result<()> {- let processor = IntakeRequestProcessor;- let mut ctx = ProxyContext::new();- ctx.insert(RequestMetadata {- intake: IntakeRequestMetadata {- enabled: Some(true),- ..IntakeRequestMetadata::default()- },- ..RequestMetadata::default()- });- let original = request();-- let processed = processor.process(&mut ctx, original.clone()).await?;-- let state = ctx- .get::<IntakeRequestState>()- .ok_or_else(|| SwitchyardError::Other("intake state missing".to_string()))?;- assert_eq!(processed, original);- assert!(!state.skip);- assert_eq!(state.request_snapshot.as_ref(), Some(&original));- Ok(())-}--#[tokio::test]-async fn request_processor_store_false_skips_when_header_absent() -> Result<()> {- let processor = IntakeRequestProcessor;- let mut ctx = ProxyContext::new();- let request = ChatRequest::openai_chat(json!({- "model": "gpt-4o",- "messages": [{"role": "user", "content": "hi"}],- "store": false- }));-- processor.process(&mut ctx, request).await?;-- let state = ctx- .get::<IntakeRequestState>()- .ok_or_else(|| SwitchyardError::Other("intake state missing".to_string()))?;- assert!(state.skip);- assert!(state.request_snapshot.is_none());- Ok(())-}diff --git a/crates/switchyard-components/tests/intake_response_processor.rs b/crates/switchyard-components/tests/intake_response_processor.rsdeleted file mode 100644index 7983f0330..000000000--- a/crates/switchyard-components/tests/intake_response_processor.rs+++ /dev/null@@ -1,585 +0,0 @@-// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-// SPDX-License-Identifier: Apache-2.0--//! Intake response processor tests for buffered, streaming, and fail-open paths.--mod support;--use std::sync::Arc;--use serde_json::json;-use switchyard_components::{- ChatRequestType, ChatResponse, ModelId, ProxyContext, Result, StreamEvent, SwitchyardError,-};-use switchyard_components::{- IntakeRequestState, IntakeResponseProcessor, IntakeSinkConfig, SubModelCall, SubModelCalls,-};--use support::intake::{- RecordingSink, completion, drain_stream, opted_in_context, record_backend_selection,-};--// Skip metadata should preserve the response and avoid sink writes.-#[tokio::test]-async fn response_processor_skip_metadata_leaves_response_untouched() -> Result<()> {- let sink = Arc::new(RecordingSink::default());- let processor = IntakeResponseProcessor::new(IntakeSinkConfig::default(), sink.clone());- let mut ctx = ProxyContext::new();- ctx.insert(IntakeRequestState {- started_at_ms: 1,- inbound_format: ChatRequestType::OpenAiChat,- session_id: None,- skip: true,- request_snapshot: None,- });-- let returned = processor- .process(&mut ctx, completion("chatcmpl-test", "world"))- .await?;-- assert!(matches!(returned, ChatResponse::OpenAiCompletion(_)));- assert!(sink.payloads()?.is_empty());- Ok(())-}--// Buffered responses should enqueue a single chat-completions ingest payload.-#[tokio::test]-async fn response_processor_enqueues_non_streaming_payload() -> Result<()> {- let sink = Arc::new(RecordingSink::default());- let processor = IntakeResponseProcessor::new(- IntakeSinkConfig {- workspace: Some("default".to_string()),- capture_content: true,- ..IntakeSinkConfig::default()- },- sink.clone(),- );- let mut ctx = opted_in_context();-- let returned = processor- .process(&mut ctx, completion("chatcmpl-test", "world"))- .await?;-- assert!(matches!(returned, ChatResponse::OpenAiCompletion(_)));- let payloads = sink.payloads()?;- assert_eq!(payloads.len(), 1);- assert_eq!(- payloads[0]["response"]["choices"][0]["message"]["content"],- "world"- );- assert!(payloads[0]["request"]["switchyard"].get("app").is_none());- assert_eq!(payloads[0]["session_id"], "session-123");- assert_eq!(payloads[0]["response"]["id"], "chatcmpl-test");- Ok(())-}--// Routing sub-model calls stashed on context each emit their own record next to-// the primary one, all through the same sink.-#[tokio::test]-async fn response_processor_emits_a_record_per_submodel_call() -> Result<()> {- let sink = Arc::new(RecordingSink::default());- let processor = IntakeResponseProcessor::new(- IntakeSinkConfig {- workspace: Some("default".to_string()),- ..IntakeSinkConfig::default()- },- sink.clone(),- );- let mut ctx = opted_in_context();- ctx.insert(SubModelCalls(vec![- SubModelCall {- model: "router-clf".to_string(),- prompt_tokens: 100,- completion_tokens: 10,- cached_tokens: 0,- router_type: "deterministic".to_string(),- routed_to: "classifier".to_string(),- },- SubModelCall {- model: "judge".to_string(),- prompt_tokens: 50,- completion_tokens: 5,- cached_tokens: 0,- router_type: "escalation_router".to_string(),- routed_to: "judge".to_string(),- },- ]));-- processor- .process(&mut ctx, completion("chatcmpl-test", "world"))- .await?;-- // One primary record plus one per routing call.- let payloads = sink.payloads()?;- assert_eq!(payloads.len(), 3);- let routed: Vec<&str> = payloads- .iter()- .filter_map(|payload| payload["request"]["switchyard"]["routing"]["routed_to"].as_str())- .collect();- assert!(routed.contains(&"classifier"));- assert!(routed.contains(&"judge"));- Ok(())-}--// The opt-in gate covers sub-model records too: a skipped turn emits nothing,-// even with routing calls stashed on context.-#[tokio::test]-async fn response_processor_skips_submodel_records_when_opted_out() -> Result<()> {- let sink = Arc::new(RecordingSink::default());- let processor = IntakeResponseProcessor::new(IntakeSinkConfig::default(), sink.clone());- let mut ctx = ProxyContext::new();- ctx.insert(IntakeRequestState {- started_at_ms: 1,- inbound_format: ChatRequestType::OpenAiChat,- session_id: None,- skip: true,- request_snapshot: None,- });- ctx.insert(SubModelCalls(vec![SubModelCall {- model: "router-clf".to_string(),- prompt_tokens: 100,- completion_tokens: 10,- cached_tokens: 0,- router_type: "deterministic".to_string(),- routed_to: "classifier".to_string(),- }]));-- processor- .process(&mut ctx, completion("chatcmpl-test", "world"))- .await?;-- assert!(sink.payloads()?.is_empty());- Ok(())-}--// Intake failures must be fail-open so user responses are not replaced.-#[tokio::test]-async fn response_processor_fail_open_when_payload_build_or_sink_enqueue_fails() -> Result<()> {- let missing_snapshot_sink = Arc::new(RecordingSink::default());- let processor =- IntakeResponseProcessor::new(IntakeSinkConfig::default(), missing_snapshot_sink.clone());- let mut missing_snapshot_ctx = ProxyContext::new();-- let returned = processor- .process(- &mut missing_snapshot_ctx,- completion("chatcmpl-test", "world"),- )- .await?;- assert!(matches!(returned, ChatResponse::OpenAiCompletion(_)));- assert!(missing_snapshot_sink.payloads()?.is_empty());-- let failing_sink = Arc::new(RecordingSink::with_error(SwitchyardError::Upstream(- "intake down".to_string(),- )));- let processor = IntakeResponseProcessor::new(IntakeSinkConfig::default(), failing_sink.clone());- let mut ctx = opted_in_context();- let returned = processor- .process(&mut ctx, completion("chatcmpl-test", "world"))- .await?;- assert!(matches!(returned, ChatResponse::OpenAiCompletion(_)));- assert!(failing_sink.payloads()?.is_empty());- Ok(())-}--// OpenAI streams should pass through unchanged and enqueue after stream completion.-#[tokio::test]-async fn response_processor_wraps_openai_stream_and_enqueues_after_stream_end() -> Result<()> {- let sink = Arc::new(RecordingSink::default());- let processor = IntakeResponseProcessor::new(- IntakeSinkConfig {- workspace: Some("default".to_string()),- capture_content: true,- ..IntakeSinkConfig::default()- },- sink.clone(),- );- let mut ctx = opted_in_context();- let events = vec![- StreamEvent::Json(json!({- "id": "chatcmpl-stream",- "object": "chat.completion.chunk",- "model": "gpt-4o",- "choices": [{"delta": {"content": "hel"}, "finish_reason": null}]- })),- StreamEvent::Json(json!({- "id": "chatcmpl-stream",- "object": "chat.completion.chunk",- "model": "gpt-4o",- "choices": [{"delta": {"content": "lo"}, "finish_reason": "stop"}],- "usage": {"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15}- })),- ];- let stream = futures_util::stream::iter(events.clone().into_iter().map(Ok));-- let returned = processor- .process(&mut ctx, ChatResponse::OpenAiStream(Box::pin(stream)))- .await?;- let drained = drain_stream(returned).await?;-- assert_eq!(drained, events);- let payloads = sink.payloads()?;- assert_eq!(payloads.len(), 1);- assert_eq!(- payloads[0]["response"]["choices"][0]["message"]["content"],- "hello"- );- assert_eq!(payloads[0]["response"]["usage"]["total_tokens"], 15);- Ok(())-}--// OpenAI streams without usage still produce a valid response payload.-#[tokio::test]-async fn response_processor_wraps_openai_stream_without_usage() -> Result<()> {- let sink = Arc::new(RecordingSink::default());- let processor = IntakeResponseProcessor::new(- IntakeSinkConfig {- workspace: Some("default".to_string()),- capture_content: true,- ..IntakeSinkConfig::default()- },- sink.clone(),- );- let mut ctx = opted_in_context();- let events = vec![- StreamEvent::Json(json!({- "id": "chatcmpl-stream",- "object": "chat.completion.chunk",- "model": "gpt-4o",- "choices": [{"delta": {"content": "hel"}, "finish_reason": null}]- })),- StreamEvent::Json(json!({- "id": "chatcmpl-stream",- "object": "chat.completion.chunk",- "model": "gpt-4o",- "choices": [{"delta": {"content": "lo"}, "finish_reason": "stop"}]- })),- ];- let stream = futures_util::stream::iter(events.clone().into_iter().map(Ok));-- let returned = processor- .process(&mut ctx, ChatResponse::OpenAiStream(Box::pin(stream)))- .await?;- let drained = drain_stream(returned).await?;-- assert_eq!(drained, events);- let payloads = sink.payloads()?;- assert_eq!(payloads.len(), 1);- assert_eq!(- payloads[0]["response"]["choices"][0]["message"]["content"],- "hello"- );- assert!(payloads[0]["response"].get("usage").is_none());- Ok(())-}--// OpenAI stream capture must preserve tool-call deltas and reasoning fields.-#[tokio::test]-async fn response_processor_wraps_openai_stream_tool_calls_and_reasoning() -> Result<()> {- let sink = Arc::new(RecordingSink::default());- let processor = IntakeResponseProcessor::new(- IntakeSinkConfig {- capture_content: true,- ..IntakeSinkConfig::default()- },- sink.clone(),- );- let mut ctx = opted_in_context();- let events = vec![- StreamEvent::Json(json!({- "id": "chatcmpl-tools",- "object": "chat.completion.chunk",- "model": "gpt-4o",- "choices": [{- "delta": {- "reasoning_content": "private ",- "tool_calls": [{- "index": 0,- "id": "call_1",- "type": "function",- "function": {"name": "search", "arguments": "{\"q\":"}- }]- },- "finish_reason": null- }]- })),- StreamEvent::Json(json!({- "id": "chatcmpl-tools",- "object": "chat.completion.chunk",- "model": "gpt-4o",- "choices": [{- "delta": {- "reasoning_content": "reasoning",- "tool_calls": [{- "index": 0,- "function": {"arguments": "\"x\"}"}- }]- },- "finish_reason": "tool_calls"- }]- })),- ];- let stream = futures_util::stream::iter(events.clone().into_iter().map(Ok));-- let returned = processor- .process(&mut ctx, ChatResponse::OpenAiStream(Box::pin(stream)))- .await?;- let drained = drain_stream(returned).await?;-- assert_eq!(drained, events);- let payloads = sink.payloads()?;- let message = &payloads[0]["response"]["choices"][0]["message"];- assert_eq!(message["reasoning_content"], "private reasoning");- assert_eq!(message["tool_calls"][0]["id"], "call_1");- assert_eq!(- message["tool_calls"][0]["function"]["arguments"],- "{\"q\":\"x\"}"- );- assert_eq!(- payloads[0]["response"]["choices"][0]["finish_reason"],- "tool_calls"- );- Ok(())-}--// Anthropic stream usage should become OpenAI-style prompt/completion usage.-#[tokio::test]-async fn response_processor_wraps_anthropic_stream_usage() -> Result<()> {- let sink = Arc::new(RecordingSink::default());- let processor = IntakeResponseProcessor::new(- IntakeSinkConfig {- capture_content: true,- ..IntakeSinkConfig::default()- },- sink.clone(),- );- let mut ctx = opted_in_context();- record_backend_selection(&mut ctx, ModelId::from_static("claude-opus-4-6"));- let events = vec![- StreamEvent::Json(json!({- "type": "message_start",- "message": {- "id": "msg_123",- "model": "claude-opus-4-6",- "usage": {"input_tokens": 7}- }- })),- StreamEvent::Json(json!({- "type": "content_block_delta",- "index": 0,- "delta": {"type": "text_delta", "text": "hello"}- })),- StreamEvent::Json(json!({- "type": "message_delta",- "delta": {"stop_reason": "end_turn"},- "usage": {"output_tokens": 3}- })),- StreamEvent::Json(json!({"type": "message_stop"})),- ];- let stream = futures_util::stream::iter(events.clone().into_iter().map(Ok));-- let returned = processor- .process(&mut ctx, ChatResponse::AnthropicStream(Box::pin(stream)))- .await?;- let drained = drain_stream(returned).await?;-- assert_eq!(drained, events);- let payloads = sink.payloads()?;- assert_eq!(- payloads[0]["response"]["choices"][0]["message"]["content"],- "hello"- );- assert_eq!(payloads[0]["response"]["usage"]["prompt_tokens"], 7);- assert_eq!(payloads[0]["response"]["usage"]["completion_tokens"], 3);- Ok(())-}--// Anthropic tool-use events should become OpenAI Chat tool calls in intake.-#[tokio::test]-async fn response_processor_wraps_anthropic_stream_tool_use() -> Result<()> {- let sink = Arc::new(RecordingSink::default());- let processor = IntakeResponseProcessor::new(- IntakeSinkConfig {- capture_content: true,- ..IntakeSinkConfig::default()- },- sink.clone(),- );- let mut ctx = opted_in_context();- record_backend_selection(&mut ctx, ModelId::from_static("claude-opus-4-6"));- let events = vec![- StreamEvent::Json(json!({- "type": "message_start",- "message": {"id": "msg_tools", "model": "claude-opus-4-6"}- })),- StreamEvent::Json(json!({- "type": "content_block_start",- "index": 0,- "content_block": {"type": "tool_use", "id": "toolu_1", "name": "search"}- })),- StreamEvent::Json(json!({- "type": "content_block_delta",- "index": 0,- "delta": {"type": "input_json_delta", "partial_json": "{\"q\":\"x\"}"}- })),- StreamEvent::Json(json!({- "type": "message_delta",- "delta": {"stop_reason": "tool_use"}- })),- StreamEvent::Json(json!({"type": "message_stop"})),- ];- let stream = futures_util::stream::iter(events.clone().into_iter().map(Ok));-- let returned = processor- .process(&mut ctx, ChatResponse::AnthropicStream(Box::pin(stream)))- .await?;- drain_stream(returned).await?;-- let payloads = sink.payloads()?;- let response = &payloads[0]["response"];- assert_eq!(response["choices"][0]["finish_reason"], "tool_calls");- assert_eq!(- response["choices"][0]["message"]["tool_calls"][0]["function"]["name"],- "search"- );- assert_eq!(- response["choices"][0]["message"]["tool_calls"][0]["function"]["arguments"],- "{\"q\":\"x\"}"- );- Ok(())-}--// Responses streams with completed response events should use the canonical response.-#[tokio::test]-async fn response_processor_wraps_responses_stream_completed_response() -> Result<()> {- let sink = Arc::new(RecordingSink::default());- let processor = IntakeResponseProcessor::new(- IntakeSinkConfig {- capture_content: true,- ..IntakeSinkConfig::default()- },- sink.clone(),- );- let mut ctx = opted_in_context();- record_backend_selection(&mut ctx, ModelId::from_static("gpt-4o"));- let response_body = json!({- "id": "resp_123",- "object": "response",- "created_at": 1_700_000_000,- "model": "gpt-4o",- "output": [{- "type": "message",- "id": "msg_123",- "status": "completed",- "role": "assistant",- "content": [{- "type": "output_text",- "text": "hello",- "annotations": []- }]- }],- "status": "completed",- "parallel_tool_calls": true,- "tool_choice": "auto",- "tools": [],- "text": {"format": {"type": "text"}},- "usage": {- "input_tokens": 11,- "output_tokens": 4,- "total_tokens": 15,- "input_tokens_details": {"cached_tokens": 0},- "output_tokens_details": {"reasoning_tokens": 0}- }- });- let events = vec![- StreamEvent::Json(json!({"type": "response.output_text.delta", "delta": "hello"})),- StreamEvent::Json(json!({- "type": "response.completed",- "response": response_body- })),- ];- let stream = futures_util::stream::iter(events.clone().into_iter().map(Ok));-- let returned = processor- .process(- &mut ctx,- ChatResponse::OpenAiResponsesStream(Box::pin(stream)),- )- .await?;- let drained = drain_stream(returned).await?;-- assert_eq!(drained, events);- let payloads = sink.payloads()?;- assert_eq!(- payloads[0]["response"]["choices"][0]["message"]["content"],- "hello"- );- assert_eq!(payloads[0]["response"]["usage"]["prompt_tokens"], 11);- assert_eq!(payloads[0]["response"]["usage"]["completion_tokens"], 4);- Ok(())-}--// Responses streams without a completed event should synthesize the final response.-#[tokio::test]-async fn response_processor_wraps_responses_stream_function_call_without_completed_event()--> Result<()> {- let sink = Arc::new(RecordingSink::default());- let processor = IntakeResponseProcessor::new(- IntakeSinkConfig {- capture_content: true,- ..IntakeSinkConfig::default()- },- sink.clone(),- );- let mut ctx = opted_in_context();- record_backend_selection(&mut ctx, ModelId::from_static("gpt-4o"));- let events = vec![- StreamEvent::Json(json!({- "type": "response.output_item.added",- "output_index": 0,- "item": {- "type": "function_call",- "id": "fc_1",- "call_id": "call_1",- "name": "search",- "arguments": ""- }- })),- StreamEvent::Json(json!({- "type": "response.function_call_arguments.delta",- "output_index": 0,- "delta": "{\"q\":\"x\"}"- })),- ];- let stream = futures_util::stream::iter(events.clone().into_iter().map(Ok));-- let returned = processor- .process(- &mut ctx,- ChatResponse::OpenAiResponsesStream(Box::pin(stream)),- )- .await?;- drain_stream(returned).await?;-- let payloads = sink.payloads()?;- let message = &payloads[0]["response"]["choices"][0]["message"];- assert_eq!(message["tool_calls"][0]["id"], "call_1");- assert_eq!(message["tool_calls"][0]["function"]["name"], "search");- assert_eq!(- message["tool_calls"][0]["function"]["arguments"],- "{\"q\":\"x\"}"- );- Ok(())-}--// Shutdown should delegate to the configured sink exactly once.-#[tokio::test]-async fn response_processor_delegates_shutdown_to_sink() -> Result<()> {- let sink = Arc::new(RecordingSink::default());- let processor = IntakeResponseProcessor::new(IntakeSinkConfig::default(), sink.clone());-- processor.shutdown().await?;-- assert_eq!(sink.shutdowns()?, 1);- Ok(())-}diff --git a/crates/switchyard-components/tests/support/intake.rs b/crates/switchyard-components/tests/support/intake.rsdeleted file mode 100644index 0867d5f66..000000000--- a/crates/switchyard-components/tests/support/intake.rs+++ /dev/null@@ -1,169 +0,0 @@-// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-// SPDX-License-Identifier: Apache-2.0--#![allow(dead_code)]--//! Shared intake fixtures used by payload and processor tests.--use async_trait::async_trait;-use futures_util::StreamExt;-use parking_lot::Mutex;-use serde_json::{Value, json};-use switchyard_components::{- BackendSelection, BackendSelectionReason, IntakeRequestMetadata, IntakeRequestState,- IntakeSink, RequestMetadata,-};-use switchyard_components::{- ChatRequest, ChatRequestType, ChatResponse, ModelId, ProxyContext, Result, StreamEvent,- SwitchyardError,-};--/// In-memory sink that records payloads and shutdown calls.-#[derive(Default)]-pub struct RecordingSink {- /// Payloads accepted by the fake sink.- payloads: Mutex<Vec<Value>>,- /// Optional one-shot error returned by `enqueue`.- error: Mutex<Option<SwitchyardError>>,- /// Number of times shutdown was invoked.- shutdowns: Mutex<u64>,-}--impl RecordingSink {- /// Creates a sink whose first enqueue returns an error.- pub fn with_error(error: SwitchyardError) -> Self {- Self {- payloads: Mutex::new(Vec::new()),- error: Mutex::new(Some(error)),- shutdowns: Mutex::new(0),- }- }-- /// Returns the payloads captured so far.- pub fn payloads(&self) -> Result<Vec<Value>> {- Ok(self.payloads.lock().clone())- }-- /// Returns the shutdown count captured so far.- pub fn shutdowns(&self) -> Result<u64> {- Ok(*self.shutdowns.lock())- }-}--#[async_trait]-impl IntakeSink for RecordingSink {- async fn enqueue(&self, payload: Value) -> Result<()> {- if let Some(error) = self.error.lock().take() {- return Err(error);- }- self.payloads.lock().push(payload);- Ok(())- }-- async fn shutdown(&self) -> Result<()> {- let mut shutdowns = self.shutdowns.lock();- *shutdowns = shutdowns.saturating_add(1);- Ok(())- }-}--/// Builds the default OpenAI Chat request used by intake tests.-pub fn request() -> ChatRequest {- ChatRequest::openai_chat(json!({- "model": "gpt-4o",- "messages": [{"role": "user", "content": "hi"}]- }))-}--/// Builds an OpenAI Chat request with a caller-selected model.-pub fn openai_chat_request(model: &str) -> ChatRequest {- ChatRequest::openai_chat(json!({- "model": model,- "messages": [{"role": "user", "content": "hi"}]- }))-}--/// Builds a standard OpenAI completion with usage.-pub fn completion(id: &str, content: &str) -> ChatResponse {- completion_with_usage(- id,- "gpt-4o",- content,- Some(json!({"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15})),- )-}--/// Builds a standard OpenAI completion with caller-selected usage.-pub fn completion_with_usage(- id: &str,- model: &str,- content: &str,- usage: Option<Value>,-) -> ChatResponse {- let mut body = json!({- "id": id,- "object": "chat.completion",- "created": 1_700_000_000,- "model": model,- "choices": [{- "index": 0,- "message": {"role": "assistant", "content": content},- "finish_reason": "stop"- }]- });- if let (Value::Object(object), Some(usage)) = (&mut body, usage) {- object.insert("usage".to_string(), usage);- }- ChatResponse::openai_completion(body)-}--/// Builds a proxy context that has opted into intake capture.-pub fn opted_in_context() -> ProxyContext {- let mut ctx = ProxyContext::new();- record_backend_selection(&mut ctx, ModelId::from_static("gpt-4o"));- ctx.insert(RequestMetadata {- session_id: Some("session-123".to_string()),- intake: IntakeRequestMetadata {- enabled: Some(true),- app: Some("codex".to_string()),- task: Some("developer-session".to_string()),- },- });- ctx.insert(IntakeRequestState {- started_at_ms: 1_700_000_000_000,- inbound_format: ChatRequestType::OpenAiChat,- session_id: Some("session-123".to_string()),- skip: false,- request_snapshot: Some(request()),- });- ctx-}--/// Records a backend selection in the typed proxy context.-pub fn record_backend_selection(ctx: &mut ProxyContext, model: ModelId) {- let _ = ctx.insert(BackendSelection::for_model(- model,- None,- BackendSelectionReason::PassthroughModel,- ));-}--/// Drains a streaming response into a vector of stream events.-pub async fn drain_stream(response: ChatResponse) -> Result<Vec<StreamEvent>> {- let mut stream = match response {- ChatResponse::OpenAiStream(stream)- | ChatResponse::OpenAiResponsesStream(stream)- | ChatResponse::AnthropicStream(stream) => stream,- other => {- return Err(SwitchyardError::Other(format!(- "expected stream, got {:?}",- other.response_type()- )));- }- };- let mut events = Vec::new();- while let Some(event) = stream.next().await {- events.push(event?);- }- Ok(events)-}diff --git a/crates/switchyard-components/tests/support/mod.rs b/crates/switchyard-components/tests/support/mod.rsindex 69c1f1690..6a0744c89 100644--- a/crates/switchyard-components/tests/support/mod.rs+++ b/crates/switchyard-components/tests/support/mod.rs@@ -15,7 +15,6 @@ use serde_json::Value;use switchyard_components::{Result, SwitchyardError};pub mod config;-pub mod intake;/// One HTTP request captured by a local mock server.#[derive(Debug)]diff --git a/crates/switchyard-py/src/component_bindings.rs b/crates/switchyard-py/src/component_bindings.rsindex 5965811c9..43a672805 100644--- a/crates/switchyard-py/src/component_bindings.rs+++ b/crates/switchyard-py/src/component_bindings.rs@@ -8,7 +8,6 @@ use pyo3::prelude::*;mod backends;pub(crate) mod config;mod dimension_collector;-pub(crate) mod intake;mod request_processors;mod response_processors;mod stage_router;@@ -16,7 +15,6 @@ pub(crate) mod stats;pub(crate) fn register(module: &Bound<'_, PyModule>) -> PyResult<()> {config::register(module)?;- intake::register(module)?;stats::register(module)?;request_processors::register(module)?;response_processors::register(module)?;diff --git a/crates/switchyard-py/src/component_bindings/config.rs b/crates/switchyard-py/src/component_bindings/config.rsindex f37eaafdd..7ce3644e5 100644--- a/crates/switchyard-py/src/component_bindings/config.rs+++ b/crates/switchyard-py/src/component_bindings/config.rs@@ -8,10 +8,8 @@ use pyo3::exceptions::PyValueError;use pyo3::prelude::*;use pyo3::types::PyBool;use serde::Serialize;-use switchyard_components::{BackendFormat, EndpointConfig, LlmTarget, LlmTargetId, ModelId};use switchyard_components::{- IntakeFormat, IntakeQueueFullPolicy, IntakeSinkConfig, IntakeTarget,- RandomRoutingProcessorConfig,+ BackendFormat, EndpointConfig, LlmTarget, LlmTargetId, ModelId, RandomRoutingProcessorConfig,};use crate::errors::py_core_error;@@ -454,233 +452,6 @@ impl PyRandomRoutingProcessorConfig {}}-#[pyclass(name = "IntakeQueueFullPolicy", frozen, eq, skip_from_py_object)]-#[derive(Clone, Copy, Debug, Eq, PartialEq)]-pub(crate) struct PyIntakeQueueFullPolicy {- inner: IntakeQueueFullPolicy,-}--impl PyIntakeQueueFullPolicy {- const fn new_inner(inner: IntakeQueueFullPolicy) -> Self {- Self { inner }- }-}--#[pymethods]-impl PyIntakeQueueFullPolicy {- #[new]- #[pyo3(signature = (value="drop"))]- fn py_new(value: &str) -> PyResult<Self> {- Ok(Self {- inner: intake_queue_policy_from_str(value)?,- })- }-- #[classattr]- const DROP: Self = Self::new_inner(IntakeQueueFullPolicy::Drop);-- #[classattr]- const BLOCK: Self = Self::new_inner(IntakeQueueFullPolicy::Block);-- #[getter]- fn value(&self) -> &'static str {- intake_queue_policy_name(self.inner)- }-- fn __repr__(&self) -> String {- format!(- "IntakeQueueFullPolicy.{}",- intake_queue_policy_variant_name(self.inner)- )- }-- fn __str__(&self) -> &'static str {- intake_queue_policy_name(self.inner)- }-- fn __hash__(&self) -> isize {- match self.inner {- IntakeQueueFullPolicy::Drop => 1,- IntakeQueueFullPolicy::Block => 2,- }- }-}--#[pyclass(name = "IntakeSinkConfig", frozen, skip_from_py_object)]-#[derive(Clone, Debug)]-pub(crate) struct PyIntakeSinkConfig {- inner: IntakeSinkConfig,-}--impl PyIntakeSinkConfig {- pub(crate) fn from_core(inner: IntakeSinkConfig) -> Self {- Self { inner }- }-- pub(crate) fn clone_core(&self) -> IntakeSinkConfig {- self.inner.clone()- }-}--#[pymethods]-impl PyIntakeSinkConfig {- #[new]- #[allow(clippy::too_many_arguments)]- #[pyo3(signature = (- intake_base_url=None,- workspace=None,- user_id=None,- api_key=None,- target_url=None,- target_format=None,- target_authenticated=None,- max_queue_size=None,- request_timeout_s=None,- max_retries=None,- on_queue_full=None,- capture_content=None- ))]- fn py_new(- intake_base_url: Option<String>,- workspace: Option<String>,- user_id: Option<String>,- api_key: Option<String>,- target_url: Option<String>,- target_format: Option<String>,- target_authenticated: Option<bool>,- max_queue_size: Option<usize>,- request_timeout_s: Option<f64>,- max_retries: Option<u32>,- on_queue_full: Option<&Bound<'_, PyAny>>,- capture_content: Option<bool>,- ) -> PyResult<Self> {- let mut config = IntakeSinkConfig::default();- if intake_base_url.is_some() {- config.intake_base_url = intake_base_url;- }- if workspace.is_some() {- config.workspace = workspace;- }- if let Some(user_id) = user_id {- config.user_id = user_id;- }- if api_key.is_some() {- config.api_key = api_key;- }- if let Some(url) = target_url {- config.target = Some(IntakeTarget {- url,- format: intake_format_from_str(target_format.as_deref())?,- authenticated: target_authenticated.unwrap_or(false),- });- }- if let Some(max_queue_size) = max_queue_size {- config.max_queue_size = max_queue_size;- }- if let Some(request_timeout_s) = request_timeout_s {- config.request_timeout_s = request_timeout_s;- }- if let Some(max_retries) = max_retries {- config.max_retries = max_retries;- }- if on_queue_full.is_some() {- config.on_queue_full = intake_queue_policy_from_python(on_queue_full)?;- }- config.capture_content = capture_content.unwrap_or_else(intake_capture_content_from_env);- Ok(Self { inner: config })- }-- #[getter]- fn intake_base_url(&self) -> Option<String> {- self.inner.intake_base_url.clone()- }-- #[getter]- fn workspace(&self) -> Option<String> {- self.inner.workspace.clone()- }-- #[getter]- fn user_id(&self) -> String {- self.inner.user_id.clone()- }-- #[getter]- fn target_url(&self) -> Option<String> {- self.inner.target.as_ref().map(|target| target.url.clone())- }-- #[getter]- fn target_format(&self) -> Option<String> {- self.inner- .target- .as_ref()- .map(|target| intake_format_name(target.format).to_string())- }-- #[getter]- fn target_authenticated(&self) -> Option<bool> {- self.inner- .target- .as_ref()- .map(|target| target.authenticated)- }-- #[getter]- fn api_key(&self) -> Option<String> {- self.inner.api_key.clone()- }-- #[getter]- fn max_queue_size(&self) -> usize {- self.inner.max_queue_size- }-- #[getter]- fn request_timeout_s(&self) -> f64 {- self.inner.request_timeout_s- }-- #[getter]- fn max_retries(&self) -> u32 {- self.inner.max_retries- }-- #[getter]- fn on_queue_full(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {- intake_queue_policy_object(py, self.inner.on_queue_full)- }-- #[getter]- fn capture_content(&self) -> bool {- self.inner.capture_content- }-- fn to_dict(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {- to_python(py, &self.inner)- }-- fn __repr__(&self) -> String {- format!(- "IntakeSinkConfig(intake_base_url={:?}, workspace={:?}, user_id={:?}, api_key={}, target={:?}, max_queue_size={}, request_timeout_s={}, max_retries={}, on_queue_full='{}', capture_content={})",- self.inner.intake_base_url,- self.inner.workspace,- self.inner.user_id,- if self.inner.api_key.is_some() {- "'<redacted>'"- } else {- "None"- },- self.inner.target,- self.inner.max_queue_size,- self.inner.request_timeout_s,- self.inner.max_retries,- intake_queue_policy_name(self.inner.on_queue_full),- self.inner.capture_content,- )- }-}-pub(crate) fn backend_format_from_python(value: Option<&Bound<'_, PyAny>>,) -> PyResult<BackendFormat> {@@ -747,90 +518,6 @@ pub(crate) fn endpoint_config_from_python(.map_err(|error| PyValueError::new_err(error.to_string()))}-/// Reads `SWITCHYARD_INTAKE_CAPTURE_CONTENT`; false (metadata-only) unless truthy.-fn intake_capture_content_from_env() -> bool {- std::env::var("SWITCHYARD_INTAKE_CAPTURE_CONTENT")- .ok()- .map(|value| {- matches!(- value.trim().to_ascii_lowercase().as_str(),- "1" | "true" | "yes" | "on"- )- })- .unwrap_or(false)-}--fn intake_queue_policy_from_python(- value: Option<&Bound<'_, PyAny>>,-) -> PyResult<IntakeQueueFullPolicy> {- let Some(value) = value.filter(|value| !value.is_none()) else {- return Ok(IntakeQueueFullPolicy::default());- };- if let Ok(policy) = value.extract::<PyRef<'_, PyIntakeQueueFullPolicy>>() {- return Ok(policy.inner);- }- let raw = if let Ok(value_attr) = value.getattr("value") {- value_attr.extract::<String>()?- } else {- value.extract::<String>()?- };- intake_queue_policy_from_str(&raw)-}--fn intake_queue_policy_from_str(value: &str) -> PyResult<IntakeQueueFullPolicy> {- match value {- "drop" => Ok(IntakeQueueFullPolicy::Drop),- "block" => Ok(IntakeQueueFullPolicy::Block),- _ => Err(PyValueError::new_err(format!(- "Unknown intake queue-full policy: {value:?}"- ))),- }-}--fn intake_queue_policy_name(policy: IntakeQueueFullPolicy) -> &'static str {- match policy {- IntakeQueueFullPolicy::Drop => "drop",- IntakeQueueFullPolicy::Block => "block",- }-}--/// Parses the Python `target_format` kwarg into an `IntakeFormat`.-///-/// Defaults to the flat document shape, since an explicit target is a data-lake-/// posting endpoint for every current caller.-fn intake_format_from_str(value: Option<&str>) -> PyResult<IntakeFormat> {- match value.unwrap_or("flat_document") {- "flat_document" => Ok(IntakeFormat::FlatDocument),- "chat_completions" => Ok(IntakeFormat::ChatCompletions),- other => Err(PyValueError::new_err(format!(- "invalid target_format {other:?}; expected 'flat_document' or 'chat_completions'"- ))),- }-}--fn intake_format_name(format: IntakeFormat) -> &'static str {- match format {- IntakeFormat::FlatDocument => "flat_document",- IntakeFormat::ChatCompletions => "chat_completions",- }-}--fn intake_queue_policy_variant_name(policy: IntakeQueueFullPolicy) -> &'static str {- match policy {- IntakeQueueFullPolicy::Drop => "DROP",- IntakeQueueFullPolicy::Block => "BLOCK",- }-}--fn intake_queue_policy_object(- py: Python<'_>,- policy: IntakeQueueFullPolicy,-) -> PyResult<Py<PyAny>> {- py.get_type::<PyIntakeQueueFullPolicy>()- .getattr(intake_queue_policy_variant_name(policy))- .map(Bound::unbind)-}-fn to_python(py: Python<'_>, value: &impl Serialize) -> PyResult<Py<PyAny>> {let value =serde_json::to_value(value).map_err(|error| PyValueError::new_err(error.to_string()))?;@@ -842,7 +529,5 @@ pub(crate) fn register(module: &Bound<'_, PyModule>) -> PyResult<()> {module.add_class::<PyEndpointConfig>()?;module.add_class::<PyLlmTarget>()?;module.add_class::<PyRandomRoutingProcessorConfig>()?;- module.add_class::<PyIntakeQueueFullPolicy>()?;- module.add_class::<PyIntakeSinkConfig>()?;Ok(())}diff --git a/crates/switchyard-py/src/component_bindings/intake.rs b/crates/switchyard-py/src/component_bindings/intake.rsdeleted file mode 100644index 6cbe36348..000000000--- a/crates/switchyard-py/src/component_bindings/intake.rs+++ /dev/null@@ -1,224 +0,0 @@-// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-// SPDX-License-Identifier: Apache-2.0--//! Python bindings for Rust-owned intake metadata values.--use std::collections::BTreeMap;--use pyo3::class::basic::CompareOp;-use pyo3::exceptions::{PyTypeError, PyValueError};-use pyo3::prelude::*;-use pyo3::types::{PyBool, PyDict, PyType};-use serde::Serialize;-use switchyard_components::{IntakeRequestMetadata, RequestMetadata};--use crate::interop::context::insert_into_python;-use crate::py_serde::value_to_python;--#[pyclass(name = "IntakeRequestMetadata", frozen, skip_from_py_object)]-#[derive(Clone, Debug)]-pub(crate) struct PyIntakeRequestMetadata {- inner: IntakeRequestMetadata,-}--impl PyIntakeRequestMetadata {- fn from_core(inner: IntakeRequestMetadata) -> Self {- Self { inner }- }-- fn clone_core(&self) -> IntakeRequestMetadata {- self.inner.clone()- }-}--#[pymethods]-impl PyIntakeRequestMetadata {- #[new]- #[pyo3(signature = (enabled=None, app=None, task=None))]- fn py_new(enabled: Option<bool>, app: Option<String>, task: Option<String>) -> Self {- Self {- inner: IntakeRequestMetadata { enabled, app, task },- }- }-- #[getter]- fn enabled(&self) -> Option<bool> {- self.inner.enabled- }-- #[getter]- fn app(&self) -> Option<String> {- self.inner.app.clone()- }-- #[getter]- fn task(&self) -> Option<String> {- self.inner.task.clone()- }-- fn to_dict(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {- to_python(py, &self.inner)- }-- fn __richcmp__(- &self,- py: Python<'_>,- other: &Bound<'_, PyAny>,- op: CompareOp,- ) -> PyResult<Py<PyAny>> {- match op {- CompareOp::Eq | CompareOp::Ne => {- let equals = other- .extract::<PyRef<'_, Self>>()- .map(|other| self.inner == other.inner)- .unwrap_or(false);- let result = if matches!(op, CompareOp::Eq) {- equals- } else {- !equals- };- Ok(PyBool::new(py, result).to_owned().unbind().into_any())- }- _ => Ok(py.NotImplemented()),- }- }-- fn __repr__(&self) -> String {- format!(- "IntakeRequestMetadata(enabled={:?}, app={:?}, task={:?})",- self.inner.enabled, self.inner.app, self.inner.task,- )- }-}--#[pyclass(name = "RequestMetadata", frozen, skip_from_py_object)]-#[derive(Clone, Debug)]-pub(crate) struct PyRequestMetadata {- inner: RequestMetadata,-}--impl PyRequestMetadata {- fn from_core(inner: RequestMetadata) -> Self {- Self { inner }- }-- pub(crate) fn clone_core(&self) -> RequestMetadata {- self.inner.clone()- }-}--#[pymethods]-impl PyRequestMetadata {- #[new]- #[pyo3(signature = (session_id=None, intake=None))]- fn py_new(- session_id: Option<String>,- intake: Option<PyRef<'_, PyIntakeRequestMetadata>>,- ) -> Self {- Self {- inner: RequestMetadata {- session_id,- intake: intake- .map(|metadata| metadata.clone_core())- .unwrap_or_default(),- },- }- }-- #[classmethod]- fn from_headers(_cls: &Bound<'_, PyType>, headers: &Bound<'_, PyAny>) -> PyResult<Self> {- Ok(Self::from_core(RequestMetadata::from_headers(- &headers_to_map(headers)?,- )))- }-- #[getter]- fn session_id(&self) -> Option<String> {- self.inner.session_id.clone()- }-- #[getter]- fn intake(&self) -> PyIntakeRequestMetadata {- PyIntakeRequestMetadata::from_core(self.inner.intake.clone())- }-- fn to_dict(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {- to_python(py, &self.inner)- }-- fn apply_to_context(&self, ctx: &Bound<'_, PyAny>) -> PyResult<()> {- insert_into_python(ctx, self.clone_core())- }-- fn __richcmp__(- &self,- py: Python<'_>,- other: &Bound<'_, PyAny>,- op: CompareOp,- ) -> PyResult<Py<PyAny>> {- match op {- CompareOp::Eq | CompareOp::Ne => {- let equals = other- .extract::<PyRef<'_, Self>>()- .map(|other| self.inner == other.inner)- .unwrap_or(false);- let result = if matches!(op, CompareOp::Eq) {- equals- } else {- !equals- };- Ok(PyBool::new(py, result).to_owned().unbind().into_any())- }- _ => Ok(py.NotImplemented()),- }- }-- fn __repr__(&self) -> String {- format!(- "RequestMetadata(session_id={:?}, intake={:?})",- self.inner.session_id, self.inner.intake,- )- }-}--fn headers_to_map(headers: &Bound<'_, PyAny>) -> PyResult<BTreeMap<String, String>> {- let dict = PyDict::new(headers.py());- dict.call_method1("update", (headers,))?;- dict.iter()- .map(|(key, value)| Ok((key.extract::<String>()?, value.extract::<String>()?)))- .collect()-}--fn to_python(py: Python<'_>, value: &impl Serialize) -> PyResult<Py<PyAny>> {- let value =- serde_json::to_value(value).map_err(|error| PyValueError::new_err(error.to_string()))?;- value_to_python(py, &value)-}--pub(crate) fn request_metadata_from_mapping(- py: Python<'_>,- metadata: &Bound<'_, PyAny>,-) -> PyResult<Option<RequestMetadata>> {- let dict = PyDict::new(py);- dict.call_method1("update", (metadata,))?;- let Some(value) = dict.get_item("_request_metadata")? else {- return Ok(None);- };- if value.is_none() {- return Ok(None);- }- let request_metadata = value- .extract::<PyRef<'_, PyRequestMetadata>>()- .map_err(|_| {- PyTypeError::new_err(- "ProxyContext metadata['_request_metadata'] must be a RequestMetadata value",- )- })?;- Ok(Some(request_metadata.clone_core()))-}--pub(crate) fn register(module: &Bound<'_, PyModule>) -> PyResult<()> {- module.add_class::<PyIntakeRequestMetadata>()?;- module.add_class::<PyRequestMetadata>()?;- Ok(())-}diff --git a/crates/switchyard-py/src/component_bindings/request_processors.rs b/crates/switchyard-py/src/component_bindings/request_processors.rsindex 0fec58d5d..19a133c3d 100644--- a/crates/switchyard-py/src/component_bindings/request_processors.rs+++ b/crates/switchyard-py/src/component_bindings/request_processors.rs@@ -4,9 +4,7 @@//! Python bindings for concrete request-side compatibility components.use pyo3::prelude::*;-use switchyard_components::{- IntakeRequestProcessor, StatsRequestProcessor, tracking_enabled_from_env,-};+use switchyard_components::{StatsRequestProcessor, tracking_enabled_from_env};use crate::errors::py_core_error;use crate::interop::context::lease_from_python;@@ -58,51 +56,7 @@ impl PyStatsRequestProcessor {}}-#[pyclass(name = "IntakeRequestProcessor", skip_from_py_object)]-#[derive(Clone, Copy, Debug, Default)]-pub(crate) struct PyIntakeRequestProcessor;--#[pymethods]-impl PyIntakeRequestProcessor {- #[new]- fn py_new() -> Self {- Self- }-- fn startup<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {- pyo3_async_runtimes::tokio::future_into_py(py, async { Ok(()) })- }-- fn shutdown<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {- pyo3_async_runtimes::tokio::future_into_py(py, async { Ok(()) })- }-- fn process<'py>(- &self,- py: Python<'py>,- ctx: &Bound<'_, PyAny>,- request: &Bound<'_, PyAny>,- ) -> PyResult<Bound<'py, PyAny>> {- let mut lease = lease_from_python(ctx)?;- let request = request_from_python(request)?;- pyo3_async_runtimes::tokio::future_into_py(py, async move {- let result = IntakeRequestProcessor- .process(lease.context_mut()?, request)- .await;- let restore_result = lease.restore();- let request = result.map_err(py_core_error)?;- restore_result?;- Python::attach(|py| request_to_python(py, request))- })- }-- fn __repr__(&self) -> &'static str {- "IntakeRequestProcessor()"- }-}-pub(crate) fn register(module: &Bound<'_, PyModule>) -> PyResult<()> {module.add_class::<PyStatsRequestProcessor>()?;- module.add_class::<PyIntakeRequestProcessor>()?;Ok(())}diff --git a/crates/switchyard-py/src/component_bindings/response_processors.rs b/crates/switchyard-py/src/component_bindings/response_processors.rsindex f8072ac40..eccaf5444 100644--- a/crates/switchyard-py/src/component_bindings/response_processors.rs+++ b/crates/switchyard-py/src/component_bindings/response_processors.rs@@ -4,9 +4,8 @@//! Python bindings for concrete response-side components.use pyo3::prelude::*;-use switchyard_components::{IntakeResponseProcessor, StatsResponseProcessor};+use switchyard_components::StatsResponseProcessor;-use super::config::PyIntakeSinkConfig;use super::stats::PyStatsAccumulator;use crate::errors::py_core_error;use crate::interop::context::lease_from_python;@@ -74,64 +73,7 @@ impl PyStatsResponseProcessor {}}-#[pyclass(name = "IntakeResponseProcessor", skip_from_py_object)]-#[derive(Clone, Debug)]-pub(crate) struct PyIntakeResponseProcessor {- inner: IntakeResponseProcessor,- config: PyIntakeSinkConfig,-}--#[pymethods]-impl PyIntakeResponseProcessor {- #[new]- fn py_new(config: PyRef<'_, PyIntakeSinkConfig>) -> PyResult<Self> {- let config = PyIntakeSinkConfig::from_core(config.clone_core());- let inner =- IntakeResponseProcessor::with_http_sink(config.clone_core()).map_err(py_core_error)?;- Ok(Self { inner, config })- }-- #[getter]- fn config(&self) -> PyIntakeSinkConfig {- self.config.clone()- }-- fn startup<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {- pyo3_async_runtimes::tokio::future_into_py(py, async { Ok(()) })- }-- fn shutdown<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {- let processor = self.inner.clone();- pyo3_async_runtimes::tokio::future_into_py(py, async move {- processor.shutdown().await.map_err(py_core_error)- })- }-- fn process<'py>(- &self,- py: Python<'py>,- ctx: &Bound<'_, PyAny>,- response: &Bound<'_, PyAny>,- ) -> PyResult<Bound<'py, PyAny>> {- let processor = self.inner.clone();- let mut lease = lease_from_python(ctx)?;- let response = response_from_python(response)?;- pyo3_async_runtimes::tokio::future_into_py(py, async move {- let result = processor.process(lease.context_mut()?, response).await;- let restore_result = lease.restore();- let response = result.map_err(py_core_error)?;- restore_result?;- Python::attach(|py| response_to_python(py, response))- })- }-- fn __repr__(&self) -> &'static str {- "IntakeResponseProcessor()"- }-}-pub(crate) fn register(module: &Bound<'_, PyModule>) -> PyResult<()> {module.add_class::<PyStatsResponseProcessor>()?;- module.add_class::<PyIntakeResponseProcessor>()?;Ok(())}diff --git a/crates/switchyard-py/src/interop/context.rs b/crates/switchyard-py/src/interop/context.rsindex d4d541b00..cd84bde3e 100644--- a/crates/switchyard-py/src/interop/context.rs+++ b/crates/switchyard-py/src/interop/context.rs@@ -9,15 +9,10 @@ use std::sync::atomic::{AtomicBool, Ordering};use parking_lot::{Mutex, MutexGuard};use pyo3::exceptions::{PyRuntimeError, PyValueError};use pyo3::prelude::*;-use pyo3::types::PyDict;use std::time::Duration;-use switchyard_components::{- BackendSelection, BackendSelectionReason, StatsBackendLatency, SubModelCall, SubModelCalls,-};+use switchyard_components::{BackendSelection, BackendSelectionReason, StatsBackendLatency};use switchyard_components::{EvictedTargets, LlmTargetId, ModelId, ProxyContext, RequestId};-use crate::component_bindings::intake::request_metadata_from_mapping;-use super::request::{request_type_from_python, request_type_object};/// Python-facing proxy context backed by the Rust `ProxyContext`.@@ -150,18 +145,14 @@ impl Drop for PyProxyContextLease {#[pymethods]impl PyProxyContext {- /// Creates a Python proxy context from optional metadata and request ID.+ /// Creates a context with a validated native request ID.+ ///+ /// Metadata is accepted for Python compatibility but remains in the+ /// Python-owned `ProxyMetadata` rather than the native context.#[new]#[pyo3(signature = (metadata=None, request_id=None))]- fn new(- py: Python<'_>,- metadata: Option<&Bound<'_, PyAny>>,- request_id: Option<String>,- ) -> PyResult<Self> {- let request_metadata = match metadata {- Some(metadata) if !metadata.is_none() => request_metadata_from_mapping(py, metadata)?,- _ => None,- };+ fn new(metadata: Option<&Bound<'_, PyAny>>, request_id: Option<String>) -> PyResult<Self> {+ let _ = metadata;let request_id = request_id.map(RequestId::new).transpose()@@ -171,9 +162,6 @@ impl PyProxyContext {let mut inner = ProxyContext::default();inner.request_id = request_id;- if let Some(request_metadata) = request_metadata {- inner.insert(request_metadata);- }Ok(Self {inner: Arc::new(Mutex::new(inner)),@@ -181,67 +169,6 @@ impl PyProxyContext {})}- /// Records one routing-strategy sub-model call for intake capture.- ///- /// Routers that call a model to pick a route (the LLM classifier, the- /// stage-router tier classifier or escalation judge) call this after a- /// successful routing call so the response-side intake processor can emit- /// each as its own anonymous record — model and token counts only, never the- /// messages. Appends to a Rust-typed slot the native intake sink reads, so- /// the routing record shares the primary record's transport and opt-in.- #[pyo3(signature = (model, prompt_tokens, completion_tokens, cached_tokens, router_type, routed_to))]- fn record_submodel_call(- &self,- model: String,- prompt_tokens: i64,- completion_tokens: i64,- cached_tokens: i64,- router_type: String,- routed_to: String,- ) -> PyResult<()> {- let call = SubModelCall {- model,- prompt_tokens,- completion_tokens,- cached_tokens,- router_type,- routed_to,- };- let mut guard = self.lock()?;- match guard.get_mut::<SubModelCalls>() {- Some(calls) => calls.0.push(call),- None => {- guard.insert(SubModelCalls(vec![call]));- }- }- Ok(())- }-- /// Returns the routing sub-model calls recorded on this context.- ///- /// Each entry is a dict with `model`, `prompt_tokens`, `completion_tokens`,- /// `cached_tokens`, `router_type`, and `routed_to`; the list is empty when no- /// routing call was recorded. Lets Python observe what- /// [`record_submodel_call`] stashed for the intake sink.- #[getter]- fn submodel_calls(&self, py: Python<'_>) -> PyResult<Vec<Py<PyDict>>> {- let calls = self.get_cloned::<SubModelCalls>()?.unwrap_or_default();- calls- .0- .into_iter()- .map(|call| {- let dict = PyDict::new(py);- dict.set_item("model", call.model)?;- dict.set_item("prompt_tokens", call.prompt_tokens)?;- dict.set_item("completion_tokens", call.completion_tokens)?;- dict.set_item("cached_tokens", call.cached_tokens)?;- dict.set_item("router_type", call.router_type)?;- dict.set_item("routed_to", call.routed_to)?;- Ok(dict.unbind())- })- .collect()- }-/// Returns the optional request ID.#[getter]fn request_id(&self) -> PyResult<Option<String>> {diff --git a/examples/experimental/litellm/uv.lock b/examples/experimental/litellm/uv.lockindex 46a16cd0e..35b70c60a 100644--- a/examples/experimental/litellm/uv.lock+++ b/examples/experimental/litellm/uv.lock@@ -839,7 +839,7 @@ wheels = [[[package]]name = "nemo-switchyard"-version = "0.1.0"+version = "0.2.0"source = { editable = "../../../" }dependencies = [{ name = "anthropic" },@@ -854,8 +854,7 @@ requires-dist = [{ name = "ddtrace", marker = "extra == 'tracing'", specifier = ">=2.9,<4" },{ name = "fastapi", marker = "extra == 'server'", specifier = ">=0.136.1,<1.0" },{ name = "httpx", specifier = ">=0.28.1,<1.0" },- { name = "nemo-platform", marker = "extra == 'intake'", specifier = ">=0.1.0,<1.0" },- { name = "nemo-switchyard", extras = ["server", "cli", "tracing", "intake", "affinity-redis"], marker = "extra == 'all'" },+ { name = "nemo-switchyard", extras = ["server", "cli", "tracing", "affinity-redis"], marker = "extra == 'all'" },{ name = "openai", specifier = ">=2.7,<3.0" },{ name = "prompt-toolkit", marker = "extra == 'cli'", specifier = ">=3.0.52,<4.0" },{ name = "pydantic", specifier = ">=2.13.3,<3.0" },@@ -863,7 +862,7 @@ requires-dist = [{ name = "sse-starlette", marker = "extra == 'server'", specifier = ">=3.4.1,<4.0" },{ name = "uvicorn", extras = ["standard"], marker = "extra == 'server'", specifier = ">=0.46.0,<1.0" },]-provides-extras = ["server", "cli", "tracing", "intake", "affinity-redis", "all"]+provides-extras = ["server", "cli", "tracing", "affinity-redis", "all"][package.metadata.requires-dev]dev = [diff --git a/pyproject.toml b/pyproject.tomlindex 2f83ce324..f39163c35 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -63,13 +63,6 @@ tracing = ["ddtrace>=2.9,<4",]-# Intake — NeMo Platform SDK required by IntakeClient for telemetry capture.-# Only needed when --intake-enabled is passed to ``switchyard serve``.-# Install with: pip install nemo-switchyard[intake]-intake = [- "nemo-platform>=0.1.0,<1.0",-]-# Shared session-affinity pin store. redis-py ships ``redis.asyncio`` natively,# so no separate async client is needed. Lazy-imported by# ``switchyard.lib.redis_pin_store`` — the default install never pulls it in.@@ -81,7 +74,7 @@ affinity-redis = [# Everything — all optional dependencies for full-featured deployment.all = [- "nemo-switchyard[server,cli,tracing,intake,affinity-redis]",+ "nemo-switchyard[server,cli,tracing,affinity-redis]",]# Dev tooling lives in a PEP 735 dependency group rather than an optionaldiff --git a/switchyard/__init__.py b/switchyard/__init__.pyindex c64530efa..83527c707 100644--- a/switchyard/__init__.py+++ b/switchyard/__init__.py@@ -36,12 +36,6 @@ from switchyard.lib.chat_response import (ResponseStream,StreamingChatResponse,)-from switchyard.lib.config import (- IntakeSinkConfig,-)-from switchyard.lib.processors.intake_payload_builder import IntakePayloadBuilder-from switchyard.lib.processors.intake_request_processor import IntakeRequestProcessor-from switchyard.lib.processors.intake_response_processor import IntakeResponseProcessorfrom switchyard.lib.processors.rl_logging_request_processor import RlLoggingRequestProcessorfrom switchyard.lib.processors.rl_logging_response_processor import RlLoggingResponseProcessorfrom switchyard.lib.profiles import (@@ -71,6 +65,7 @@ from switchyard.lib.profiles import (profile_config,profile_config_type,)+from switchyard.lib.request_metadata import RequestMetadatafrom switchyard.lib.roles import (LLMBackend,)@@ -170,10 +165,7 @@ __all__ = ["build_switchyard_app",# Route dispatch table"RouteTable",- "IntakePayloadBuilder",- "IntakeRequestProcessor",- "IntakeResponseProcessor",- "IntakeSinkConfig",+ "RequestMetadata","RlLoggingRequestProcessor","RlLoggingResponseProcessor",# Random Routing usage casediff --git a/switchyard/cli/intake_cli_config.py b/switchyard/cli/intake_cli_config.pydeleted file mode 100644index 814ddac0b..000000000--- a/switchyard/cli/intake_cli_config.py+++ /dev/null@@ -1,82 +0,0 @@-# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-# SPDX-License-Identifier: Apache-2.0--"""Resolve Intake options for ``switchyard serve``."""--import argparse-import os-from collections.abc import Mapping-from dataclasses import dataclass---@dataclass(frozen=True)-class IntakeCliConfig:- """Resolved Intake options for the Python server."""-- enabled: bool- base_url: str | None = None- workspace: str | None = None- api_key: str | None = None- target_url: str | None = None-- @classmethod- def from_server_args(- cls,- args: argparse.Namespace,- *,- env: Mapping[str, str] | None = None,- ) -> "IntakeCliConfig":- resolved_env = os.environ if env is None else env- base_url, workspace, api_key = _resolve_sink_connection(args, resolved_env)- return cls(- enabled=bool(getattr(args, "intake_enabled", False))- or _env_bool("SWITCHYARD_INTAKE_ENABLED", resolved_env),- base_url=base_url,- workspace=workspace,- api_key=api_key,- target_url=_arg_or_env(- args, "intake_target_url", resolved_env, "SWITCHYARD_INTAKE_TARGET_URL",- ),- )--def _resolve_sink_connection(- args: argparse.Namespace,- env: Mapping[str, str],-) -> tuple[str | None, str | None, str | None]:- return (- _arg_or_env(args, "intake_base_url", env, "SWITCHYARD_INTAKE_BASE_URL"),- _arg_or_env(args, "intake_workspace", env, "SWITCHYARD_INTAKE_WORKSPACE"),- _arg_or_env(- args,- "intake_api_key",- env,- "SWITCHYARD_INTAKE_API_KEY",- "NMP_ACCESS_TOKEN",- ),- )---def _arg_or_env(- args: argparse.Namespace,- attr: str,- env: Mapping[str, str],- *env_names: str,-) -> str | None:- arg_value = getattr(args, attr, None)- if arg_value:- return str(arg_value)- for env_name in env_names:- env_value = env.get(env_name)- if env_value:- return env_value- return None---def _env_bool(name: str, env: Mapping[str, str]) -> bool:- raw = env.get(name)- if raw is None:- return False- return raw.strip().lower() in {"1", "true", "yes", "on"}---__all__ = ["IntakeCliConfig"]diff --git a/switchyard/cli/route_bundle.py b/switchyard/cli/route_bundle.pyindex 70d7c1e85..a1d3d214b 100644--- a/switchyard/cli/route_bundle.py+++ b/switchyard/cli/route_bundle.py@@ -95,7 +95,7 @@ class RouteBundle:can share the same instance with downstream readers (live stats footer,``/v1/routing/stats``). ``None`` makes the builder create a fresh one.- Per-chain processor injection (Intake telemetry, custom hooks) is+ Per-chain processor injection (for example, custom hooks) iscall-site runtime state, not bundle data. ``serve`` and launchers may passprocessors through the table builder, but route YAML never declaresthose processors itself.@@ -347,8 +347,7 @@ def load_route_bundle_table(standalone ``switchyard serve`` callers want.``pre_routing_request_processors`` / ``extra_response_processors`` let- callers attach process-level components such as Intake telemetry to every- YAML-declared route.+ callers attach process-level components to every YAML-declared route."""return build_route_bundle_table(parse_routing_profiles_file(path),@@ -423,8 +422,8 @@ def build_table_from_bundle(``pre_routing_request_processors`` / ``extra_response_processors`` arecall-time kwargs (not bundle data). ``serve`` and launchers pass- process-level processors such as Intake here when CLI/env config enables- them; YAML routes never declare those processors themselves.+ process-level processors here; YAML routes never declare those processors+ themselves."""table = RouteTable()stats = bundle.stats_accumulator or StatsAccumulator()diff --git a/switchyard/cli/switchyard_cli.py b/switchyard/cli/switchyard_cli.pyindex cd82216b5..05e7dacce 100644--- a/switchyard/cli/switchyard_cli.py+++ b/switchyard/cli/switchyard_cli.py@@ -9,24 +9,17 @@ from __future__ import annotationsimport argparseimport loggingimport os-from collections.abc import Sequencefrom importlib.metadata import PackageNotFoundError, version-from inspect import signature-from typing import Anyfrom switchyard.cli.command_utils import (quiet_dependency_loggers as _quiet_dependency_loggers,)-from switchyard.cli.intake_cli_config import IntakeCliConfigfrom switchyard.cli.launch_command import (cmd_launch_claude,cmd_launch_codex,cmd_launch_openclaw,)from switchyard.cli.route_bundle import RouteBundleConfigError, load_route_bundle_table-from switchyard.lib.config import IntakeSinkConfig-from switchyard.lib.processors.intake_request_processor import IntakeRequestProcessor-from switchyard.lib.processors.intake_response_processor import IntakeResponseProcessorfrom switchyard.lib.processors.rl_logging_response_processor import build_rl_logging_processorsfrom switchyard.server.server_util import (add_transport_args,@@ -36,109 +29,12 @@ from switchyard.server.server_util import (logger = logging.getLogger(__name__)-_CANONICAL_INTAKE_ENABLE_FLAG = "--intake-enabled"-_DEPRECATED_INTAKE_ENABLE_FLAG = "--enable-intake"-_ARGPARSE_ACTION_SUPPORTS_DEPRECATED = (- "deprecated" in signature(argparse.Action.__init__).parameters-)---class _IntakeEnabledAction(argparse.Action):- """Normalize the Intake flag and warn on its deprecated alias."""-- def __init__(- self,- option_strings: Sequence[str],- dest: str,- nargs: int | str | None = None,- const: Any = None,- default: Any = None,- type: Any = None,- choices: Any = None,- required: bool = False,- help: str | None = None,- metavar: str | tuple[str, ...] | None = None,- deprecated: bool = False,- ) -> None:- del nargs- action_kwargs: dict[str, Any] = {- "option_strings": option_strings,- "dest": dest,- "nargs": 0,- "const": const,- "default": default,- "type": type,- "choices": choices,- "required": required,- "help": help,- "metavar": metavar,- }- if _ARGPARSE_ACTION_SUPPORTS_DEPRECATED:- action_kwargs["deprecated"] = deprecated- super().__init__(**action_kwargs)-- def __call__(- self,- parser: argparse.ArgumentParser,- namespace: argparse.Namespace,- values: Any,- option_string: str | None = None,- ) -> None:- if option_string == _DEPRECATED_INTAKE_ENABLE_FLAG:- logger.warning(- "%s is deprecated; use %s",- _DEPRECATED_INTAKE_ENABLE_FLAG,- _CANONICAL_INTAKE_ENABLE_FLAG,- )- setattr(namespace, self.dest, True)---def _add_intake_args(parser: argparse.ArgumentParser) -> None:- parser.add_argument(- _CANONICAL_INTAKE_ENABLE_FLAG,- _DEPRECATED_INTAKE_ENABLE_FLAG,- dest="intake_enabled",- default=False,- action=_IntakeEnabledAction,- help=(- "Enable Intake for requests that opt in with store=true or "- "x-switchyard-intake-enabled=true."- ),- )- parser.add_argument("--intake-base-url", default=None)- parser.add_argument("--intake-workspace", default=None)- parser.add_argument("--intake-api-key", default=None)- parser.add_argument("--intake-target-url", default=None)---def _resolve_intake_config(args: argparse.Namespace) -> IntakeSinkConfig | None:- intake = IntakeCliConfig.from_server_args(args)- if not intake.enabled:- return None- return IntakeSinkConfig(- intake_base_url=intake.base_url,- workspace=intake.workspace,- api_key=intake.api_key,- target_url=intake.target_url,- )---def _resolve_intake_processors(- args: argparse.Namespace,-) -> tuple[list[Any], list[Any]]:- intake = _resolve_intake_config(args)- if intake is None:- return [], []- return [IntakeRequestProcessor()], [IntakeResponseProcessor(intake)]--def _cmd_serve(args: argparse.Namespace) -> None:"""Serve an explicit routing-profile bundle."""- intake_request, intake_response = _resolve_intake_processors(args)- rl_request, rl_response = build_rl_logging_processors(resolve_rl_log_dir(args))- request_processors = [*intake_request, *rl_request]- response_processors = [*intake_response, *rl_response]+ request_processors, response_processors = build_rl_logging_processors(+ resolve_rl_log_dir(args)+ )if args.routing_log_file:from switchyard.lib.processors.routing_log_response_processor import (RoutingLogResponseProcessor,@@ -244,7 +140,6 @@ def _build_parser() -> argparse.ArgumentParser:serve.add_argument("--enable-rl-logging", action="store_true")serve.add_argument("--rl-log-dir", default="./rl_data", metavar="DIR")add_transport_args(serve)- _add_intake_args(serve)serve.add_argument("--routing-log-file", default=None, metavar="PATH")serve.add_argument("--workers",diff --git a/switchyard/lib/config/__init__.py b/switchyard/lib/config/__init__.pydeleted file mode 100644index 1c74cba12..000000000--- a/switchyard/lib/config/__init__.py+++ /dev/null@@ -1,14 +0,0 @@-# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-# SPDX-License-Identifier: Apache-2.0--"""Configuration models shared by profile and processor implementations."""--from switchyard.lib.config.intake_sink_config import (- IntakeQueueFullPolicy,- IntakeSinkConfig,-)--__all__ = [- "IntakeQueueFullPolicy",- "IntakeSinkConfig",-]diff --git a/switchyard/lib/config/intake_sink_config.py b/switchyard/lib/config/intake_sink_config.pydeleted file mode 100644index d91e821c6..000000000--- a/switchyard/lib/config/intake_sink_config.py+++ /dev/null@@ -1,8 +0,0 @@-# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-# SPDX-License-Identifier: Apache-2.0--"""Rust-owned intake sink config exports."""--from switchyard_rust.components import IntakeQueueFullPolicy, IntakeSinkConfig--__all__ = ["IntakeQueueFullPolicy", "IntakeSinkConfig"]diff --git a/switchyard/lib/processors/__init__.py b/switchyard/lib/processors/__init__.pyindex 17f8a468b..c640aa02a 100644--- a/switchyard/lib/processors/__init__.py+++ b/switchyard/lib/processors/__init__.py@@ -3,8 +3,6 @@"""Concrete request-side and response-side processor implementations."""-from typing import TYPE_CHECKING, Any-from switchyard.lib.processors.model_rewrite_request_processor import (ModelRewriteRequestProcessor,)@@ -15,41 +13,8 @@ from switchyard.lib.processors.stats_response_processor_accumulator import (StatsResponseProcessor,)-if TYPE_CHECKING:- from switchyard.lib.processors.intake_client import IntakeClient- from switchyard.lib.processors.intake_payload_builder import IntakePayloadBuilder- from switchyard.lib.processors.intake_request_processor import IntakeRequestProcessor- from switchyard.lib.processors.intake_response_processor import IntakeResponseProcessor-__all__ = [- "IntakeClient",- "IntakePayloadBuilder",- "IntakeRequestProcessor",- "IntakeResponseProcessor","ModelRewriteRequestProcessor","StatsRequestProcessor","StatsResponseProcessor",]---def __getattr__(name: str) -> Any:- """Lazy load intake processors to avoid circular imports."""- if name == "IntakeClient":- from switchyard.lib.processors.intake_client import IntakeClient- return IntakeClient- elif name == "IntakePayloadBuilder":- from switchyard.lib.processors.intake_payload_builder import (- IntakePayloadBuilder,- )- return IntakePayloadBuilder- elif name == "IntakeRequestProcessor":- from switchyard.lib.processors.intake_request_processor import (- IntakeRequestProcessor,- )- return IntakeRequestProcessor- elif name == "IntakeResponseProcessor":- from switchyard.lib.processors.intake_response_processor import (- IntakeResponseProcessor,- )- return IntakeResponseProcessor- raise AttributeError(f"module {__name__!r} has no attribute {name!r}")diff --git a/switchyard/lib/processors/intake_client.py b/switchyard/lib/processors/intake_client.pydeleted file mode 100644index 53d962ff0..000000000--- a/switchyard/lib/processors/intake_client.py+++ /dev/null@@ -1,230 +0,0 @@-# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-# SPDX-License-Identifier: Apache-2.0--"""Async intake client backed by the NeMo Platform SDK."""--from __future__ import annotations--import asyncio-import importlib.util-import logging-from collections.abc import Callable-from typing import Protocol, cast-from urllib.parse import quote--from switchyard.lib.config.intake_sink_config import (- IntakeSinkConfig,-)---class AsyncNeMoPlatform(Protocol):- """Static shape of the optional NeMo Platform SDK client used by intake."""-- workspace: str | None-- async def post(- self,- path: str,- *,- cast_to: type[object],- body: object,- ) -> object: ...-- async def close(self) -> None: ...---log = logging.getLogger(__name__)-JsonObject = dict[str, object]--#: Max seconds ``aclose()`` waits for the in-flight queue to drain before-#: bailing out and closing the HTTP client anyway.-_DRAIN_TIMEOUT_S = 30.0--_SDK_INSTALL_HINT = (- "Install the NeMo Platform SDK with the `intake` extra, e.g. "- "`uv run --extra intake switchyard launch claude --intake-enabled`."-)--_SDK_LOGIN_HINT = (- "Run `uv run nmp auth login --base-url {INTAKE_BASE_URL}`, "- "or pass --intake-base-url and --intake-api-key."-)---class IntakeClient:- """Fail-open queue + worker that POSTs completed turns through AsyncNeMoPlatform.-- The SDK handles config bootstrap, auth, and retries. Intake still uses a- generic POST path because the stable SDK does not expose a generated- ``client.intake`` resource.- """-- def __init__(self, config: IntakeSinkConfig) -> None:- self._client: AsyncNeMoPlatform = _build_sdk_client(config)- # Payloads need a concrete workspace even when the SDK resolves it.- self._config = IntakeSinkConfig(- intake_base_url=config.intake_base_url,- workspace=config.workspace or _sdk_workspace(self._client) or "default",- user_id=config.user_id,- api_key=config.api_key,- max_queue_size=config.max_queue_size,- request_timeout_s=config.request_timeout_s,- max_retries=config.max_retries,- on_queue_full=config.on_queue_full,- )- self._queue: asyncio.Queue[JsonObject | None] = asyncio.Queue(- maxsize=self._config.max_queue_size,- )- self._worker_task: asyncio.Task[None] | None = None- self._background_tasks: set[asyncio.Task[None]] = set()- self._closed = False- self._dropped = 0-- @property- def effective_config(self) -> IntakeSinkConfig:- """Config with workspace resolved against SDK / nmp config."""- return self._config-- async def enqueue(self, payload: JsonObject) -> None:- """Queue a payload for background POST."""- await self._enqueue_payload(payload, allow_closed=False)-- def enqueue_background(self, payload_factory: Callable[[], JsonObject]) -> None:- """Build and enqueue a payload in a client-retained background task."""- if self._closed:- log.warning("IntakeClient is closed; dropping payload")- return-- task = asyncio.create_task(self._build_and_enqueue(payload_factory))- self._background_tasks.add(task)- task.add_done_callback(self._background_tasks.discard)-- async def _enqueue_payload(self, payload: JsonObject, *, allow_closed: bool) -> None:- if self._closed and not allow_closed:- log.warning("IntakeClient is closed; dropping payload")- return- self._ensure_worker()- if self._config.on_queue_full.value == "block":- await self._queue.put(payload)- return- try:- self._queue.put_nowait(payload)- except asyncio.QueueFull:- self._dropped += 1- log.warning(- "Intake queue full (max=%d); dropping payload. dropped=%d",- self._config.max_queue_size,- self._dropped,- )-- async def _build_and_enqueue(self, payload_factory: Callable[[], JsonObject]) -> None:- try:- payload = payload_factory()- except Exception:- log.exception("Failed to build intake payload; dropping")- return- await self._enqueue_payload(payload, allow_closed=True)-- async def aclose(self) -> None:- """Drain pending items, stop the worker, and close the HTTP client."""- if self._closed:- return- self._closed = True- await self._wait_for_background_tasks()- self._ensure_worker()- await self._queue.put(None)- if self._worker_task is not None:- try:- await asyncio.wait_for(self._worker_task, timeout=_DRAIN_TIMEOUT_S)- except TimeoutError:- log.warning("Timed out draining intake queue during shutdown")- self._worker_task.cancel()- await asyncio.gather(self._worker_task, return_exceptions=True)- await self._client.close()-- async def _wait_for_background_tasks(self) -> None:- if not self._background_tasks:- return- pending = list(self._background_tasks)- try:- await asyncio.wait_for(- asyncio.gather(*pending, return_exceptions=True),- timeout=_DRAIN_TIMEOUT_S,- )- except TimeoutError:- log.warning("Timed out waiting for intake background tasks during shutdown")- for task in pending:- task.cancel()- await asyncio.gather(*pending, return_exceptions=True)-- def _ensure_worker(self) -> None:- if self._worker_task is None or self._worker_task.done():- self._worker_task = asyncio.create_task(self._worker())-- async def _worker(self) -> None:- while True:- payload = await self._queue.get()- if payload is None:- self._queue.task_done()- return- try:- await self._post_payload(payload)- except Exception:- log.exception("Intake worker failed while posting payload; dropping")- finally:- self._queue.task_done()-- async def _post_payload(self, payload: JsonObject) -> None:- try:- await self._client.post(- _chat_completions_ingest_path(self._config.workspace or "default"),- cast_to=object,- body=payload,- )- except Exception as exc:- status_code = getattr(exc, "status_code", None)- if not isinstance(status_code, int):- raise- log.warning(- "Intake rejected payload with %d: %s",- status_code,- str(exc)[:200],- )---def _build_sdk_client(config: IntakeSinkConfig) -> AsyncNeMoPlatform:- """Build an ``AsyncNeMoPlatform`` for the intake POST path."""- if importlib.util.find_spec("nemo_platform") is None:- raise RuntimeError(_SDK_INSTALL_HINT)-- from nemo_platform import ( # pyright: ignore[reportMissingImports]- AsyncNeMoPlatform as NeMoPlatformClient,- )-- client_kwargs: dict[str, object] = {- "timeout": config.request_timeout_s,- "max_retries": config.max_retries,- }- if config.workspace is not None:- client_kwargs["workspace"] = config.workspace- if config.intake_base_url is not None:- client_kwargs["base_url"] = config.intake_base_url- if config.api_key is not None:- client_kwargs["access_token"] = config.api_key-- try:- return cast(AsyncNeMoPlatform, NeMoPlatformClient(**client_kwargs))- except Exception as exc:- raise RuntimeError(- f"Failed to construct AsyncNeMoPlatform for intake: {exc}. "- + _SDK_LOGIN_HINT,- ) from exc---def _sdk_workspace(client: AsyncNeMoPlatform) -> str | None:- workspace = getattr(client, "workspace", None)- return workspace if isinstance(workspace, str) else None---def _chat_completions_ingest_path(workspace: str) -> str:- return f"/apis/intake/v2/workspaces/{quote(workspace, safe='')}/ingest/chat-completions"diff --git a/switchyard/lib/processors/intake_payload_builder.py b/switchyard/lib/processors/intake_payload_builder.pydeleted file mode 100644index a279687d3..000000000--- a/switchyard/lib/processors/intake_payload_builder.py+++ /dev/null@@ -1,299 +0,0 @@-# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-# SPDX-License-Identifier: Apache-2.0--"""Build intake payloads from request/response primitives."""--from datetime import UTC, datetime-from functools import cache-from importlib.metadata import PackageNotFoundError, version-from typing import Any, cast--from switchyard.lib.config.intake_sink_config import (- IntakeSinkConfig,-)-from switchyard.lib.cost_estimator import estimate_model_cost-from switchyard.lib.proxy_context import ProxyContext-from switchyard.lib.request_metadata import (- CTX_REQUEST_METADATA,- RequestMetadata,-)-from switchyard_rust.core import (- ChatRequest,- ChatRequestType,- ChatResponse,- ChatResponseType,- request_type_matches,- response_type_matches,-)-from switchyard_rust.translation import TranslationEngine--JsonObject = dict[str, object]--#: Context metadata key for random routing tier selection (mirrored from core.backends.random_routing_llm_backend)-_CTX_RANDOM_ROUTING_TIER = "_random_routing_tier"--INTAKE_STARTED_AT_MS_KEY = "_intake_started_at_ms"-INTAKE_ENDED_AT_MS_KEY = "_intake_ended_at_ms"-INTAKE_SESSION_ID_KEY = "_intake_session_id"-INTAKE_INBOUND_FORMAT_KEY = "_intake_inbound_format"-INTAKE_REQUEST_SNAPSHOT_KEY = "_intake_request_snapshot"-INTAKE_SKIP_KEY = "_intake_skip"-SYNTHETIC_STREAM_RESPONSE_IDS = frozenset(- {- "chatcmpl-intake-stream",- "chatcmpl-switchyard-stream",- "msg_switchyard_stream",- "resp_switchyard_stream",- }-)---class IntakePayloadBuilder:- """Pure builder that produces one intake payload per completed turn."""-- def __init__(self, config: IntakeSinkConfig) -> None:- self._config = config- self._translation = TranslationEngine()-- def build(- self,- *,- ctx: ProxyContext,- request_snapshot: ChatRequest,- response: ChatResponse,- stream: bool,- ) -> JsonObject:- """Build a single intake payload."""- openai_request = self._translation.request_to(- ChatRequestType.OPENAI_CHAT,- request_snapshot,- )- if not request_type_matches(openai_request, ChatRequestType.OPENAI_CHAT):- raise NotImplementedError(- f"Intake payloads require an OpenAI Chat-shaped request, got "- f"{type(request_snapshot).__name__}",- )- openai_response = self._build_openai_response_dict(response)- session_id_raw = ctx.metadata.get(INTAKE_SESSION_ID_KEY)- session_id = session_id_raw if isinstance(session_id_raw, str) and session_id_raw else None- request_entry = self._build_request_entry(- ctx=ctx,- openai_request=dict(openai_request.body),- stream=stream,- )- response_entry = _sanitize_response_entry(openai_response)- # Metadata-only unless content capture is explicitly enabled.- if not self._config.capture_content:- _redact_content(request_entry, response_entry)- payload: JsonObject = {- "request": request_entry,- "response": response_entry,- "provider": "switchyard",- }- # Cost reads usage from the unredacted response, so metrics are unaffected.- payload.update(_cost_fields(openai_response))- evaluation_context = self._evaluation_context(ctx)- if evaluation_context:- payload["evaluation_context"] = evaluation_context- if session_id is not None:- payload["session_id"] = session_id- return payload-- def request_from_snapshot(self, ctx: ProxyContext) -> ChatRequest:- """Read the copied original request wrapper from context metadata."""- request = ctx.metadata.get(INTAKE_REQUEST_SNAPSHOT_KEY)- if not isinstance(request, ChatRequest):- raise ValueError("Missing intake request snapshot in context")- return request-- def _build_openai_response_dict(self, response: ChatResponse) -> JsonObject:- translated = self._translation.response_to(ChatRequestType.OPENAI_CHAT, response)- if response_type_matches(translated, ChatResponseType.OPENAI_COMPLETION):- return cast(JsonObject, dict(translated.body))- raise NotImplementedError(- f"Intake payloads require an OpenAI Chat-shaped response, got "- f"{type(response).__name__}",- )-- def _build_routing(self, ctx: ProxyContext) -> dict[str, str]:- random_tier = ctx.metadata.get(_CTX_RANDOM_ROUTING_TIER)- if not isinstance(random_tier, str) or not random_tier:- return {}-- return {- "router_type": "random",- "routed_to": random_tier,- }-- def _build_request_entry(- self,- *,- ctx: ProxyContext,- openai_request: JsonObject,- stream: bool,- ) -> JsonObject:- request_entry = dict(openai_request)- if stream or request_entry.get("stream") is True:- request_entry["stream"] = False- started_at_ms = _coerce_int(ctx.metadata.get(INTAKE_STARTED_AT_MS_KEY))- ended_at_ms = _coerce_int(ctx.metadata.get(INTAKE_ENDED_AT_MS_KEY))- switchyard_metadata: JsonObject = {- "version": _switchyard_version(),- "inbound_format": ctx.metadata.get(INTAKE_INBOUND_FORMAT_KEY),- "stream": stream,- "user_id": self._config.user_id,- "created_at": _created_at_iso(started_at_ms, ended_at_ms),- }- session_id_raw = ctx.metadata.get(INTAKE_SESSION_ID_KEY)- if isinstance(session_id_raw, str) and session_id_raw:- switchyard_metadata["session_id"] = session_id_raw- if started_at_ms is not None and ended_at_ms is not None:- switchyard_metadata["latency_ms"] = ended_at_ms - started_at_ms- routing = self._build_routing(ctx)- if routing:- switchyard_metadata["routing"] = routing- request_entry["switchyard"] = switchyard_metadata- return request_entry-- def _task_name(self, ctx: ProxyContext) -> str:- return _request_metadata(ctx).intake.task or "chat"-- def _evaluation_context(self, ctx: ProxyContext) -> JsonObject | None:- session_id_raw = ctx.metadata.get(INTAKE_SESSION_ID_KEY)- evaluation_run_id = session_id_raw if isinstance(session_id_raw, str) and session_id_raw else None- if not evaluation_run_id:- return None- return {- "evaluation_run_id": evaluation_run_id,- "test_case_id": self._task_name(ctx),- }---def _request_metadata(ctx: ProxyContext) -> RequestMetadata:- """Read :class:`RequestMetadata` off ``ctx.metadata`` or return a blank one."""- value = ctx.metadata.get(CTX_REQUEST_METADATA)- return value if isinstance(value, RequestMetadata) else RequestMetadata()---def _redact_content(request_entry: JsonObject, response_entry: JsonObject) -> None:- """Strip prompt/response text so the payload is metadata-only; model/usage stay."""- for key in (- "messages",- "system",- "prompt",- "input",- "tools",- "tool_choice",- "functions",- "function_call",- ):- request_entry.pop(key, None)- choices = response_entry.get("choices")- if isinstance(choices, list):- for choice in choices:- if not isinstance(choice, dict):- continue- choice.pop("logprobs", None)- for shape in ("message", "delta"):- part = choice.get(shape)- if isinstance(part, dict):- for key in [k for k in part if k != "role"]:- part.pop(key, None)---def _sanitize_response_entry(openai_response: JsonObject) -> JsonObject:- response = dict(openai_response)- response_id = response.get("id")- if response_id in SYNTHETIC_STREAM_RESPONSE_IDS:- response.pop("id", None)- return response---def _coerce_int(value: object) -> int | None:- if isinstance(value, bool):- return int(value)- if isinstance(value, int):- return value- if isinstance(value, float):- return int(value)- return None---def _cost_fields(openai_response: JsonObject) -> JsonObject:- model = _str_or_none(openai_response.get("model"))- if model is None:- return {}- usage = _usage_from_response(openai_response)- if usage is None:- return {}- breakdown = estimate_model_cost(- model=model,- prompt_tokens=usage["prompt_tokens"],- completion_tokens=usage["completion_tokens"],- cached_tokens=usage["cached_tokens"],- cache_creation_tokens=usage["cache_creation_tokens"],- )- total_cost = breakdown["total_cost"]- if total_cost <= 0:- return {}- input_cost = breakdown["input_cost"]- output_cost = breakdown["output_cost"]- return {- "cost_usd": total_cost,- "cost_input_usd": input_cost,- "cost_output_usd": output_cost,- "cost_details": {- "base_input": breakdown["base_input_cost"],- "cached_input": breakdown["cached_input_cost"],- "cache_write": breakdown["cache_write_cost"],- },- }---def _usage_from_response(openai_response: JsonObject) -> dict[str, int] | None:- usage = openai_response.get("usage")- if not isinstance(usage, dict):- return None- prompt_details = _dict_or_empty(usage.get("prompt_tokens_details"))- prompt_tokens = _clean_int(usage.get("prompt_tokens"))- completion_tokens = _clean_int(usage.get("completion_tokens"))- if prompt_tokens is None or completion_tokens is None:- return None- return {- "prompt_tokens": prompt_tokens,- "completion_tokens": completion_tokens,- "cached_tokens": _clean_int(prompt_details.get("cached_tokens")) or 0,- "cache_creation_tokens": _clean_int(prompt_details.get("cache_creation_tokens")) or 0,- }---def _dict_or_empty(value: Any) -> dict[str, Any]:- return value if isinstance(value, dict) else {}---def _clean_int(value: object) -> int | None:- if not isinstance(value, int) or isinstance(value, bool):- return None- return value if value >= 0 else None---def _str_or_none(value: object) -> str | None:- if not isinstance(value, str):- return None- value = value.strip()- return value or None---@cache-def _switchyard_version() -> str:- try:- return version("nemo-switchyard")- except PackageNotFoundError:- return "unknown"---def _created_at_iso(started_at_ms: int | None, ended_at_ms: int | None) -> str:- source_ms = started_at_ms if started_at_ms is not None else ended_at_ms- if source_ms is None:- return datetime.now(UTC).isoformat()- return datetime.fromtimestamp(source_ms / 1000, tz=UTC).isoformat()diff --git a/switchyard/lib/processors/intake_request_processor.py b/switchyard/lib/processors/intake_request_processor.pydeleted file mode 100644index c05e43ff9..000000000--- a/switchyard/lib/processors/intake_request_processor.py+++ /dev/null@@ -1,8 +0,0 @@-# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-# SPDX-License-Identifier: Apache-2.0--"""Rust-owned intake request processor export."""--from switchyard_rust.components import IntakeRequestProcessor--__all__ = ["IntakeRequestProcessor"]diff --git a/switchyard/lib/processors/intake_response_processor.py b/switchyard/lib/processors/intake_response_processor.pydeleted file mode 100644index ad8babd0a..000000000--- a/switchyard/lib/processors/intake_response_processor.py+++ /dev/null@@ -1,8 +0,0 @@-# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-# SPDX-License-Identifier: Apache-2.0--"""Rust-owned intake response processor export."""--from switchyard_rust.components import IntakeResponseProcessor--__all__ = ["IntakeResponseProcessor"]diff --git a/switchyard/lib/processors/llm_classifier/request_processor.py b/switchyard/lib/processors/llm_classifier/request_processor.pyindex c233d5690..4a8e292b9 100644--- a/switchyard/lib/processors/llm_classifier/request_processor.py+++ b/switchyard/lib/processors/llm_classifier/request_processor.py@@ -385,16 +385,6 @@ class LLMClassifierRequestProcessor:prompt_tokens, completion_tokens, cached_tokens = _classifier_token_counts(completion.usage,)- # Record usage so the intake sink emits the classifier sub-call as its- # own record; the routed-turn record never sees this call.- ctx.record_submodel_call(- model=self._config.model,- prompt_tokens=prompt_tokens,- completion_tokens=completion_tokens,- cached_tokens=cached_tokens,- router_type="deterministic",- routed_to="classifier",- )if self._stats_accumulator is not None:await self._record_classifier_call(prompt_tokens=prompt_tokens,diff --git a/switchyard/lib/processors/routing_log_response_processor.py b/switchyard/lib/processors/routing_log_response_processor.pyindex b378d39c8..7046c851f 100644--- a/switchyard/lib/processors/routing_log_response_processor.py+++ b/switchyard/lib/processors/routing_log_response_processor.py@@ -66,7 +66,7 @@ class RoutingLogResponseProcessor:actual_model = _field(response.body, "model")record = {"ts": datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z",- "task": getattr(getattr(metadata, "intake", None), "task", None),+ "task": getattr(metadata, "task", None),"trial_id": headers.get("x-switchyard-trial-id"),"session_id": getattr(metadata, "session_id", None),"model": actual_model if isinstance(actual_model, str) and actual_model else served_model,diff --git a/switchyard/lib/processors/stage_router/classifier.py b/switchyard/lib/processors/stage_router/classifier.pyindex aec9e2569..86c4057fb 100644--- a/switchyard/lib/processors/stage_router/classifier.py+++ b/switchyard/lib/processors/stage_router/classifier.py@@ -231,17 +231,6 @@ class TierClassifier:prompt_tokens, completion_tokens, cached_tokens = _tier_token_counts(getattr(response, "usage", None),)- # Record usage so the intake sink emits the tier-classifier call as its- # own intake record; the routed-turn record never sees it.- if hasattr(ctx, "record_submodel_call"):- ctx.record_submodel_call(- model=self._model,- prompt_tokens=prompt_tokens,- completion_tokens=completion_tokens,- cached_tokens=cached_tokens,- router_type="stage_router",- routed_to="tier_classifier",- )if self._stats is not None:try:await self._stats.record_classifier_usage(diff --git a/switchyard/lib/profiles/chain.py b/switchyard/lib/profiles/chain.pyindex db9c8e29e..b74d1253a 100644--- a/switchyard/lib/profiles/chain.py+++ b/switchyard/lib/profiles/chain.py@@ -114,8 +114,8 @@ class ComponentChainProfile:"""Return a copy with serving-level stats and processor hooks applied.Profile configs stay user-facing and parseable; shared serving resources- such as one route-table accumulator or Intake processors are attached by- the builder that hosts the profile.+ such as one route-table accumulator are attached by the builder that+ hosts the profile."""from switchyard.lib.processors.stats_request_processor import (StatsRequestProcessor,diff --git a/switchyard/lib/request_metadata.py b/switchyard/lib/request_metadata.pyindex 2f56f4d59..8419a65c8 100644--- a/switchyard/lib/request_metadata.py+++ b/switchyard/lib/request_metadata.py@@ -4,10 +4,10 @@"""request metadata helpers for HTTP endpoint context."""from collections.abc import Mapping+from dataclasses import dataclassfrom typing import Anyfrom switchyard.lib.proxy_context import CTX_CALLER_API_KEY-from switchyard_rust.components import IntakeRequestMetadata, RequestMetadataCTX_REQUEST_METADATA = "_request_metadata"CTX_PROFILE_REQUEST_HEADERS = "_profile_request_headers"@@ -15,8 +15,6 @@ CTX_PROFILE_REQUEST_HEADERS = "_profile_request_headers"# Existing Switchyard session header. Do not add aliases here unless a# concrete client requires one; keeping one spelling avoids ambiguity.PROXY_SESSION_ID_HEADER = "proxy_x_session_id"-INTAKE_ENABLED_HEADER = "x-switchyard-intake-enabled"-INTAKE_APP_HEADER = "x-switchyard-intake-app"INTAKE_TASK_HEADER = "x-switchyard-intake-task"# Sentinel values our own launchers send as the ``Authorization`` /@@ -34,19 +32,36 @@ CALLER_API_KEY_HEADER = "x-switchyard-api-key" # pragma: allowlist secret# Request headers whose values carry a caller credential. Redacted before the# header map is retained on the context (``CTX_PROFILE_REQUEST_HEADERS``), so the-# caller's key never reaches profile metadata, intake, logs, or traces. The key+# caller's key never reaches profile metadata, logs, or traces. The key# is still forwarded upstream via ``CTX_CALLER_API_KEY`` (extracted by# ``attach_caller_api_key`` from the raw headers, before redaction)._SENSITIVE_HEADERS = frozenset({"authorization", "x-api-key", CALLER_API_KEY_HEADER})_REDACTED = "[REDACTED]"+@dataclass(frozen=True, slots=True)+class RequestMetadata:+ """Session and task identifiers retained for compatibility routing logs."""++ session_id: str | None = None+ task: str | None = None++ @classmethod+ def from_headers(cls, headers: Mapping[str, str]) -> "RequestMetadata":+ """Extract request metadata from a case-insensitive header mapping."""+ normalized = {name.lower(): value for name, value in headers.items()}+ return cls(+ session_id=_nonempty_header(normalized, PROXY_SESSION_ID_HEADER),+ task=_nonempty_header(normalized, INTAKE_TASK_HEADER),+ )++def attach_request_metadata(ctx: Any,metadata: RequestMetadata,headers: Mapping[str, str] | None = None,) -> None:- """Attach request metadata to both Python and native typed context storage."""+ """Attach request metadata and redacted headers to the Python context."""ctx.metadata[CTX_REQUEST_METADATA] = metadataif headers is not None:# Redact credential headers before retaining the map: the caller key is@@ -54,7 +69,11 @@ def attach_request_metadata(# so nothing downstream needs the raw value, and a retained/logged header# map must not expose it.ctx.metadata[CTX_PROFILE_REQUEST_HEADERS] = redact_sensitive_headers(headers)- metadata.apply_to_context(ctx)+++def _nonempty_header(headers: Mapping[str, str], name: str) -> str | None:+ value = headers.get(name)+ return value if value else Nonedef redact_sensitive_headers(headers: Mapping[str, str]) -> dict[str, str]:@@ -114,11 +133,8 @@ __all__ = ["CALLER_API_KEY_HEADER","CTX_REQUEST_METADATA","CTX_PROFILE_REQUEST_HEADERS",- "INTAKE_APP_HEADER",- "INTAKE_ENABLED_HEADER","INTAKE_TASK_HEADER","PROXY_SESSION_ID_HEADER",- "IntakeRequestMetadata","RequestMetadata","attach_caller_api_key","attach_request_metadata",diff --git a/switchyard_rust/__init__.py b/switchyard_rust/__init__.pyindex bd121bfe3..2603ef237 100644--- a/switchyard_rust/__init__.py+++ b/switchyard_rust/__init__.py@@ -16,11 +16,6 @@ if TYPE_CHECKING:from switchyard_rust.components import AnthropicNativeBackend as AnthropicNativeBackendfrom switchyard_rust.components import BackendFormat as BackendFormatfrom switchyard_rust.components import EndpointConfig as EndpointConfig- from switchyard_rust.components import IntakeQueueFullPolicy as IntakeQueueFullPolicy- from switchyard_rust.components import IntakeRequestMetadata as IntakeRequestMetadata- from switchyard_rust.components import IntakeRequestProcessor as IntakeRequestProcessor- from switchyard_rust.components import IntakeResponseProcessor as IntakeResponseProcessor- from switchyard_rust.components import IntakeSinkConfig as IntakeSinkConfigfrom switchyard_rust.components import LlmTarget as LlmTargetfrom switchyard_rust.components import LlmTargetBackend as LlmTargetBackendfrom switchyard_rust.components import MultiLlmBackend as MultiLlmBackend@@ -29,7 +24,6 @@ if TYPE_CHECKING:from switchyard_rust.components import (RandomRoutingProcessorConfig as RandomRoutingProcessorConfig,)- from switchyard_rust.components import RequestMetadata as RequestMetadatafrom switchyard_rust.components import StatsAccumulator as StatsAccumulatorfrom switchyard_rust.components import StatsLlmBackend as StatsLlmBackendfrom switchyard_rust.components import StatsRequestProcessor as StatsRequestProcessor@@ -62,18 +56,12 @@ def __getattr__(name: str) -> object:"AnthropicNativeBackend","BackendFormat","EndpointConfig",- "IntakeQueueFullPolicy",- "IntakeRequestMetadata",- "IntakeRequestProcessor",- "IntakeResponseProcessor",- "IntakeSinkConfig","LlmTarget","LlmTargetBackend","MultiLlmBackend","OpenAiNativeBackend","OpenAiPassthroughBackend","RandomRoutingProcessorConfig",- "RequestMetadata","StatsAccumulator","StatsLlmBackend","StatsRequestProcessor",@@ -140,11 +128,6 @@ __all__ = ["ChatResponseStream","ChatResponseType","EndpointConfig",- "IntakeQueueFullPolicy",- "IntakeRequestMetadata",- "IntakeRequestProcessor",- "IntakeResponseProcessor",- "IntakeSinkConfig","LLMBackend","LlmTarget","LlmTargetBackend",@@ -154,7 +137,6 @@ __all__ = ["ProxyMetadata","ProxyContext","RandomRoutingProcessorConfig",- "RequestMetadata","StatsAccumulator","StatsLlmBackend","StatsRequestProcessor",diff --git a/switchyard_rust/components.py b/switchyard_rust/components.pyindex a451f6f0f..e34cadea6 100644--- a/switchyard_rust/components.py+++ b/switchyard_rust/components.py@@ -15,11 +15,6 @@ _COMPONENT_EXPORTS = frozenset("BackendFormat","DimensionCollector","EndpointConfig",- "IntakeQueueFullPolicy",- "IntakeRequestMetadata",- "IntakeRequestProcessor",- "IntakeResponseProcessor",- "IntakeSinkConfig","LlmTarget","LlmTargetBackend","MultiLlmBackend",@@ -27,7 +22,6 @@ _COMPONENT_EXPORTS = frozenset("OpenAiPassthroughBackend","PickOutcome","RandomRoutingProcessorConfig",- "RequestMetadata","ResponseFlag","ResponseSignalCollector","ResponseSignals",@@ -59,11 +53,6 @@ if TYPE_CHECKING:BackendFormat: type[Any]DimensionCollector: type[Any]EndpointConfig: type[Any]- IntakeQueueFullPolicy: type[Any]- IntakeRequestMetadata: type[Any]- IntakeRequestProcessor: type[Any]- IntakeResponseProcessor: type[Any]- IntakeSinkConfig: type[Any]LlmTarget: type[Any]LlmTargetBackend: type[Any]MultiLlmBackend: type[Any]@@ -71,7 +60,6 @@ if TYPE_CHECKING:OpenAiPassthroughBackend: type[Any]PickOutcome: type[Any]RandomRoutingProcessorConfig: type[Any]- RequestMetadata: type[Any]ResponseFlag: type[Any]ResponseSignalCollector: type[Any]ResponseSignals: type[Any]diff --git a/switchyard_rust/components.pyi b/switchyard_rust/components.pyiindex 00a4e876f..36714b8fc 100644--- a/switchyard_rust/components.pyi+++ b/switchyard_rust/components.pyi@@ -83,76 +83,6 @@ class RandomRoutingProcessorConfig:def to_dict(self) -> dict[str, Any]: ...-class IntakeQueueFullPolicy:- DROP: ClassVar[IntakeQueueFullPolicy]- BLOCK: ClassVar[IntakeQueueFullPolicy]-- value: str-- def __init__(self, value: str = "drop") -> None: ...---class IntakeSinkConfig:- intake_base_url: str | None- workspace: str | None- user_id: str- api_key: str | None- target_url: str | None- target_format: str | None- target_authenticated: bool | None- max_queue_size: int- request_timeout_s: float- max_retries: int- on_queue_full: IntakeQueueFullPolicy- capture_content: bool-- def __init__(- self,- intake_base_url: str | None = None,- workspace: str | None = None,- user_id: str | None = None,- api_key: str | None = None,- target_url: str | None = None,- target_format: str | None = None,- target_authenticated: bool | None = None,- max_queue_size: int | None = None,- request_timeout_s: float | None = None,- max_retries: int | None = None,- on_queue_full: IntakeQueueFullPolicy | str | None = None,- capture_content: bool | None = None,- ) -> None: ...- def to_dict(self) -> dict[str, Any]: ...---class IntakeRequestMetadata:- enabled: bool | None- app: str | None- task: str | None-- def __init__(- self,- enabled: bool | None = None,- app: str | None = None,- task: str | None = None,- ) -> None: ...- def to_dict(self) -> dict[str, Any]: ...---class RequestMetadata:- session_id: str | None- intake: IntakeRequestMetadata-- def __init__(- self,- session_id: str | None = None,- intake: IntakeRequestMetadata | None = None,- ) -> None: ...- @classmethod- def from_headers(cls, headers: Any) -> RequestMetadata: ...- def to_dict(self) -> dict[str, Any]: ...- def apply_to_context(self, ctx: Any) -> None: ...--class StatsAccumulator:def __init__(self) -> None: ...async def record_success(@@ -249,13 +179,6 @@ class StatsRequestProcessor:async def shutdown(self) -> None: ...-class IntakeRequestProcessor:- def __init__(self) -> None: ...- async def process(self, ctx: ProxyContext, request: Any) -> Any: ...- async def startup(self) -> None: ...- async def shutdown(self) -> None: ...--class StatsResponseProcessor:accumulator: StatsAccumulator@@ -266,15 +189,6 @@ class StatsResponseProcessor:def get_endpoint(self) -> object: ...-class IntakeResponseProcessor:- config: IntakeSinkConfig-- def __init__(self, config: IntakeSinkConfig) -> None: ...- async def process(self, ctx: ProxyContext, response: Any) -> Any: ...- async def startup(self) -> None: ...- async def shutdown(self) -> None: ...--class DimensionCollector:def __init__(self,diff --git a/switchyard_rust/core.py b/switchyard_rust/core.pyindex 1b10f663b..f9ed33bfd 100644--- a/switchyard_rust/core.py+++ b/switchyard_rust/core.py@@ -310,29 +310,6 @@ class ProxyContext:def backend_call_latency_ms(self, value: float | None) -> None:self._native.backend_call_latency_ms = value- @property- def submodel_calls(self) -> list[dict[str, Any]]:- return cast(list[dict[str, Any]], self._native.submodel_calls)-- def record_submodel_call(- self,- model: str,- prompt_tokens: int,- completion_tokens: int,- cached_tokens: int,- router_type: str,- routed_to: str,- ) -> None:- """Record one routing model call for intake and stats."""- self._native.record_submodel_call(- model,- prompt_tokens,- completion_tokens,- cached_tokens,- router_type,- routed_to,- )-def __repr__(self) -> str:return repr(self._native)diff --git a/tests/test_init_all_exports.py b/tests/test_init_all_exports.pyindex 029bf1e81..08152e010 100644--- a/tests/test_init_all_exports.py+++ b/tests/test_init_all_exports.py@@ -23,21 +23,5 @@ def test_all_symbols_accessible() -> None:assert missing == [], f"Symbols in __all__ not importable from switchyard: {missing}"-def test_intake_payload_builder_importable() -> None:- from switchyard import IntakePayloadBuilder # noqa: F401---def test_intake_request_processor_importable() -> None:- from switchyard import IntakeRequestProcessor # noqa: F401---def test_intake_response_processor_importable() -> None:- from switchyard import IntakeResponseProcessor # noqa: F401---def test_intake_sink_config_importable() -> None:- from switchyard import IntakeSinkConfig # noqa: F401--def test_random_routing_config_importable() -> None:from switchyard import RandomRoutingConfig # noqa: F401diff --git a/tests/test_intake_cli_flags.py b/tests/test_intake_cli_flags.pydeleted file mode 100644index be20137a4..000000000--- a/tests/test_intake_cli_flags.py+++ /dev/null@@ -1,46 +0,0 @@-# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-# SPDX-License-Identifier: Apache-2.0--"""Tests for Intake flags on ``switchyard serve``."""--import logging--import pytest--from switchyard.cli.switchyard_cli import _build_parser--_SERVE = ["serve", "--routing-profiles", "routes.yaml"]---def test_serve_accepts_canonical_intake_flag() -> None:- args = _build_parser().parse_args([*_SERVE, "--intake-enabled"])- assert args.intake_enabled is True---def test_serve_accepts_deprecated_intake_alias(- caplog: pytest.LogCaptureFixture,-) -> None:- caplog.set_level(logging.WARNING, "switchyard.cli.switchyard_cli")- args = _build_parser().parse_args([*_SERVE, "--enable-intake"])- assert args.intake_enabled is True- assert "--enable-intake is deprecated; use --intake-enabled" in caplog.text---def test_serve_accepts_intake_connection_options() -> None:- args = _build_parser().parse_args(- [- *_SERVE,- "--intake-base-url",- "https://nmp.example",- "--intake-workspace",- "workspace-a",- "--intake-api-key",- "ci-token",- "--intake-target-url",- "https://data-lake.example/posting",- ]- )- assert args.intake_base_url == "https://nmp.example"- assert args.intake_workspace == "workspace-a"- assert args.intake_api_key == "ci-token"- assert args.intake_target_url == "https://data-lake.example/posting"diff --git a/tests/test_intake_sink.py b/tests/test_intake_sink.pydeleted file mode 100644index df6e9d8a2..000000000--- a/tests/test_intake_sink.py+++ /dev/null@@ -1,813 +0,0 @@-# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-# SPDX-License-Identifier: Apache-2.0--"""Tests for the intake sink usage case."""--from __future__ import annotations--import json-import threading-from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer-from typing import Any-from unittest.mock import AsyncMock, Mock--import httpx-import pytest-from openai.types.chat import ChatCompletion, ChatCompletionChunk-from openai.types.chat.chat_completion import Choice-from openai.types.chat.chat_completion_chunk import Choice as ChunkChoice-from openai.types.chat.chat_completion_chunk import ChoiceDelta-from openai.types.chat.chat_completion_message import ChatCompletionMessage-from openai.types.completion_usage import CompletionUsage--from switchyard.lib.config import IntakeSinkConfig-from switchyard.lib.processors import (- IntakeClient,- IntakePayloadBuilder,- IntakeRequestProcessor,- IntakeResponseProcessor,-)-from switchyard.lib.processors.intake_payload_builder import (- INTAKE_ENDED_AT_MS_KEY,- INTAKE_INBOUND_FORMAT_KEY,- INTAKE_SESSION_ID_KEY,- INTAKE_STARTED_AT_MS_KEY,-)-from switchyard.lib.proxy_context import ProxyContext-from switchyard.lib.request_metadata import (- CTX_REQUEST_METADATA,- IntakeRequestMetadata,- RequestMetadata,- attach_request_metadata,-)-from switchyard.lib.roles import LLMBackend-from switchyard.lib.switchyard import Switchyard-from switchyard.server.switchyard_app import build_switchyard_app-from switchyard_rust.core import (- ChatRequest,- ChatResponse,-)-from switchyard_rust.translation import TranslationEngine---def _assert_chat_completions_ingest_shape(payload: dict[str, Any]) -> None:- assert "request" in payload- assert "response" in payload- assert payload["provider"] == "switchyard"-- # nemo-platform chat-completions ingest forbids legacy entry-envelope fields.- for key in (- "data",- "context",- "external_id",- "usage",- ):- assert key not in payload---def _completion(- *,- response_id: str = "chatcmpl-test",- model: str = "openai/openai/gpt-5.2",- content: str = "hello",- include_usage: bool = True,-) -> ChatCompletion:- return ChatCompletion(- id=response_id,- object="chat.completion",- created=1700000000,- model=model,- choices=[- Choice(- index=0,- message=ChatCompletionMessage(role="assistant", content=content),- finish_reason="stop",- )- ],- usage=(- CompletionUsage(prompt_tokens=10, completion_tokens=5, total_tokens=15)- if include_usage- else None- ),- )---def _chunk(- *,- content: str | None = None,- finish_reason: str | None = None,- usage: CompletionUsage | None = None,-) -> ChatCompletionChunk:- return ChatCompletionChunk(- id="chatcmpl-stream",- object="chat.completion.chunk",- created=1700000000,- model="openai/openai/gpt-5.2",- choices=[- ChunkChoice(- index=0,- delta=ChoiceDelta(content=content),- finish_reason=finish_reason,- )- ],- usage=usage,- )---def _responses_response_dict(- *,- response_id: str = "resp_123",- model: str = "gpt-4o",- text: str = "hello",- input_tokens: int = 0,- output_tokens: int = 0,-) -> dict[str, object]:- return {- "id": response_id,- "object": "response",- "created_at": 1700000000,- "model": model,- "output": [- {- "type": "message",- "id": "msg_123",- "status": "completed",- "role": "assistant",- "content": [- {- "type": "output_text",- "text": text,- "annotations": [],- }- ],- }- ],- "status": "completed",- "parallel_tool_calls": True,- "tool_choice": "auto",- "tools": [],- "text": {"format": {"type": "text"}},- "usage": {- "input_tokens": input_tokens,- "output_tokens": output_tokens,- "total_tokens": input_tokens + output_tokens,- "input_tokens_details": {"cached_tokens": 0},- "output_tokens_details": {"reasoning_tokens": 0},- },- }---class _FakeIntakeClient:- def __init__(- self,- effective_config: IntakeSinkConfig | None = None,- ) -> None:- self.enqueue = AsyncMock()- self.enqueue_background = Mock(side_effect=self._enqueue_background)- self.aclose = AsyncMock()- self.background_payloads: list[dict[str, object]] = []- self.background_errors: list[Exception] = []- self.effective_config = effective_config or IntakeSinkConfig(- intake_base_url="http://localhost:8080",- workspace="default",- user_id="brian",- )-- def _enqueue_background(self, payload_factory):- try:- self.background_payloads.append(payload_factory())- except Exception as exc:- self.background_errors.append(exc)---class _IntakeHttpStub:- def __init__(self) -> None:- self._server: ThreadingHTTPServer | None = None- self._thread: threading.Thread | None = None- self._lock = threading.Lock()- self._requests: list[dict[str, Any]] = []-- def __enter__(self) -> _IntakeHttpStub:- owner = self-- class Handler(BaseHTTPRequestHandler):- protocol_version = "HTTP/1.1"-- def do_POST(self) -> None:- length = int(self.headers.get("content-length", "0"))- raw = self.rfile.read(length)- with owner._lock:- owner._requests.append({- "path": self.path,- "authorization": self.headers.get("authorization"),- "body": json.loads(raw.decode("utf-8")),- })- response = b"{}"- self.send_response(200)- self.send_header("content-type", "application/json")- self.send_header("content-length", str(len(response)))- self.send_header("connection", "close")- self.end_headers()- self.wfile.write(response)-- def log_message(self, _format: str, *args: object) -> None:- return None-- self._server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)- self._thread = threading.Thread(target=self._server.serve_forever, daemon=True)- self._thread.start()- return self-- def __exit__(self, *args: object) -> None:- if self._server is not None:- self._server.shutdown()- self._server.server_close()- if self._thread is not None:- self._thread.join(timeout=2)-- @property- def base_url(self) -> str:- if self._server is None:- raise RuntimeError("stub server is not running")- host, port = self._server.server_address- return f"http://{host}:{port}"-- @property- def requests(self) -> list[dict[str, Any]]:- with self._lock:- return list(self._requests)---class _StaticCompletionBackend(LLMBackend):- async def call(self, _ctx: ProxyContext, _request: ChatRequest) -> ChatResponse:- return ChatResponse.openai_completion(_completion(content="endpoint-ok"))---def _stub_sdk_client(monkeypatch) -> AsyncMock:- """Replace ``_build_sdk_client`` so IntakeClient tests don't need the SDK installed."""- fake = AsyncMock()- fake.close = AsyncMock()- fake.workspace = "default"- monkeypatch.setattr(- "switchyard.lib.processors.intake_client._build_sdk_client",- lambda config: fake,- )- return fake---class TestRequestMetadata:- def test_from_headers_extracts_only_explicit_fields(self):- metadata = RequestMetadata.from_headers({- "proxy_x_session_id": "sess-1",- "x-switchyard-intake-enabled": "true",- "x-switchyard-intake-app": "log2/codex",- "x-switchyard-intake-task": "developer-session",- "authorization": "Bearer secret",- })-- assert metadata.session_id == "sess-1"- assert metadata.intake.enabled is True- assert metadata.intake.app == "log2/codex"- assert metadata.intake.task == "developer-session"---class TestIntakePayloadBuilder:- def test_responses_request_is_normalized_to_openai_shape(self):- builder = IntakePayloadBuilder(- IntakeSinkConfig(- intake_base_url="http://localhost:8080",- workspace="default",- capture_content=True,- )- )- request = ChatRequest.openai_responses({- "model": "openai/openai/gpt-5.2",- "input": "say hi",- })- ctx = ProxyContext(metadata={- CTX_REQUEST_METADATA: RequestMetadata(- intake=IntakeRequestMetadata(- app="codex",- task="developer-session",- ),- ),- INTAKE_INBOUND_FORMAT_KEY: request.request_type,- "_proxy_actual_model": "openai/openai/gpt-5.2",- })-- payload = builder.build(- ctx=ctx,- request_snapshot=request,- response=ChatResponse.openai_completion(_completion()),- stream=False,- )-- assert payload["request"]["messages"][0]["content"] == "say hi"- assert "app" not in payload["request"]["switchyard"]- assert "task" not in payload["request"]["switchyard"]- assert payload["response"]["id"] == "chatcmpl-test"- assert payload["provider"] == "switchyard"- assert "user_id" not in payload- assert "switchyard" not in payload["response"]- _assert_chat_completions_ingest_shape(payload)-- def test_metadata_only_by_default_redacts_content(self):- builder = IntakePayloadBuilder(- IntakeSinkConfig(intake_base_url="http://localhost:8080", workspace="default")- )- request = ChatRequest.openai_chat({- "model": "openai/openai/gpt-5.2",- "messages": [{"role": "user", "content": "SENTINEL_PROMPT"}],- "tools": [{"type": "function", "function": {"name": "SENTINEL_TOOL"}}],- })- ctx = ProxyContext(metadata={})-- payload = builder.build(- ctx=ctx,- request_snapshot=request,- response=ChatResponse.openai_completion(_completion(content="SENTINEL_RESPONSE")),- stream=False,- )-- serialized = json.dumps(payload)- for sentinel in ("SENTINEL_PROMPT", "SENTINEL_TOOL", "SENTINEL_RESPONSE"):- assert sentinel not in serialized, f"leaked content: {sentinel}"- assert "messages" not in payload["request"]- assert payload["response"]["choices"][0]["message"].get("content") is None- assert payload["response"]["model"] == "openai/openai/gpt-5.2"- assert payload["response"]["usage"]["prompt_tokens"] == 10-- def test_synthetic_stream_id_is_stripped_before_ingest(self):- builder = IntakePayloadBuilder(- IntakeSinkConfig(- intake_base_url="http://localhost:8080",- workspace="default",- )- )- request = ChatRequest.openai_chat({- "model": "openai/openai/gpt-5.2",- "messages": [{"role": "user", "content": "hi"}],- })- ctx = ProxyContext(metadata={- INTAKE_INBOUND_FORMAT_KEY: request.request_type,- "_proxy_actual_model": "openai/openai/gpt-5.2",- })-- payload = builder.build(- ctx=ctx,- request_snapshot=request,- response=ChatResponse.openai_completion(- _completion(response_id="chatcmpl-switchyard-stream"),- ),- stream=True,- )-- assert "id" not in payload["response"]-- def test_missing_served_model_yields_null_usage_model(self):- builder = IntakePayloadBuilder(- IntakeSinkConfig(- intake_base_url="http://localhost:8080",- workspace="default",- )- )- request = ChatRequest.openai_chat({- "model": "openai/openai/gpt-5.2",- "messages": [{"role": "user", "content": "hi"}],- })- ctx = ProxyContext(metadata={- INTAKE_INBOUND_FORMAT_KEY: request.request_type,- })-- payload = builder.build(- ctx=ctx,- request_snapshot=request,- response=ChatResponse.openai_completion(_completion()),- stream=False,- )-- assert "served_model" not in payload["request"]["switchyard"]- assert "switchyard" not in payload["response"]-- def test_response_usage_carries_tokens_and_request_metadata_carries_timing(self):- builder = IntakePayloadBuilder(- IntakeSinkConfig(- intake_base_url="http://localhost:8080",- workspace="default",- )- )- request = ChatRequest.openai_chat({- "model": "gpt-4o",- "messages": [{"role": "user", "content": "hi"}],- })- ctx = ProxyContext(metadata={- INTAKE_INBOUND_FORMAT_KEY: request.request_type,- "_proxy_actual_model": "gpt-4o",- INTAKE_STARTED_AT_MS_KEY: 1_700_000_000_000,- INTAKE_ENDED_AT_MS_KEY: 1_700_000_001_840,- INTAKE_SESSION_ID_KEY: "session-123",- CTX_REQUEST_METADATA: RequestMetadata(- intake=IntakeRequestMetadata(- app="codex",- task="developer-session",- ),- ),- })-- payload = builder.build(- ctx=ctx,- request_snapshot=request,- response=ChatResponse.openai_completion(_completion()),- stream=False,- )-- assert payload["response"]["usage"]["prompt_tokens"] == 10- assert payload["response"]["usage"]["completion_tokens"] == 5- assert payload["cost_usd"] == pytest.approx(0.000088)- assert payload["cost_input_usd"] == pytest.approx(0.000018)- assert payload["cost_output_usd"] == pytest.approx(0.00007)- assert payload["cost_details"]["base_input"] == pytest.approx(0.000018)- assert payload["cost_details"]["cached_input"] == pytest.approx(0.0)- assert payload["cost_details"]["cache_write"] == pytest.approx(0.0)-- request_switchyard = payload["request"]["switchyard"]- assert payload["evaluation_context"] == {- "evaluation_run_id": "session-123",- "test_case_id": "developer-session",- }- assert "served_model" not in request_switchyard- assert "started_at_ms" not in request_switchyard- assert "ended_at_ms" not in request_switchyard- assert "duration_ms" not in request_switchyard- assert request_switchyard["latency_ms"] == 1840- assert request_switchyard["stream"] is False- assert request_switchyard["inbound_format"] == request.request_type-- assert "switchyard" not in payload["response"]- _assert_chat_completions_ingest_shape(payload)-- def test_chat_completions_payload_omits_cost_for_unknown_model(self):- """Unknown model aliases do not invent chat-completions cost fields."""- builder = IntakePayloadBuilder(- IntakeSinkConfig(- intake_base_url="http://localhost:8080",- workspace="default",- )- )- request = ChatRequest.openai_chat({- "model": "made-up-model",- "messages": [{"role": "user", "content": "hi"}],- })- ctx = ProxyContext(metadata={- INTAKE_INBOUND_FORMAT_KEY: request.request_type,- "_proxy_actual_model": "made-up-model",- })-- payload = builder.build(- ctx=ctx,- request_snapshot=request,- response=ChatResponse.openai_completion(_completion(model="made-up-model")),- stream=False,- )-- assert payload["response"]["model"] == "made-up-model"- assert payload["response"]["usage"]["prompt_tokens"] == 10- assert payload["response"]["usage"]["completion_tokens"] == 5- assert "cost_usd" not in payload- assert "cost_input_usd" not in payload- assert "cost_output_usd" not in payload- assert "cost_details" not in payload- _assert_chat_completions_ingest_shape(payload)-- def test_chat_completions_payload_omits_cost_when_tokens_are_missing_for_known_model(self):- builder = IntakePayloadBuilder(- IntakeSinkConfig(- intake_base_url="http://localhost:8080",- workspace="default",- )- )- request = ChatRequest.openai_chat({- "model": "openai/openai/gpt-5.2",- "messages": [{"role": "user", "content": "hi"}],- })- ctx = ProxyContext(metadata={- INTAKE_INBOUND_FORMAT_KEY: request.request_type,- "_proxy_actual_model": "openai/openai/gpt-5.2",- })-- payload = builder.build(- ctx=ctx,- request_snapshot=request,- response=ChatResponse.openai_completion(_completion(include_usage=False)),- stream=False,- )-- assert payload["response"]["model"] == "openai/openai/gpt-5.2"- assert "usage" not in payload["response"] or payload["response"]["usage"] is None- _assert_chat_completions_ingest_shape(payload)---class TestIntakeRequestProcessor:- async def test_returns_request_unchanged_without_client_opt_in(self):- processor = IntakeRequestProcessor()- ctx = ProxyContext(metadata={- CTX_REQUEST_METADATA: RequestMetadata(- session_id="session-123",- ),- })- request = ChatRequest.openai_chat({- "model": "gpt-4o",- "messages": [{"role": "user", "content": "hi"}],- })-- returned = await processor.process(ctx, request)-- assert returned.body == request.body-- async def test_store_true_request_still_round_trips_through_rust_processor(self):- processor = IntakeRequestProcessor()- ctx = ProxyContext(metadata={- CTX_REQUEST_METADATA: RequestMetadata(),- })- request = ChatRequest.openai_chat({- "model": "gpt-4o",- "messages": [{"role": "user", "content": "hi"}],- "store": True,- })-- returned = await processor.process(ctx, request)-- assert returned.body == request.body- assert returned.body["store"] is True-- async def test_header_false_request_still_round_trips_through_rust_processor(self):- processor = IntakeRequestProcessor()- ctx = ProxyContext(metadata={- CTX_REQUEST_METADATA: RequestMetadata(- intake=IntakeRequestMetadata(enabled=False),- ),- })- request = ChatRequest.openai_chat({- "model": "gpt-4o",- "messages": [{"role": "user", "content": "hi"}],- "store": True,- })-- returned = await processor.process(ctx, request)-- assert returned.body == request.body-- async def test_constructor_metadata_opt_out_overrides_store_true_in_rust_context(self):- request_processor = IntakeRequestProcessor()- request = ChatRequest.openai_chat({- "model": "gpt-4o",- "messages": [{"role": "user", "content": "hi"}],- "store": True,- })- ctx = ProxyContext(metadata={- CTX_REQUEST_METADATA: RequestMetadata(- intake=IntakeRequestMetadata(enabled=False),- ),- })-- with _IntakeHttpStub() as server:- response_processor = IntakeResponseProcessor(- IntakeSinkConfig(- intake_base_url=server.base_url,- workspace="default",- max_retries=0,- )- )- await request_processor.process(ctx, request)- await response_processor.process(ctx, ChatResponse.openai_completion(_completion()))- await response_processor.shutdown()-- assert server.requests == []-- async def test_header_opt_in_attached_to_rust_context_posts_payload(self):- request_processor = IntakeRequestProcessor()- request = ChatRequest.openai_chat({- "model": "gpt-4o",- "messages": [{"role": "user", "content": "hi"}],- })- ctx = ProxyContext()- attach_request_metadata(- ctx,- RequestMetadata.from_headers({- "proxy_x_session_id": "session-123",- "x-switchyard-intake-enabled": "true",- "x-switchyard-intake-app": "codex",- "x-switchyard-intake-task": "developer-session",- }),- )-- with _IntakeHttpStub() as server:- response_processor = IntakeResponseProcessor(- IntakeSinkConfig(- intake_base_url=server.base_url,- workspace="default",- max_retries=0,- )- )- await request_processor.process(ctx, request)- await response_processor.process(ctx, ChatResponse.openai_completion(_completion()))- await response_processor.shutdown()-- assert len(server.requests) == 1- payload = server.requests[0]["body"]- assert "app" not in payload["request"]["switchyard"]- assert "task" not in payload["request"]["switchyard"]- assert payload["session_id"] == "session-123"-- async def test_store_true_posts_routed_turn_and_submodel_records_to_flat_target(self):- """`store: true` alone (no header) opts in, so the routed turn and every- recorded routing call post to the flat-document target as distinct- documents. This is the opt-in the response-side Python processor could- never see."""- request_processor = IntakeRequestProcessor()- request = ChatRequest.openai_chat({- "model": "gpt-4o",- "messages": [{"role": "user", "content": "hi"}],- "store": True,- })- ctx = ProxyContext()- attach_request_metadata(- ctx,- RequestMetadata.from_headers({"proxy_x_session_id": "sess-xyz"}),- )- # A router records its own model call, exactly as the LLM classifier does.- ctx.record_submodel_call(- model="router-clf",- prompt_tokens=120,- completion_tokens=8,- cached_tokens=0,- router_type="deterministic",- routed_to="classifier",- )-- with _IntakeHttpStub() as server:- response_processor = IntakeResponseProcessor(- IntakeSinkConfig(- target_url=f"{server.base_url}/lake/switchyard/posting",- max_retries=0,- )- )- await request_processor.process(ctx, request)- await response_processor.process(- ctx, ChatResponse.openai_completion(_completion())- )- await response_processor.shutdown()-- # One routed-turn document plus one per routing call, all flat documents.- posted = server.requests- assert len(posted) == 2- for entry in posted:- assert entry["path"] == "/lake/switchyard/posting"- # Distinct _id so the routing record never overwrites the routed turn.- assert len({entry["body"]["_id"] for entry in posted}) == 2- routed = {entry["body"].get("s_switchyard_routed_to") for entry in posted}- assert "classifier" in routed-- async def test_header_opt_out_overrides_store_true_in_rust_context(self):- request_processor = IntakeRequestProcessor()- request = ChatRequest.openai_chat({- "model": "gpt-4o",- "messages": [{"role": "user", "content": "hi"}],- "store": True,- })- ctx = ProxyContext()- attach_request_metadata(- ctx,- RequestMetadata.from_headers({- "x-switchyard-intake-enabled": "false",- }),- )-- with _IntakeHttpStub() as server:- response_processor = IntakeResponseProcessor(- IntakeSinkConfig(- intake_base_url=server.base_url,- workspace="default",- max_retries=0,- )- )- await request_processor.process(ctx, request)- await response_processor.process(ctx, ChatResponse.openai_completion(_completion()))- await response_processor.shutdown()-- assert server.requests == []-- async def test_http_endpoint_attaches_headers_to_rust_context(self):- request_processor = IntakeRequestProcessor()-- with _IntakeHttpStub() as server:- response_processor = IntakeResponseProcessor(- IntakeSinkConfig(- intake_base_url=server.base_url,- workspace="default",- max_retries=0,- capture_content=True,- )- )- switchyard = Switchyard(- request_processors=[request_processor],- backend=_StaticCompletionBackend(),- response_processors=[response_processor],- translator=TranslationEngine(),- )- app = build_switchyard_app(switchyard)-- async with httpx.AsyncClient(- transport=httpx.ASGITransport(app=app, raise_app_exceptions=False),- base_url="http://test",- ) as client:- response = await client.post(- "/v1/chat/completions",- headers={- "x-switchyard-intake-enabled": "true",- "x-switchyard-intake-app": "codex",- },- json={- "model": "gpt-4o",- "messages": [{"role": "user", "content": "hi"}],- },- )- await response_processor.shutdown()-- assert response.status_code == 200, response.text- assert len(server.requests) == 1- payload = server.requests[0]["body"]- assert "app" not in payload["request"]["switchyard"]- assert payload["request"]["messages"][0]["content"] == "hi"---class TestIntakeResponseProcessor:- def test_requires_http_sink_base_url(self) -> None:- with pytest.raises(RuntimeError, match="intake_base_url"):- IntakeResponseProcessor(IntakeSinkConfig())-- async def test_missing_request_state_leaves_response_untouched(self):- processor = IntakeResponseProcessor(- IntakeSinkConfig(- intake_base_url="http://127.0.0.1:9",- workspace="default",- )- )- response = ChatResponse.openai_completion(_completion(content="world"))- ctx = ProxyContext()-- returned = await processor.process(ctx, response)-- assert returned.body == response.body---class TestIntakeClient:- async def test_aclose_flushes_background_payloads(self, monkeypatch):- _stub_sdk_client(monkeypatch)- client = IntakeClient(- IntakeSinkConfig(- intake_base_url="http://localhost:8080",- workspace="default",- )- )- posted: list[dict[str, object]] = []-- async def fake_post(payload: dict[str, object]) -> None:- posted.append(payload)-- monkeypatch.setattr(client, "_post_payload", fake_post)-- client.enqueue_background(lambda: {"ok": True})- await client.aclose()-- assert posted == [{"ok": True}]-- async def test_post_payload_uses_sdk_generic_post(self, monkeypatch):- sdk_client = _stub_sdk_client(monkeypatch)- client = IntakeClient(- IntakeSinkConfig(- intake_base_url="http://localhost:8080",- workspace="team space",- )- )- payload = {"request": {"model": "m", "messages": []}, "response": {"choices": []}}-- await client._post_payload(payload)-- sdk_client.post.assert_awaited_once_with(- "/apis/intake/v2/workspaces/team%20space/ingest/chat-completions",- cast_to=object,- body=payload,- )-- def test_missing_sdk_raises_clear_error(self, monkeypatch):- import sys-- monkeypatch.setitem(sys.modules, "nemo_platform", None)- with pytest.raises(RuntimeError, match="NeMo Platform SDK"):- IntakeClient(- IntakeSinkConfig(- intake_base_url="http://localhost:8080",- workspace="default",- )- )diff --git a/tests/test_intake_target.py b/tests/test_intake_target.pydeleted file mode 100644index edbb91230..000000000--- a/tests/test_intake_target.py+++ /dev/null@@ -1,38 +0,0 @@-# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-# SPDX-License-Identifier: Apache-2.0--"""Tests for Intake target URL resolution on ``switchyard serve``."""--import argparse--from switchyard.cli.intake_cli_config import IntakeCliConfig---def test_server_target_flag_wins_over_environment() -> None:- args = argparse.Namespace(- intake_enabled=True,- intake_target_url="https://from-flag.example/posting",- )- resolved = IntakeCliConfig.from_server_args(- args,- env={"SWITCHYARD_INTAKE_TARGET_URL": "https://from-env.example/posting"},- )- assert resolved.target_url == "https://from-flag.example/posting"---def test_server_target_resolves_from_environment() -> None:- args = argparse.Namespace(intake_enabled=True, intake_target_url=None)- resolved = IntakeCliConfig.from_server_args(- args,- env={"SWITCHYARD_INTAKE_TARGET_URL": "https://from-env.example/posting"},- )- assert resolved.target_url == "https://from-env.example/posting"---def test_server_environment_can_enable_intake() -> None:- args = argparse.Namespace(intake_enabled=False, intake_target_url=None)- resolved = IntakeCliConfig.from_server_args(- args,- env={"SWITCHYARD_INTAKE_ENABLED": "1"},- )- assert resolved.enabled is Truediff --git a/tests/test_llm_classifier_request_processor.py b/tests/test_llm_classifier_request_processor.pyindex 5337c56d6..bc261454e 100644--- a/tests/test_llm_classifier_request_processor.py+++ b/tests/test_llm_classifier_request_processor.py@@ -123,46 +123,6 @@ async def test_request_processor_stamps_classifier_signals() -> None:assert "debug this traceback" in fake.calls[0]["request_summary"]-async def test_request_processor_stashes_submodel_call_on_success() -> None:- """Success records the classifier's usage for the intake sink to emit."""- fake = _FakeClassifierClient(- _signals_json(),- usage=_FakeUsage(prompt_tokens=420, completion_tokens=80, cached_tokens=10),- )- processor = LLMClassifierRequestProcessor(- LLMClassifierConfig(model="router-classifier"),- client=fake,- )- ctx = ProxyContext()-- await processor.process(ctx, _request())-- assert ctx.submodel_calls == [- {- "model": "router-classifier",- "prompt_tokens": 420,- "completion_tokens": 80,- "cached_tokens": 10,- "router_type": "deterministic",- "routed_to": "classifier",- }- ]---async def test_request_processor_stashes_no_submodel_call_on_fail_open() -> None:- """Fail-open (classifier errored) has no usage, so nothing is recorded."""- fake = _FakeClassifierClient(RuntimeError("upstream down"))- processor = LLMClassifierRequestProcessor(- LLMClassifierConfig(model="router-classifier", fail_open=True),- client=fake,- )- ctx = ProxyContext()-- await processor.process(ctx, _request())-- assert ctx.submodel_calls == []--async def test_classifier_skips_llm_call_when_session_pinned() -> None:"""Once a conversation is pinned, the classifier runs once per task, not per turn."""fake = _FakeClassifierClient(_signals_json())diff --git a/tests/test_request_metadata.py b/tests/test_request_metadata.pyindex 76a9dd44b..285544b78 100644--- a/tests/test_request_metadata.py+++ b/tests/test_request_metadata.py@@ -10,12 +10,12 @@ import pytestfrom switchyard.lib.proxy_context import CTX_CALLER_API_KEY, ProxyContextfrom switchyard.lib.request_metadata import (CTX_PROFILE_REQUEST_HEADERS,+ RequestMetadata,attach_caller_api_key,attach_request_metadata,extract_caller_api_key,redact_sensitive_headers,)-from switchyard_rust.components import RequestMetadataclass TestExtractCallerApiKey:@@ -91,7 +91,7 @@ class TestRedactSensitiveHeaders:"Authorization": "Bearer nvapi-real","x-api-key": "nvapi-x","x-switchyard-api-key": "nvapi-forwarded",- "x-switchyard-intake-app": "demo",+ "x-switchyard-intake-task": "demo","content-type": "application/json",}redacted = redact_sensitive_headers(headers)@@ -99,7 +99,7 @@ class TestRedactSensitiveHeaders:assert redacted["x-api-key"] == "[REDACTED]"assert redacted["x-switchyard-api-key"] == "[REDACTED]"# Non-credential headers pass through untouched.- assert redacted["x-switchyard-intake-app"] == "demo"+ assert redacted["x-switchyard-intake-task"] == "demo"assert redacted["content-type"] == "application/json"def test_matching_is_case_insensitive(self) -> None:@@ -109,13 +109,13 @@ class TestRedactSensitiveHeaders:class TestCallerKeyForwardedButNotRetained:"""The endpoint extracts the caller key for upstream use, then retains a- redacted header map so the key cannot leak into profile metadata, intake,- logs, or traces."""+ redacted header map so the key cannot leak into profile metadata, logs, or+ traces."""def test_key_extracted_but_redacted_in_stored_headers(self) -> None:headers = {"x-switchyard-api-key": "nvapi-secret",- "x-switchyard-intake-app": "demo",+ "x-switchyard-intake-task": "demo",}ctx = ProxyContext()# Mirror the endpoint: both helpers receive the raw headers.@@ -127,4 +127,4 @@ class TestCallerKeyForwardedButNotRetained:# ...but the retained header map carries no raw credential.stored = ctx.metadata[CTX_PROFILE_REQUEST_HEADERS]assert stored["x-switchyard-api-key"] == "[REDACTED]"- assert stored["x-switchyard-intake-app"] == "demo"+ assert stored["x-switchyard-intake-task"] == "demo"diff --git a/tests/test_rl_logging.py b/tests/test_rl_logging.pyindex 4ab814ae8..5f9293dc0 100644--- a/tests/test_rl_logging.py+++ b/tests/test_rl_logging.py@@ -328,8 +328,6 @@ def test_serve_attaches_rl_logging_processors(monkeypatch, tmp_path: Path) -> Noargs = argparse.Namespace(routing_profiles="profiles.yaml",enable_rl_logging=True, rl_log_dir=str(tmp_path),- intake_enabled=False, intake_base_url=None, intake_workspace=None,- intake_api_key=None, intake_target_url=None,routing_log_file=None,)cli._cmd_serve(args)diff --git a/tests/test_route_bundle.py b/tests/test_route_bundle.pyindex d2fcc00b7..1ca67a85e 100644--- a/tests/test_route_bundle.py+++ b/tests/test_route_bundle.py@@ -453,54 +453,6 @@ def test_main_accepts_routing_profiles_flag(assert capsys.readouterr().err == ""-def test_serve_subcommand_enables_intake_from_cli_args(- monkeypatch: pytest.MonkeyPatch,- tmp_path,-) -> None:- import switchyard.cli.switchyard_cli as cli- from switchyard.lib.processors import (- IntakeRequestProcessor,- IntakeResponseProcessor,- )-- yaml_path = tmp_path / "routes.yaml"- yaml_path.write_text(- "routes:\n"- " direct:\n"- " type: model\n"- " target: some/model\n"- )- captured: dict[str, Any] = {}-- def _fake_serve(- args: Any,- switchyard: object,- inbound_default: str,- **_kwargs: object,- ) -> None:- captured["switchyard"] = switchyard-- monkeypatch.setattr(cli, "build_and_serve", _fake_serve)-- args = cli._build_parser().parse_args([- "serve",- "--routing-profiles",- str(yaml_path),- "--intake-enabled",- "--intake-base-url",- "https://intake.example.test",- "--intake-api-key",- "sk-intake",- "--port",- "4555",- ])- args.func(args)-- components = captured["switchyard"].lookup_switchyard("direct").iter_components()- assert any(isinstance(component, IntakeRequestProcessor) for component in components)- assert any(isinstance(component, IntakeResponseProcessor) for component in components)--class TestEscalationRouterRouteType:"""`type: escalation_router` wires the judge-latched chain via YAML."""diff --git a/tests/test_routing_log_response_processor.py b/tests/test_routing_log_response_processor.pyindex 75fa1a62a..8cb95dfd0 100644--- a/tests/test_routing_log_response_processor.py+++ b/tests/test_routing_log_response_processor.py@@ -23,8 +23,7 @@ from switchyard.lib.processors.routing_log_response_processor import (RoutingLogResponseProcessor,)from switchyard.lib.proxy_context import CTX_PROXY_ACTUAL_MODEL-from switchyard.lib.request_metadata import attach_request_metadata-from switchyard_rust.components import RequestMetadata+from switchyard.lib.request_metadata import RequestMetadata, attach_request_metadatafrom switchyard_rust.core import ChatResponse, ProxyContextTASK_HEADERS = {diff --git a/tests/test_stage_router_classifier.py b/tests/test_stage_router_classifier.pyindex 4670f1d1a..5e0f4c84e 100644--- a/tests/test_stage_router_classifier.py+++ b/tests/test_stage_router_classifier.py@@ -10,7 +10,6 @@ to ``None`` so the picker keeps moving.import jsonfrom dataclasses import dataclass-from types import SimpleNamespacefrom typing import Anyfrom switchyard.lib.processors.stage_router.classifier import (@@ -211,29 +210,3 @@ async def test_window_4_appends_last_four_messages():assert "msg-5" in user_promptassert "msg-0" not in user_promptassert "msg-1" not in user_prompt---async def test_classify_stashes_submodel_call_for_intake() -> None:- """A successful tier-classifier call is recorded for the intake sink to emit."""- ctx, signal = await _build_signal()- resp = _Resp(content=json.dumps({"tier": "capable"}))- # The producer reads token usage off the response; _Resp carries no usage- # field, so attach one shaped like the OpenAI SDK usage object.- resp.usage = SimpleNamespace( # type: ignore[attr-defined]- prompt_tokens=333,- completion_tokens=12,- prompt_tokens_details=SimpleNamespace(cached_tokens=5),- )- classifier = TierClassifier(model="tier-clf", api_key="k", client=_StubClient(resp))-- assert await classifier.classify(ctx, signal) == CAPABLE_TIER- assert ctx.submodel_calls == [- {- "model": "tier-clf",- "prompt_tokens": 333,- "completion_tokens": 12,- "cached_tokens": 5,- "router_type": "stage_router",- "routed_to": "tier_classifier",- }- ]diff --git a/tests/test_switchyard_rust_component_bindings.py b/tests/test_switchyard_rust_component_bindings.pyindex 6673e64e4..b85dcec4d 100644--- a/tests/test_switchyard_rust_component_bindings.py+++ b/tests/test_switchyard_rust_component_bindings.py@@ -16,10 +16,6 @@ from switchyard_rust import (ChatRequestType,ChatResponse,EndpointConfig,- IntakeQueueFullPolicy,- IntakeRequestProcessor,- IntakeResponseProcessor,- IntakeSinkConfig,LLMBackend,LlmTarget,LlmTargetBackend,@@ -53,7 +49,6 @@ def test_component_exports_are_callable_processors_and_native_backends() -> Noneanthropic_target = _target("anthropic", "claude-test", format=BackendFormat.ANTHROPIC)assert callable(StatsRequestProcessor().process)- assert callable(IntakeRequestProcessor().process)assert callable(StatsResponseProcessor(StatsAccumulator()).process)assert isinstance(OpenAiNativeBackend(openai_target), LLMBackend)assert isinstance(AnthropicNativeBackend(anthropic_target), LLMBackend)@@ -84,8 +79,6 @@ def test_config_bindings_validate_and_own_values() -> None:}assert target.extra_body == {"chat_template_kwargs": {"enable_thinking": False}}assert target.extra_headers == {"X-Inference-Priority": "batch"}- assert IntakeQueueFullPolicy("block") == IntakeQueueFullPolicy.BLOCK-with pytest.raises(ValueError, match="Unknown backend format"):BackendFormat("bedrock")with pytest.raises(ValueError, match="must not be empty"):@@ -238,13 +231,3 @@ def test_wrappers_require_rust_native_backend_instances() -> None:with pytest.raises(TypeError):StatsLlmBackend(PythonOnlyBackend(), StatsAccumulator())---def test_intake_response_processor_validates_http_sink_config() -> None:- processor = IntakeResponseProcessor(- IntakeSinkConfig(intake_base_url="https://intake.example.test", api_key="key")- )- assert callable(processor.process)-- with pytest.raises(RuntimeError, match="intake_base_url"):- IntakeResponseProcessor(IntakeSinkConfig())diff --git a/tests/test_version_package_name.py b/tests/test_version_package_name.pydeleted file mode 100644index 1630829a3..000000000--- a/tests/test_version_package_name.py+++ /dev/null@@ -1,42 +0,0 @@-# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-# SPDX-License-Identifier: Apache-2.0--"""Regression tests for version lookups after the distribution rename."""--from __future__ import annotations--from importlib.metadata import PackageNotFoundError-from unittest.mock import patch---def _mock_version(name: str) -> str:- """Simulate an environment that only has ``nemo-switchyard`` installed."""- if name == "nemo-switchyard":- return "1.0.0"- raise PackageNotFoundError(name)---def test_intake_payload_builder_version_uses_nemo_switchyard_package() -> None:- from switchyard.lib.processors import intake_payload_builder-- intake_payload_builder._switchyard_version.cache_clear()- with patch(- "switchyard.lib.processors.intake_payload_builder.version",- side_effect=_mock_version,- ):- result = intake_payload_builder._switchyard_version()-- assert result == "1.0.0"---def test_intake_payload_builder_version_fallback_is_unknown() -> None:- from switchyard.lib.processors import intake_payload_builder-- intake_payload_builder._switchyard_version.cache_clear()- with patch(- "switchyard.lib.processors.intake_payload_builder.version",- side_effect=PackageNotFoundError("nemo-switchyard"),- ):- result = intake_payload_builder._switchyard_version()-- assert result == "unknown"diff --git a/uv.lock b/uv.lockindex 8fa9e845b..230dadf93 100644--- a/uv.lock+++ b/uv.lock@@ -16,15 +16,6 @@ resolution-markers = ["python_full_version < '3.13' and sys_platform != 'emscripten' and sys_platform != 'win32'",]-[[package]]-name = "aiofiles"-version = "25.1.0"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/41/c3/534eac40372d8ee36ef40df62ec129bee4fdb5ad9706e58a29be53b2c970/aiofiles-25.1.0.tar.gz", hash = "sha256:a8d728f0a29de45dc521f18f07297428d56992a742f0cd2701ba86e44d23d5b2", size = 46354, upload-time = "2025-10-09T20:51:04.358Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/bc/8a/340a1555ae33d7354dbca4faa54948d76d89a27ceef032c8c3bc661d003e/aiofiles-25.1.0-py3-none-any.whl", hash = "sha256:abe311e527c862958650f9438e859c1fa7568a141b22abcd015e120e86a85695", size = 14668, upload-time = "2025-10-09T20:51:03.174Z" },-]-[[package]]name = "aiohappyeyeballs"version = "2.6.1"@@ -182,15 +173,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" },]-[[package]]-name = "asgiref"-version = "3.11.1"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/63/40/f03da1264ae8f7cfdbf9146542e5e7e8100a4c66ab48e791df9a03d3f6c0/asgiref-3.11.1.tar.gz", hash = "sha256:5f184dc43b7e763efe848065441eac62229c9f7b0475f41f80e207a114eda4ce", size = 38550, upload-time = "2026-02-03T13:30:14.33Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/5c/0a/a72d10ed65068e115044937873362e6e32fab1b7dce0046aeb224682c989/asgiref-3.11.1-py3-none-any.whl", hash = "sha256:e8667a091e69529631969fd45dc268fa79b99c92c5fcdda727757e52146ec133", size = 24345, upload-time = "2026-02-03T13:30:13.039Z" },-]-[[package]]name = "attrs"version = "26.1.0"@@ -222,43 +204,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/3e/5c/fb93d3092640a24dfb7bd7727a24016d7c01774ca013e60efd3f683c8002/backrefs-7.0-py314-none-any.whl", hash = "sha256:a6448b28180e3ca01134c9cf09dcebafad8531072e09903c5451748a05f24bc9", size = 412349, upload-time = "2026-04-28T16:28:02.412Z" },]-[[package]]-name = "base58"-version = "2.1.1"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/7f/45/8ae61209bb9015f516102fa559a2914178da1d5868428bd86a1b4421141d/base58-2.1.1.tar.gz", hash = "sha256:c5d0cb3f5b6e81e8e35da5754388ddcc6d0d14b6c6a132cb93d69ed580a7278c", size = 6528, upload-time = "2021-10-30T22:12:17.858Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/4a/45/ec96b29162a402fc4c1c5512d114d7b3787b9d1c2ec241d9568b4816ee23/base58-2.1.1-py3-none-any.whl", hash = "sha256:11a36f4d3ce51dfc1043f3218591ac4eb1ceb172919cebe05b52a5bcc8d245c2", size = 5621, upload-time = "2021-10-30T22:12:16.658Z" },-]--[[package]]-name = "boto3"-version = "1.43.36"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "botocore" },- { name = "jmespath" },- { name = "s3transfer" },-]-sdist = { url = "https://files.pythonhosted.org/packages/ff/9f/897287e955db0f50b12fd69ef45956e4fd2c7ddb48c736872f7ea2314443/boto3-1.43.36.tar.gz", hash = "sha256:587d7ee92a12e440ad12b0e7f11f3358f0c4d65b19f64726efc94aaf194aff28", size = 112690, upload-time = "2026-06-23T02:47:14.561Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/9f/f1/274303f52483ecf199eae6f8d9b6f5951670397ee4d72c06cfd4eb644612/boto3-1.43.36-py3-none-any.whl", hash = "sha256:42942dde254673abcbc9e6e60017c88341a4f49d99d24e1f2e290fb38138c26f", size = 140031, upload-time = "2026-06-23T02:47:13.178Z" },-]--[[package]]-name = "botocore"-version = "1.43.36"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "jmespath" },- { name = "python-dateutil" },- { name = "urllib3" },-]-sdist = { url = "https://files.pythonhosted.org/packages/7c/37/da9e7f6ca73ac73afd7f0bb7f238aa5daba35c081e98d7f48a7c399599c0/botocore-1.43.36.tar.gz", hash = "sha256:4cae47d1b2d426316b85a0087d9e69e048f13bc003b5177d74639fe9dfd28205", size = 15625488, upload-time = "2026-06-23T02:47:03.192Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/5c/19/934f81592527a3f7f9b943c893e334c721a4644948642bc33885d584e9ec/botocore-1.43.36-py3-none-any.whl", hash = "sha256:3c65fdc39ed01d8dfde1e961b34038aed03c459f8ddf80717a12ac006475e49d", size = 15313630, upload-time = "2026-06-23T02:46:59.327Z" },-]-[[package]]name = "bytecode"version = "0.18.1"@@ -676,15 +621,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/02/c3/253a89ee03fc9b9682f1541728eb66db7db22148cd94f89ab22528cd1e1b/deprecation-2.1.0-py2.py3-none-any.whl", hash = "sha256:a10811591210e1fb0e768a8c25517cabeabcba6f0bf96564f8ff45189f90b14a", size = 11178, upload-time = "2020-04-20T14:23:36.581Z" },]-[[package]]-name = "detect-installer"-version = "0.1.0"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/5f/ce/6897d812825e9d4c53e3c7112726e800cc5231b013b2223bf64f653ff362/detect_installer-0.1.0.tar.gz", hash = "sha256:00ad7ba0a36e3cf7d08a40d3643011746dbc112597c7d475cc91c416710ca4e7", size = 3049, upload-time = "2026-02-23T10:40:22.567Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/cc/34/8cc73273414405086c58852916e4031812a6a30fe04c057e37ad99397b7f/detect_installer-0.1.0-py3-none-any.whl", hash = "sha256:034fb20fd665c36e6ba52b8821525ea07fb4f7f938cac459df889fb33801528a", size = 4539, upload-time = "2026-02-23T10:40:23.807Z" },-]-[[package]]name = "dill"version = "0.4.1"@@ -715,29 +651,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277, upload-time = "2023-12-24T09:54:30.421Z" },]-[[package]]-name = "dnspython"-version = "2.8.0"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/8c/8b/57666417c0f90f08bcafa776861060426765fdb422eb10212086fb811d26/dnspython-2.8.0.tar.gz", hash = "sha256:181d3c6996452cb1189c4046c61599b84a5a86e099562ffde77d26984ff26d0f", size = 368251, upload-time = "2025-09-07T18:58:00.022Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/ba/5a/18ad964b0086c6e62e2e7500f7edc89e3faa45033c71c1893d34eed2b2de/dnspython-2.8.0-py3-none-any.whl", hash = "sha256:01d9bbc4a2d76bf0db7c1f729812ded6d912bd318d3b1cf81d30c0f845dbf3af", size = 331094, upload-time = "2025-09-07T18:57:58.071Z" },-]--[[package]]-name = "docker"-version = "7.1.0"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "pywin32", marker = "sys_platform == 'win32'" },- { name = "requests" },- { name = "urllib3" },-]-sdist = { url = "https://files.pythonhosted.org/packages/91/9b/4a2ea29aeba62471211598dac5d96825bb49348fa07e906ea930394a83ce/docker-7.1.0.tar.gz", hash = "sha256:ad8c70e6e3f8926cb8a92619b832b4ea5299e2831c14284663184e200546fa6c", size = 117834, upload-time = "2024-05-23T11:13:57.216Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/e3/26/57c6fb270950d476074c087527a558ccb6f4436657314bfb6cdf484114c4/docker-7.1.0-py3-none-any.whl", hash = "sha256:c96b93b7f0a746f9e77d325bcfb87422a3d8bd4f03136ae8a85b37f1898d5fc0", size = 147774, upload-time = "2024-05-23T11:13:55.01Z" },-]-[[package]]name = "docstring-parser"version = "0.18.0"@@ -747,28 +660,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/a7/5f/ed01f9a3cdffbd5a008556fc7b2a08ddb1cc6ace7effa7340604b1d16699/docstring_parser-0.18.0-py3-none-any.whl", hash = "sha256:b3fcbed555c47d8479be0796ef7e19c2670d428d72e96da63f3a40122860374b", size = 22484, upload-time = "2026-04-14T04:09:18.638Z" },]-[[package]]-name = "durationpy"-version = "0.10"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/9d/a4/e44218c2b394e31a6dd0d6b095c4e1f32d0be54c2a4b250032d717647bab/durationpy-0.10.tar.gz", hash = "sha256:1fa6893409a6e739c9c72334fc65cca1f355dbdd93405d30f726deb5bde42fba", size = 3335, upload-time = "2025-05-17T13:52:37.26Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/b0/0d/9feae160378a3553fa9a339b0e9c1a048e147a4127210e286ef18b730f03/durationpy-0.10-py3-none-any.whl", hash = "sha256:3b41e1b601234296b4fb368338fdcd3e13e0b4fb5b67345948f4f2bf9868b286", size = 3922, upload-time = "2025-05-17T13:52:36.463Z" },-]--[[package]]-name = "email-validator"-version = "2.3.0"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "dnspython" },- { name = "idna" },-]-sdist = { url = "https://files.pythonhosted.org/packages/f5/22/900cb125c76b7aaa450ce02fd727f452243f2e91a61af068b40adba60ea9/email_validator-2.3.0.tar.gz", hash = "sha256:9fc05c37f2f6cf439ff414f8fc46d917929974a82244c20eb10231ba60c54426", size = 51238, upload-time = "2025-08-26T13:09:06.831Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/de/15/545e2b6cf2e3be84bc1ed85613edd75b8aea69807a71c26f4ca6a9258e82/email_validator-2.3.0-py3-none-any.whl", hash = "sha256:80f13f623413e6b197ae73bb10bf4eb0908faf509ad8362c5edeb0be7fd450b4", size = 35604, upload-time = "2025-08-26T13:09:05.858Z" },-]-[[package]]name = "envier"version = "0.6.1"@@ -794,131 +685,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/5a/ff/2e4eca3ade2c22fe1dea7043b8ee9dabe47753349eb1b56a202de8af6349/fastapi-0.136.1-py3-none-any.whl", hash = "sha256:a6e9d7eeada96c93a4d69cb03836b44fa34e2854accb7244a1ece36cd4781c3f", size = 117683, upload-time = "2026-04-23T16:49:42.437Z" },]-[package.optional-dependencies]-standard = [- { name = "email-validator" },- { name = "fastapi-cli", extra = ["standard"] },- { name = "fastar" },- { name = "httpx" },- { name = "jinja2" },- { name = "pydantic-extra-types" },- { name = "pydantic-settings" },- { name = "python-multipart" },- { name = "uvicorn", extra = ["standard"] },-]--[[package]]-name = "fastapi-cli"-version = "0.0.27"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "rich-toolkit" },- { name = "typer" },- { name = "uvicorn", extra = ["standard"] },-]-sdist = { url = "https://files.pythonhosted.org/packages/37/d0/ee5678346811967b8d096d5d5604e71b50d6bf5a2abfbdb331157e2bbaa9/fastapi_cli-0.0.27.tar.gz", hash = "sha256:1dffb1e40c0c88f2e0171a8a252a2b615c1e63ff8c05626649e4badd6a84336a", size = 23630, upload-time = "2026-06-18T14:48:43.421Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/1a/ab/0a709f9488fe62647db80f8a277fb0ee62e85adc6746abf477ed373c9eb7/fastapi_cli-0.0.27-py3-none-any.whl", hash = "sha256:2e389a40f318e29fec8cb1e289f267f17c048876fb82dbfa869a10b16740495d", size = 13070, upload-time = "2026-06-18T14:48:44.311Z" },-]--[package.optional-dependencies]-standard = [- { name = "fastapi-cloud-cli" },- { name = "uvicorn", extra = ["standard"] },-]--[[package]]-name = "fastapi-cloud-cli"-version = "0.21.0"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "detect-installer" },- { name = "fastar" },- { name = "httpx" },- { name = "pydantic", extra = ["email"] },- { name = "rich-toolkit" },- { name = "rignore" },- { name = "sentry-sdk" },- { name = "typer" },- { name = "uvicorn", extra = ["standard"] },-]-sdist = { url = "https://files.pythonhosted.org/packages/60/c3/5cd0b824ca4b4fd073ce998321881ed68b8e0b85d441653eb1bd997c6fc0/fastapi_cloud_cli-0.21.0.tar.gz", hash = "sha256:463350dcbdcbb9b3baa32a99a3db0610f34a3ae143dd1d35a71173aec5dd245d", size = 93804, upload-time = "2026-06-24T15:23:07.554Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/15/a0/2ec3fb041fd41281073cb11ed6c63a33bc1f7a315554e26256a9709dbe47/fastapi_cloud_cli-0.21.0-py3-none-any.whl", hash = "sha256:ea49208fb301b2298e6ddaf9225163cf6dbb255bc9126001242f3cd21486bbe6", size = 76195, upload-time = "2026-06-24T15:23:06.609Z" },-]--[[package]]-name = "fastar"-version = "0.11.0"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/03/0f/0aeb3fc50046617702acc0078b277b58367fd62eb727b9ec733ae0e8bbcc/fastar-0.11.0.tar.gz", hash = "sha256:aa7f100f7313c03fdb20f1385927ba95671071ba308ad0c1763fef295e1895ce", size = 70238, upload-time = "2026-04-13T17:11:17.143Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/0f/06/a5773706afc8bd496769786590bbc56d2d0ee419a299cc12ea3f5717fcf3/fastar-0.11.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:3c51f1c2cdddbd1420d2897ace7738e36c65e17f6ae84e0bfe763f8d1068bb97", size = 708394, upload-time = "2026-04-13T17:09:57.269Z" },- { url = "https://files.pythonhosted.org/packages/cc/a6/d5e2a4e48495616440a21eed07558219ca90243ad00b0502586f95bd4833/fastar-0.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0d9d6b052baf5380baea866675dab6ccd04ec2460d12b1c46f10ce3f4ee6a820", size = 628417, upload-time = "2026-04-13T17:09:42.145Z" },- { url = "https://files.pythonhosted.org/packages/ab/69/9816d69ac8265c9e50456637a487ccfb7a9c566efd9dbcd673df9c2558c2/fastar-0.11.0-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:bd2f05666d4df7e14885b5c38fefd92a785917387513d33d837ff42ec143a22f", size = 863950, upload-time = "2026-04-13T17:09:11.506Z" },- { url = "https://files.pythonhosted.org/packages/5b/0d/f88daad53aff2e754b6b5ff2a7113f72447a34f6ef17cc23ca99988117b7/fastar-0.11.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c1e6e74aba1ae77ca4aedcaf1697cd413319f4c88a5ccbe5b42c709517c5097e", size = 760737, upload-time = "2026-04-13T17:07:55.958Z" },- { url = "https://files.pythonhosted.org/packages/2f/a6/82ef4ecd969d50d92ed3ed9dbd8fe77faa24be5e5736f716edc9f4ce8d62/fastar-0.11.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:38ef77fe940bbc9b37a98bd838727f844b11731cd39358a2640ff864fb385086", size = 757603, upload-time = "2026-04-13T17:08:10.623Z" },- { url = "https://files.pythonhosted.org/packages/03/35/50249f0d827251f8ac511495e2eacccebda80a00a0ad73e9615b8113b84f/fastar-0.11.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8955e61b32d6aff82c983217abf80933fd823b0e727586fc72f08043d996fd59", size = 923952, upload-time = "2026-04-13T17:08:25.526Z" },- { url = "https://files.pythonhosted.org/packages/7b/d8/faee41659e9c379d906d24eaee6d6833ac8cfef0a5df480e5c2a8d3efb33/fastar-0.11.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:483532442cdb08fbff0169510224eae0836f2f672cea6aacb52847d90fefdc46", size = 816574, upload-time = "2026-04-13T17:08:56.076Z" },- { url = "https://files.pythonhosted.org/packages/22/47/0448ea7992b997dad2bf004bfd98eca74b5858630eae080b50c7b17d9ddc/fastar-0.11.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ef5a6071121e05d8287fc75bccb054bcbac8bb0501200a0c0a8feeace5303ea4", size = 819382, upload-time = "2026-04-13T17:09:26.66Z" },- { url = "https://files.pythonhosted.org/packages/33/ef/0d63eb43586831b7a6f8b22c4d77125a7c594423af1f4f090fa9541b9b40/fastar-0.11.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:e45e598af5afe8412197d4786efd6cf29be02e7d3d4f6a3461149eae5d7e94f1", size = 885254, upload-time = "2026-04-13T17:08:40.9Z" },- { url = "https://files.pythonhosted.org/packages/01/25/edd584675d69e49a165052c3ee886df1c5d574f3e7d813c990306387c623/fastar-0.11.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2e160919b1c47ddb8538e7e8eb4cd527281b40f0bf75110a75993838ef61f286", size = 971239, upload-time = "2026-04-13T17:10:12.997Z" },- { url = "https://files.pythonhosted.org/packages/a5/37/e8bb24f506ba2b08fbaf36c5800e843bd4d542954e9331f00418e2d23349/fastar-0.11.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:4bb4dc0fc8f7a6807febcebce8a2f3626ba4955a9263d81ecc630aad83be84c0", size = 1035185, upload-time = "2026-04-13T17:10:30.207Z" },- { url = "https://files.pythonhosted.org/packages/9a/bf/be753736296338149ee4cb3e92e2b5423d6ba17c7b951d15218fd7e99bbf/fastar-0.11.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:4ec95af56aa173f6e320e1183001bf108ba59beaf13edd1fc8200648db203588", size = 1072191, upload-time = "2026-04-13T17:10:47.072Z" },- { url = "https://files.pythonhosted.org/packages/d2/cd/a81c1aaafb5a22ce57c98ae22f39c89413ed53e4ee6e1b1444b0bd666a6c/fastar-0.11.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:136cf342735464091c39dc3708168f9fdeb9ebea40b1ead937c61afaf46143d9", size = 1028054, upload-time = "2026-04-13T17:11:04.293Z" },- { url = "https://files.pythonhosted.org/packages/ec/88/1ce4eed3d70627c95f49ca017f6bbbf2ddcc4b0c601d293259de7689bc20/fastar-0.11.0-cp312-cp312-win32.whl", hash = "sha256:35f23c11b556cc4d3704587faacbc0037f7bdf6c4525cd1d09c70bda4b1c6809", size = 454198, upload-time = "2026-04-13T17:11:45.168Z" },- { url = "https://files.pythonhosted.org/packages/8f/1d/26ce92f4331cd61a69840db9ca6115829805eec24f285481a854f578e917/fastar-0.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:920bc56c3c0b8a8ca492904941d1883c1c947c858cd93343356c29122a38f44c", size = 486697, upload-time = "2026-04-13T17:11:31.084Z" },- { url = "https://files.pythonhosted.org/packages/ed/96/e6eda4480559c69b05d466e7b5ea9170e81fef3795a73e059959a3258319/fastar-0.11.0-cp312-cp312-win_arm64.whl", hash = "sha256:395248faf89e8a6bd5dc1fd544c8465113b627cb6d7c8b296796b60ebea33593", size = 462591, upload-time = "2026-04-13T17:11:20.577Z" },- { url = "https://files.pythonhosted.org/packages/c9/d6/3be260037e86fb694e88d47f583bac3a0188c99cee1a6b257ac26cb6b53c/fastar-0.11.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:33f544b08b4541b678e53749b4552a44720d96761fb79c172b005b1089c443ed", size = 707975, upload-time = "2026-04-13T17:09:58.866Z" },- { url = "https://files.pythonhosted.org/packages/e1/cd/7867aefb1784662554a335f2952c75a50f0c70585ed0d2210d6cc15e5627/fastar-0.11.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:91c1c792447e4a642745f347ff9847c52af39633071c57ee67ed53c157fc3506", size = 628460, upload-time = "2026-04-13T17:09:43.776Z" },- { url = "https://files.pythonhosted.org/packages/e5/2b/d11d84bdd5e0e377771b955755771e3460b290da5809cb78c1b735ee2228/fastar-0.11.0-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:881247e6b6eaea59fc6569f9b61447aa6b9fc2ee864e048b4643d69c52745805", size = 863054, upload-time = "2026-04-13T17:09:13.048Z" },- { url = "https://files.pythonhosted.org/packages/25/39/d3f428b318fa940b1b6e785b8d54fc895dfb5d5b945ef8d5442ffa904fb2/fastar-0.11.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:863b7929845c9fec92ef6c8d59579cf46af5136655e5342f8df5cebe46cab06c", size = 760247, upload-time = "2026-04-13T17:07:57.396Z" },- { url = "https://files.pythonhosted.org/packages/9e/04/03949aee82aabb8ede06ac5a4a5579ffaf98a8fe59ce958494508ff15513/fastar-0.11.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:96b4a57df12bf3211662627a3ea29d62ecb314a2434a0d0843f9fc23e47536e5", size = 756512, upload-time = "2026-04-13T17:08:12.415Z" },- { url = "https://files.pythonhosted.org/packages/3f/0c/2ca1ae0a3828ca51047962d932b80daca2522db73e8cb9d040cb6ebe28d5/fastar-0.11.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ceef1c2c4df7b7b8ebd3f5d718bbf457b9bbdf25ce0bd07870211ec4fbd9aff4", size = 922183, upload-time = "2026-04-13T17:08:27.187Z" },- { url = "https://files.pythonhosted.org/packages/65/68/7fe808b1f73a68e686f25434f538c6dc10ef4dfb3db0ace22cd861744bf8/fastar-0.11.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b8e545918441910a779659d4759ad0eef349e935fbdb4668a666d3681567eb05", size = 816394, upload-time = "2026-04-13T17:08:57.657Z" },- { url = "https://files.pythonhosted.org/packages/1f/17/07d086080f8a83b8d7966955e29bcdbd6a060f5bd949dc9d5abd3658cead/fastar-0.11.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:28095bb8f821e85fc2764e1a55f03e5e2876dee2abe7cd0ee9420d929905d643", size = 818983, upload-time = "2026-04-13T17:09:28.46Z" },- { url = "https://files.pythonhosted.org/packages/fb/e2/2c4edf0910af2e814ff6d65b77a91196d472ca8a9fb2033bd983f6856caa/fastar-0.11.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:0fafb95ecbe70f666a5e9b35dd63974ccdc9bb3d99ccdbd4014a823ec3e659b5", size = 884689, upload-time = "2026-04-13T17:08:42.763Z" },- { url = "https://files.pythonhosted.org/packages/fa/ba/04fdcbd6558e60de4ced3b55230fac47675d181252582b2fcec3c74608e5/fastar-0.11.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:af48fed039b94016629dcdad1c95c90c486326dd068de2b0a4df419ee09b6821", size = 970677, upload-time = "2026-04-13T17:10:15.124Z" },- { url = "https://files.pythonhosted.org/packages/df/b3/2b860a9658550167dbd5824c85e88d0b4b912bf493e42a6322544d6e483d/fastar-0.11.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:74cd96163f39b8638ab4e8d49708ca887959672a22871d8170d01f067319533b", size = 1034026, upload-time = "2026-04-13T17:10:32.318Z" },- { url = "https://files.pythonhosted.org/packages/b7/9b/fa42ea1188b144bac4b1b60753dfd449974a4d5eda132029ee7711569f94/fastar-0.11.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:4e8b993cb5613bab495ed482810bedc0986633fcb9a3b55c37ec88e0d6714f6a", size = 1071147, upload-time = "2026-04-13T17:10:48.833Z" },- { url = "https://files.pythonhosted.org/packages/95/c8/d2e501556dca9f1fbc9246111a31792fb49ad908fa4927f34938a97a3604/fastar-0.11.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dfe39d91fc28e37e06162d94afe01050220edb7df554acb5b702b5503e564816", size = 1028377, upload-time = "2026-04-13T17:11:06.374Z" },- { url = "https://files.pythonhosted.org/packages/db/33/5f11f23eca0a569cd052507bc45dda2e5468697f8665728d25be44120f7d/fastar-0.11.0-cp313-cp313-win32.whl", hash = "sha256:c5f63d4d99ff4bfb37c659982ec413358bdee747005348756cc50a04d412d989", size = 454089, upload-time = "2026-04-13T17:11:46.821Z" },- { url = "https://files.pythonhosted.org/packages/da/2f/35ff03c939cba7a255a9132367873fec6c355fd06a7f84fedcbaf4c8129f/fastar-0.11.0-cp313-cp313-win_amd64.whl", hash = "sha256:8690ed1928d31ded3ada308e1086525fb3871f5fa81e1b69601a3f7774004583", size = 486312, upload-time = "2026-04-13T17:11:32.86Z" },- { url = "https://files.pythonhosted.org/packages/ef/71/ee9246cbfcbfd4144558f35e7e9a306ffe0a7564730a5188c45f21d2dab8/fastar-0.11.0-cp313-cp313-win_arm64.whl", hash = "sha256:d977ded9d98a0719a305e0a4d5ee811f1d3e856d853a50acb8ae833c3cd6d5d2", size = 461975, upload-time = "2026-04-13T17:11:22.589Z" },- { url = "https://files.pythonhosted.org/packages/7a/cd/3644c48ecac456f928c12d47ec3bed36c36555b17c3859856f1ff860265d/fastar-0.11.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:71375bd6f03c2a43eb47bd949ea38ff45434917f9cdac79675c5b9f60de4fa73", size = 707860, upload-time = "2026-04-13T17:10:00.371Z" },- { url = "https://files.pythonhosted.org/packages/69/ca/dee04476ae3626b2b040a60ad84628f77e1ffd8444232f2426b0ca1e0d7e/fastar-0.11.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:eddfd9cab16e19ae247fe44bf992cb403ccfe27d3931d6de29a4695d95ad386c", size = 628216, upload-time = "2026-04-13T17:09:45.355Z" },- { url = "https://files.pythonhosted.org/packages/dc/5e/9395c7353d079cb4f5be0f7982ce0dc9f2e7dec5fd175eef466729d6023a/fastar-0.11.0-cp314-cp314-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:7c371f1d4386c699018bb64eb2fa785feacf32785559049d2bb72fe4af023f53", size = 864378, upload-time = "2026-04-13T17:09:14.611Z" },- { url = "https://files.pythonhosted.org/packages/fa/ba/1e4f67148223ff219612b6281a6000357abbcc2417964fa5c83f11d68fce/fastar-0.11.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cad7fa41e3e66554387481c1a09365e4638becd322904932674159d5f4046728", size = 760921, upload-time = "2026-04-13T17:07:59.138Z" },- { url = "https://files.pythonhosted.org/packages/0f/82/09d11fb6d12f17993ffaf32ffd30c3c121a11e2966e84f19fb6f66430118/fastar-0.11.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cf36652fa71b83761717c9899b98732498f8a2cb6327ff16bbf07f6be85c3437", size = 757012, upload-time = "2026-04-13T17:08:14.186Z" },- { url = "https://files.pythonhosted.org/packages/52/1f/5aeeacc4cb65615e2c9292cd9c5b0cd6fb6d2e6ee472ca6adc6c1b1b22ef/fastar-0.11.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f68ff8c17833053da4841720e95edde80ce45bb994b6b7d51418dddaac70ee47", size = 924510, upload-time = "2026-04-13T17:08:28.741Z" },- { url = "https://files.pythonhosted.org/packages/bb/1a/1e5bdabbeaf2e856928956292609f2ff6a650f94480fb8afaca30229e483/fastar-0.11.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4563ed37a12ea1cdc398af8571258d24b988bf342b7b3bf5451bd5891243280c", size = 816602, upload-time = "2026-04-13T17:08:59.461Z" },- { url = "https://files.pythonhosted.org/packages/87/24/f960147910da3bed41a3adfcb026e17d5f50f4cf467a3324237a7088f61a/fastar-0.11.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cee63c9875cba3b70dc44338c560facc5d6e763047dcc4a30501f9a68cf5f890", size = 819452, upload-time = "2026-04-13T17:09:29.926Z" },- { url = "https://files.pythonhosted.org/packages/cc/f4/3e77d7901d5707fd7f8a352e153c8ae09ea974e6fabad0b7c4eb9944b8d4/fastar-0.11.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:bd76bfffae6d0a91f4ac4a612f721e7aec108db97dccdd120ae063cd66959f27", size = 885254, upload-time = "2026-04-13T17:08:44.285Z" },- { url = "https://files.pythonhosted.org/packages/47/01/1585edd5ec47782ae93cd94edf05828e0ab02ef00aec00aea4194a600464/fastar-0.11.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8f5b707501ec01c1bc0518f741f01d322e50c9adc19a451aa24f67a2316e9397", size = 971496, upload-time = "2026-04-13T17:10:17.024Z" },- { url = "https://files.pythonhosted.org/packages/f1/e9/6874c9d1236ded565a0bed54b320ac9f165f287b1d89490fb70f9f323c81/fastar-0.11.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:37c0b5a88a657839aad98b0a6c9e4ac4c2c15d6b49c44ee3935c6b08e9d3e479", size = 1034685, upload-time = "2026-04-13T17:10:34.063Z" },- { url = "https://files.pythonhosted.org/packages/14/d8/4ab20613ce2983427aee958e39be878dba874aa227c530a845e32429c4f6/fastar-0.11.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:6c55f536c62a6efb180c1af0d5182948bff576bbfe6276e8e1359c9c7d2215d8", size = 1072675, upload-time = "2026-04-13T17:10:50.53Z" },- { url = "https://files.pythonhosted.org/packages/1f/ae/5ac3b7c20ce4b08f011dd2b979f96caabe64f9b10b157f211ea91bdfadca/fastar-0.11.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3082eeca59e189b9039335862f4c2780c0c8871d656bfdf559db4414a105b251", size = 1029330, upload-time = "2026-04-13T17:11:08.138Z" },- { url = "https://files.pythonhosted.org/packages/8a/e7/37cd6a1d4e288292170b64e19d79ecce2a7de8bb76790323399a2abc4619/fastar-0.11.0-cp314-cp314-win32.whl", hash = "sha256:b201a0a4e29f9fec2a177e13154b8725ec65ab9f83bd6415483efaa2aa18344b", size = 453940, upload-time = "2026-04-13T17:11:48.713Z" },- { url = "https://files.pythonhosted.org/packages/ff/1c/795c878b1ee29d79021cf8ed81f18f2b25ccde58453b0d34b9bdc7e025ea/fastar-0.11.0-cp314-cp314-win_amd64.whl", hash = "sha256:868fddb26072a43e870a8819134b9f80ee602931be5a76e6fb873e04da343637", size = 486334, upload-time = "2026-04-13T17:11:34.882Z" },- { url = "https://files.pythonhosted.org/packages/ff/a4/113f104301df8bddcc0b3775b611a30cb7610baa3add933c7ccac9386467/fastar-0.11.0-cp314-cp314-win_arm64.whl", hash = "sha256:3db39c9cc42abb0c780a26b299f24dfbc8be455985e969e15336d70d7b2f833b", size = 461534, upload-time = "2026-04-13T17:11:24.329Z" },- { url = "https://files.pythonhosted.org/packages/5a/a6/5c5f2c2c8e0c63e56a5636ebc7721589c889e94c0092cec7eb28ae7207e6/fastar-0.11.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:49c3299dec5e125e7ebaa27545714da9c7391777366015427e0ae62d548b442b", size = 707156, upload-time = "2026-04-13T17:10:02.176Z" },- { url = "https://files.pythonhosted.org/packages/df/f7/982c01b61f0fc135ad2b16d01e6d0ee53cf8791e68827f5f7c5a65b2e5b1/fastar-0.11.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3328ed1ed56d31f5198350b17dd60449b8d6b9d47abb4688bab6aef4450a165b", size = 627032, upload-time = "2026-04-13T17:09:46.978Z" },- { url = "https://files.pythonhosted.org/packages/2b/c3/38f1dac77ae0c71c37b176277c96d830796b8ce2fe69705f917829b53829/fastar-0.11.0-cp314-cp314t-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:bd3eca3bbfec84a614bcb4143b4ad4f784d0895babc26cfc88436af88ca23c7a", size = 864403, upload-time = "2026-04-13T17:09:16.58Z" },- { url = "https://files.pythonhosted.org/packages/6e/f0/e69c363bdb3e5a5848e937b662b5469581ee6682c51bc1c0556494773929/fastar-0.11.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ff86a967acb0d621dd24063dda090daa67bf4993b9570e97fe156de88a9006ca", size = 759480, upload-time = "2026-04-13T17:08:00.599Z" },- { url = "https://files.pythonhosted.org/packages/3b/29/4d8737590c2a6357d614d7cc7288e8f68e7e449680b8922997cc4349e65e/fastar-0.11.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:86eaf7c0e985d93a7734168be2fb232b2a8cca53e41431c2782d7c12b12c03b1", size = 756219, upload-time = "2026-04-13T17:08:15.699Z" },- { url = "https://files.pythonhosted.org/packages/bb/ec/400de7b3b7d48801908f19cf5462177104395799472671b3e8152b2b04ca/fastar-0.11.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:91f07b0b8eb67e2f177733a1f884edad7dfb9f8977ffef15927b20cb9604027d", size = 923669, upload-time = "2026-04-13T17:08:30.574Z" },- { url = "https://files.pythonhosted.org/packages/5d/01/8926c53da923fed7ab4b96e7fbf7f73b663beb4f02095b654d6fab46f9ad/fastar-0.11.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f85c896885eb4abf1a635d54dea22cac6ae48d04fc2ea26ae652fcf1febe1220", size = 815729, upload-time = "2026-04-13T17:09:01.204Z" },- { url = "https://files.pythonhosted.org/packages/89/f0/5fef4c7946e352651b504b1a4235dac3505e7cfd24020788ab50552e84bf/fastar-0.11.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:075c07095c8de4b774ba8f28b9c0a02b1a2cd254da50cbe464dd3bb2432e9158", size = 819812, upload-time = "2026-04-13T17:09:31.907Z" },- { url = "https://files.pythonhosted.org/packages/b3/c8/0ebc3298b4a45e7bddc50b169ae6a6f5b80c939394d4befe6e60de535ee7/fastar-0.11.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:07f028933820c65750baf3383b807ecce1cd9385cf00ce192b79d263ad6b856c", size = 884074, upload-time = "2026-04-13T17:08:45.802Z" },- { url = "https://files.pythonhosted.org/packages/ae/9f/7baa4cdff8d6fbca41fa5c764b48a941fed8a9ec6c4cc92de65895a28299/fastar-0.11.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:039f875efa0f01fa43c20bf4e2fc7305489c61d0ac76eda991acfba7820a0e63", size = 969450, upload-time = "2026-04-13T17:10:18.667Z" },- { url = "https://files.pythonhosted.org/packages/d4/dc/1ebbfb58a47056ba866494f19efbcdd2ba2897096b94f36e796594b4d05b/fastar-0.11.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:fff12452a9a5c6814a012445f26365541cc3d99dcca61f09762e6a389f7a32ea", size = 1033775, upload-time = "2026-04-13T17:10:36.165Z" },- { url = "https://files.pythonhosted.org/packages/c2/5f/ce4e3914066f08c99eb8c32952cc07c1a013e81b1db1b0f598130bf6b974/fastar-0.11.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:2bf733e09f942b6fa876efe30a90508d1f4caef5630c00fb2a84fba355873712", size = 1072158, upload-time = "2026-04-13T17:10:52.497Z" },- { url = "https://files.pythonhosted.org/packages/03/2a/6bca72992c84151c387cc6558f3867f5ebe5fb3684ee6fa9b76280ba4b8e/fastar-0.11.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d1531fa848fdd3677d2dce0a4b436ea64d9ae38fb8babe2ddbc180dd153cb7a3", size = 1028577, upload-time = "2026-04-13T17:11:09.934Z" },- { url = "https://files.pythonhosted.org/packages/83/18/7a7c15657a3da5569b26fc51cde6a80f8d84cb54b3b1aea6d74a103db4ad/fastar-0.11.0-cp314-cp314t-win32.whl", hash = "sha256:5744551bc67c6fc6581cbd0e34a0fd6e2cd0bd30b43e94b1c3119cf35064b162", size = 453601, upload-time = "2026-04-13T17:11:53.726Z" },- { url = "https://files.pythonhosted.org/packages/6d/d8/331b59a6de279f3ad75c10c02c40a12f21d64a437d9c3d6f1af2dcbd7a76/fastar-0.11.0-cp314-cp314t-win_amd64.whl", hash = "sha256:f4ce44e3b56c47cf38244b98d29f269b259740a580c47a2552efa5b96a5458fb", size = 486436, upload-time = "2026-04-13T17:11:40.089Z" },- { url = "https://files.pythonhosted.org/packages/6b/fd/5390ec4f49100f3ecb9968a392f9e6d039f1e3fe0ecd28443716ff01e589/fastar-0.11.0-cp314-cp314t-win_arm64.whl", hash = "sha256:76c1359314355eafbc6989f20fb1ad565a3d10200117923b9da765a17e2f6f11", size = 461049, upload-time = "2026-04-13T17:11:25.918Z" },-]-[[package]]name = "fastuuid"version = "0.14.0"@@ -1084,114 +850,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/f7/ec/67fbef5d497f86283db54c22eec6f6140243aae73265799baaaa19cd17fb/ghp_import-2.1.0-py3-none-any.whl", hash = "sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619", size = 11034, upload-time = "2022-05-02T15:47:14.552Z" },]-[[package]]-name = "googleapis-common-protos"-version = "1.75.0"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "protobuf" },-]-sdist = { url = "https://files.pythonhosted.org/packages/b5/c8/f439cffde755cffa462bfbb156278fa6f9d09119719af9814b858fd4f81f/googleapis_common_protos-1.75.0.tar.gz", hash = "sha256:53a062ff3c32552fbd62c11fe23768b78e4ddf0494d5e5fd97d3f4689c75fbbd", size = 151035, upload-time = "2026-05-07T08:04:49.423Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/e7/c8/e2645aa8ed02fd4c7a2f59d68783b65b1f3cbdfe39a6308e156509d1fee8/googleapis_common_protos-1.75.0-py3-none-any.whl", hash = "sha256:961ed60399c457ceb0ee8f285a84c870aabc9c6a832b9d37bb281b5bebde43ed", size = 300631, upload-time = "2026-05-07T08:03:30.345Z" },-]--[[package]]-name = "greenlet"-version = "3.5.2"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/dd/8b/befc3cb36965f397d87e86fb3b00e3ec0dc67c1ecb0986d7f54ee528f018/greenlet-3.5.2.tar.gz", hash = "sha256:c1b906220d83c140361cdd12eef970fb5881a168b98ee58a43786426173da14c", size = 199243, upload-time = "2026-06-17T20:19:01.317Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/3f/7a/6bc2a7835731387ed303b9390ce68a116ab053df05450a59181239200454/greenlet-3.5.2-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:76dae33e97b52743a19210931ee3e78a88fe1438bc2fc4ee5e7512d289bfad4f", size = 288351, upload-time = "2026-06-17T17:36:17.019Z" },- { url = "https://files.pythonhosted.org/packages/57/1b/bd98062fcef6d0e9d0873ab6f2d029772e6ea342972ae43275bd6177900f/greenlet-3.5.2-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:30252d191d6959df1d040b559a38fc017139606c5ecc2ad00416557c0355d742", size = 604273, upload-time = "2026-06-17T18:07:20.296Z" },- { url = "https://files.pythonhosted.org/packages/25/e6/fe392c522bf45d976abe7db2793f6ef4e87b053ebb869deeaae46aeb54da/greenlet-3.5.2-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1adc23c50f22b0f5979521909a8360ab4a3d3bef8b641ce633a04cf1b1c967ea", size = 616536, upload-time = "2026-06-17T18:29:43.205Z" },- { url = "https://files.pythonhosted.org/packages/68/4a/399ff81fa93a19d6a9df394cef0355f082dbc19ad41aba9593cd0ad444e2/greenlet-3.5.2-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1f052fff492c52fdfa99bd3b3c1389a53de37dae76a0562741417f0d018f02b3", size = 613749, upload-time = "2026-06-17T17:39:28.148Z" },- { url = "https://files.pythonhosted.org/packages/a5/75/f519593f12ad43d08e28c03a95cfe2eeae011707dbc9dab0c4a263ce90f9/greenlet-3.5.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:120b77c2a18ebf629c3a7886f68c6d01e065654844ad468f15bb93ace66f2094", size = 1573725, upload-time = "2026-06-17T18:22:12.023Z" },- { url = "https://files.pythonhosted.org/packages/f1/bc/bc1ea4b0754c6c51bbf9d94677b0b1f7fbda8cbb404e44a896854fc0a940/greenlet-3.5.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a850f6224088ef7dcc70f1a545cb6b3d119c35d6dca63b925b9f35da0635cdad", size = 1638132, upload-time = "2026-06-17T17:40:06.971Z" },- { url = "https://files.pythonhosted.org/packages/36/c0/f0f5a34247df60de285f75f22e57f14027f4b3c43820981854b5b643ca6d/greenlet-3.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:89da99ee8345b458ea2f16831dad31c88ddcdec454b48704d569a0b8fb28f146", size = 239393, upload-time = "2026-06-17T17:33:47.09Z" },- { url = "https://files.pythonhosted.org/packages/09/17/a8544e165445f30aea67a8d9cf2786d2bb0eb1b0e0d224b4d9bd80e2d587/greenlet-3.5.2-cp312-cp312-win_arm64.whl", hash = "sha256:ca92411942154023c65851e6077d8ca0d00f19de5fa80bb2c6f196ff6c920ba9", size = 237723, upload-time = "2026-06-17T17:36:47.776Z" },- { url = "https://files.pythonhosted.org/packages/d0/3c/bb37b9d40d65b0741a8b040ca5c307034d0a9822994dff5f825c88dd7a6b/greenlet-3.5.2-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:0629377725977252159de1ebd3c6e49c170a63856e585446797bb3d66d4d9c34", size = 287178, upload-time = "2026-06-17T17:35:25.132Z" },- { url = "https://files.pythonhosted.org/packages/f0/a6/0c5902393f492f8ceb19d0b5cf139284e3a11b333a049739643b1036b6f8/greenlet-3.5.2-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a2ddf9eddc617681108dd071b3feabf3f4a4cd64846254aec4d4ceda098b639a", size = 606900, upload-time = "2026-06-17T18:07:21.692Z" },- { url = "https://files.pythonhosted.org/packages/d8/7c/42899c31d4b87148ae4e3f87f63e13398824be6241f4dde42ded95768a34/greenlet-3.5.2-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f41feb9f2b59e2e61ac9bea4e344ddd9396bf3cacb2583f73a3595ed7df6f8e7", size = 619265, upload-time = "2026-06-17T18:29:44.837Z" },- { url = "https://files.pythonhosted.org/packages/d3/52/4ff8c98d3cfe62b4515f8584ae14510a58f35c549cc5292b78d9b7a40b70/greenlet-3.5.2-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:09201fa698768db245920b00fdc86ee3e73540f01ca6db162be9632642e1a473", size = 616187, upload-time = "2026-06-17T17:39:29.473Z" },- { url = "https://files.pythonhosted.org/packages/c9/a6/269c8bf9aefc13361ce1088f0e392b154cb21005de7862e42b5d782b81fd/greenlet-3.5.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a1759fa4f14c398508cf20dc8037de55cc23ae8bd14c185c2718257837195ca5", size = 1573778, upload-time = "2026-06-17T18:22:13.497Z" },- { url = "https://files.pythonhosted.org/packages/1f/9b/391d015cbc6323e81b14c02cf825fdca7e0049c9bb489bf4ac72883118ba/greenlet-3.5.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b9318cdeb9abdbfdd8bc8464ee4a06dffde2c7846e1def138365a6240ab2c9a5", size = 1638092, upload-time = "2026-06-17T17:40:08.163Z" },- { url = "https://files.pythonhosted.org/packages/49/53/5b4df711f4356c62e85d9f819d87966d526d1cfb32bae49a8f7d6fc36ea4/greenlet-3.5.2-cp313-cp313-win_amd64.whl", hash = "sha256:2c3b3311af72b3d3b03cc0f1ffd11f072e834be5d0444105cf715fc44434e39c", size = 239352, upload-time = "2026-06-17T17:38:51.593Z" },- { url = "https://files.pythonhosted.org/packages/bb/b6/18efc3a329ec035c3f344b8f2b60356451950ddf9b7b64ff00023778a1dd/greenlet-3.5.2-cp313-cp313-win_arm64.whl", hash = "sha256:f9bbd6216c45a563c2a61e478e038b439d9f248bde44f775ea37d339da643af4", size = 237635, upload-time = "2026-06-17T17:35:36.632Z" },- { url = "https://files.pythonhosted.org/packages/c7/89/aaafc8e14de4ac882e02ccb963225329b0e8578aba4365e71eb678e45722/greenlet-3.5.2-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:1c31219badba285858ba8ed117f403dea7fafee6bade9a1991875aae530c3ceb", size = 287676, upload-time = "2026-06-17T17:33:31.514Z" },- { url = "https://files.pythonhosted.org/packages/b8/fc/2308249206c12ac70de7b9a00970f84f07d10b3cd60e05d2fbcaa84124e8/greenlet-3.5.2-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6f96ed6f4adc1066954ae95f45717657cb67468ef3b89e9a3632e14a625a8f39", size = 653552, upload-time = "2026-06-17T18:07:23.493Z" },- { url = "https://files.pythonhosted.org/packages/7c/24/47730d1f8f1336b9b089237521ed7a26eee997065dcb4cab81cdca333abc/greenlet-3.5.2-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5795e883e915333c0d5648faaa691857fbc7180136883edc377f50f0d509c2a8", size = 665756, upload-time = "2026-06-17T18:29:46.616Z" },- { url = "https://files.pythonhosted.org/packages/99/69/d6c99db15dc0b5e892ac3cc7b942c8b21f4a9cc3bd9ea0bc3b0f339ffbd4/greenlet-3.5.2-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:26aed8d9503ca78889141a9739d71b383efea5f472a7c522b5410f7eb2a1b163", size = 663228, upload-time = "2026-06-17T17:39:31.073Z" },- { url = "https://files.pythonhosted.org/packages/4f/88/9e603f448e2bc107c883e95817b980fb9b45ba6aea0299b2e9978124bea2/greenlet-3.5.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:dbebc038fcdda8f8f21cce985fd04e34e0f42007e7fc7ab7ad285caf77974b95", size = 1620723, upload-time = "2026-06-17T18:22:14.817Z" },- { url = "https://files.pythonhosted.org/packages/11/91/26da17e3777858c16fdb8d020a4c68f3a03cb92f238de8f5351d5d5186e9/greenlet-3.5.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:a207023f1cf8695fd82580b8099c09c5809be18bc2282362cdfb965dd884a317", size = 1684227, upload-time = "2026-06-17T17:40:09.536Z" },- { url = "https://files.pythonhosted.org/packages/2d/44/b3a11f7aa34cb38f1b7f3df8bcd9fcd09bac9d342c2a2c9b8686c804bcd2/greenlet-3.5.2-cp314-cp314-win_amd64.whl", hash = "sha256:c674a1dd4fe41f6a93febe7ab366ceabf15080ea31a9307811c56dac5f435f73", size = 240257, upload-time = "2026-06-17T17:35:23.359Z" },- { url = "https://files.pythonhosted.org/packages/de/e3/3b62145fe917311732041a258adb218248add00542e3131c48bd047fbed5/greenlet-3.5.2-cp314-cp314-win_arm64.whl", hash = "sha256:3c417cd6c593bbbef6f7aa31a79f37d3db7d18832fc56b694a2150130bde784e", size = 239038, upload-time = "2026-06-17T17:37:56.792Z" },- { url = "https://files.pythonhosted.org/packages/47/ac/d3bad483e9f6cd1848604fdffa32cac25846dd6dfcec0e6f81c790185518/greenlet-3.5.2-cp314-cp314t-macosx_11_0_universal2.whl", hash = "sha256:a96457a30384de52d9c5d2fd33abf6c1daae3db392cd556738f408b1a79a1cf0", size = 295668, upload-time = "2026-06-17T17:36:02.293Z" },- { url = "https://files.pythonhosted.org/packages/00/e9/3a7e557b895fd0469b00cd0b2bd498ba950e8bfdf6d7adeecf2c5e4130a6/greenlet-3.5.2-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4af5d4961818ab651d09c1448a03b1ba2a1726a076266ebb62330bab9f3238c", size = 652820, upload-time = "2026-06-17T18:07:24.95Z" },- { url = "https://files.pythonhosted.org/packages/78/67/6225d5c5e4afc04be0fd161eec82e4b72017e8a100d222f25d7b42b0140d/greenlet-3.5.2-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a1789a6244ea1ba61fd4386c9a6a31873e9b0234762103364be98ef87dcb19f3", size = 658697, upload-time = "2026-06-17T18:29:48.365Z" },- { url = "https://files.pythonhosted.org/packages/fa/99/6324b8ef916dcaddccb340b304c992ca3f947614ce0f2685d438187300b8/greenlet-3.5.2-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3be00501fb4a8c37f6b4b3c4773808ceb26ea65c7ea64fd5735d0f330b3786de", size = 656436, upload-time = "2026-06-17T17:39:32.509Z" },- { url = "https://files.pythonhosted.org/packages/a9/ee/f5bf9daac27c5e1b011965f64b5630a32b415daf7381b312943629e12c2a/greenlet-3.5.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:1d554cd96841a68d464d75a3736f8e87408a7b02b1930a75fa32feb408ad62f8", size = 1617193, upload-time = "2026-06-17T18:22:16.252Z" },- { url = "https://files.pythonhosted.org/packages/8a/21/b05d5b12715bda92ce27c118d64971d21e9b8f3563ed959a7d271e2d4223/greenlet-3.5.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3dff6cd3aac35f6cd3fc23460105acf576f5faf6c378de0bc088bf37c913864a", size = 1677512, upload-time = "2026-06-17T17:40:10.771Z" },- { url = "https://files.pythonhosted.org/packages/b8/97/1b8f1314b868041b327dc1051603e8142b826480cb0ecb8a7b7632aee9c4/greenlet-3.5.2-cp314-cp314t-win_amd64.whl", hash = "sha256:36cfea2aa075d544617176b2e84450480f0797070ad8799a8c41ada2fe449d32", size = 243145, upload-time = "2026-06-17T17:34:37.502Z" },- { url = "https://files.pythonhosted.org/packages/36/07/1b5311775e04c718a118c504d7a3a312430e2a1bd1347226aff4774e4549/greenlet-3.5.2-cp315-cp315-macosx_11_0_universal2.whl", hash = "sha256:a0314aa832c94633355dc6f3ee54f195159533355a323f26926fc63b98b2ccbb", size = 288315, upload-time = "2026-06-17T17:34:34.04Z" },- { url = "https://files.pythonhosted.org/packages/ed/cc/6abcd2a486b58b9f77b7a93b690d59cb2c11a5906ed2ad4c63c7b9c1113d/greenlet-3.5.2-cp315-cp315-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:24c59cb7db9d5c694cb8fd0c76eef8e456b2123afdfa7e4b8f2a67a0860d7682", size = 659130, upload-time = "2026-06-17T18:07:26.354Z" },- { url = "https://files.pythonhosted.org/packages/f2/12/f4aaad6d3d383233f700ab322568a4f29f2c701a4861d85f4811d99689b2/greenlet-3.5.2-cp315-cp315-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7bb811753703739ad318112f16eccfaabdac050037b6d092debaa8b23566b4ce", size = 669724, upload-time = "2026-06-17T18:29:50.13Z" },- { url = "https://files.pythonhosted.org/packages/91/2a/a089811fc31c6bf8742f40a4e73470d6d401cef18e4314eb20dc399b377c/greenlet-3.5.2-cp315-cp315-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6d78b5c1c178dad90447f1b8452262709d3eef4c98f825569e74c9d0b2260ac9", size = 668089, upload-time = "2026-06-17T17:39:33.808Z" },- { url = "https://files.pythonhosted.org/packages/0f/1c/2f47c7d5fcfa98a62b705bf9a0505d86f4563c0d81cab1f7159ff1e743b7/greenlet-3.5.2-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:0977af2df83136f81c1f76e76d4e2fe7d0dc56ea9c101a86af26a95190b9ca32", size = 1625684, upload-time = "2026-06-17T18:22:17.664Z" },- { url = "https://files.pythonhosted.org/packages/b9/bf/661dd24624f70b7b32972d7693d0344ecde10278f647d7b828baf739899c/greenlet-3.5.2-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:f9ed777c6891d8253e54468576f55e27f8fc1a662a664f946a191003574c0a74", size = 1688043, upload-time = "2026-06-17T17:40:12.403Z" },- { url = "https://files.pythonhosted.org/packages/60/49/d9bde1d15a21296b3b521fe083eb8aabd54ac05d15de9832918f3d639543/greenlet-3.5.2-cp315-cp315-win_amd64.whl", hash = "sha256:c0ea4eb3de23f0bac1d75205e10ccfa9b418b17b01a2d7bf19e3b69dda08900a", size = 240531, upload-time = "2026-06-17T17:35:47.448Z" },- { url = "https://files.pythonhosted.org/packages/7f/4d/86d7768bd53e9907de0333df215c2018cd01a593b3715cbd79aa82dd94b7/greenlet-3.5.2-cp315-cp315-win_arm64.whl", hash = "sha256:7a7bfc200be40d04961d7e80e8337d726c0c1a50777e588123c3ed8ba731dcb9", size = 239579, upload-time = "2026-06-17T17:39:39.954Z" },- { url = "https://files.pythonhosted.org/packages/92/15/907be5e8900901039bae752fa9a31c03a3c1e064833f35a4e49449184581/greenlet-3.5.2-cp315-cp315t-macosx_11_0_universal2.whl", hash = "sha256:98a52d6a50d4deaba304331d83ee3e10ebbdc1517fcca40b2715d1de4534065c", size = 296697, upload-time = "2026-06-17T17:37:15.887Z" },- { url = "https://files.pythonhosted.org/packages/95/5c/08c57be575c3d6a3c023bbf22144a1c7dc6ed4d134527bb36ded4dbf04a8/greenlet-3.5.2-cp315-cp315t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1587ff8b58fdf806993ed1490a06ac19c22d47b219c68b30954380029045d8d4", size = 656710, upload-time = "2026-06-17T18:07:28.046Z" },- { url = "https://files.pythonhosted.org/packages/8c/d0/749f917bdc9fc90fceea4aa65fbf6556e617a50714d1496bdc8ad190bb36/greenlet-3.5.2-cp315-cp315t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:feb721811d2754bfd16b48de151dd6b1f222c048e625151f2ca44cfdfd69f59c", size = 662629, upload-time = "2026-06-17T18:29:51.728Z" },- { url = "https://files.pythonhosted.org/packages/5a/a5/68cefae3a07f6d0093a490cf28ab604f14578f3e60205a2a2b2d5cd70af2/greenlet-3.5.2-cp315-cp315t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7fe6062b1f35534e1e8fb28dfed406cf4eeff3e0bca3a0d9f8ff69f20a4abb00", size = 660147, upload-time = "2026-06-17T17:39:35.068Z" },- { url = "https://files.pythonhosted.org/packages/d2/6b/b9156d8397e4750220f54c7c5c34650f1e740a8d2f66eab9cfd1b7b53b69/greenlet-3.5.2-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:b4ac902af825cbac8e9b2fccab8122236fd2ba6c8b71a080116d2c2ec72671b1", size = 1621675, upload-time = "2026-06-17T18:22:18.873Z" },- { url = "https://files.pythonhosted.org/packages/b0/e3/d3250f4fa01c211a93d04e34fded63187e648dbec17b9b1a14d388040593/greenlet-3.5.2-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:6f1e473c06ae8be00c9034c2bb10fa277b08a93287e3111c395b839f01d27e1f", size = 1680577, upload-time = "2026-06-17T17:40:14.055Z" },- { url = "https://files.pythonhosted.org/packages/55/ba/eaee8bda4419770d7096b5a009ebff0ab20a2a28cdd83c4b591bfdf36fa9/greenlet-3.5.2-cp315-cp315t-win_amd64.whl", hash = "sha256:3c2315045f9983e2e50d7e89d95405c21bddb8745f2da4487bc080ab3525f904", size = 243482, upload-time = "2026-06-17T17:37:34.741Z" },- { url = "https://files.pythonhosted.org/packages/37/45/f794a81c91e9942c61f9110bd1f9a38a0ea565eab57f8b08cd53d3131e48/greenlet-3.5.2-cp315-cp315t-win_arm64.whl", hash = "sha256:db548d5ab6c2a8ead82c013f875090d79b5d7d2b67fc513934ce6cf66492ad7f", size = 242062, upload-time = "2026-06-17T17:35:39.814Z" },-]--[[package]]-name = "grpcio"-version = "1.81.1"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "typing-extensions" },-]-sdist = { url = "https://files.pythonhosted.org/packages/b0/b5/1ff353970a87eda4c98251e34d2dfd214abd4982dc89119c9252a2a482d2/grpcio-1.81.1.tar.gz", hash = "sha256:6fa10a767143a5e82e8eaab53918af0cd8909a57a27f8cb2288b80a613ac671b", size = 13026582, upload-time = "2026-06-11T12:46:51.673Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/85/07/9a979c81738863a738dc23d65177056e71fbb2db817740ed870b33434e7a/grpcio-1.81.1-cp312-cp312-linux_armv7l.whl", hash = "sha256:8b39472beafc0bdcafc4c8c73ad082ebfdb449d566897a61e7acb4fa88089115", size = 6053264, upload-time = "2026-06-11T12:45:21.017Z" },- { url = "https://files.pythonhosted.org/packages/75/95/539706ca0d3bd40dbad583dc56fd883da941f37556b629132da5762781b9/grpcio-1.81.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:12b7524c88d4026d3dcb7b0ebe16b6714f3b4af402ddd0f0639ab064a00c87c3", size = 12052560, upload-time = "2026-06-11T12:45:23.652Z" },- { url = "https://files.pythonhosted.org/packages/e0/44/f257b7e0bd69c93b06c6cb8ac8d1b901ccb42bedabd83c1a4c77a71f8810/grpcio-1.81.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1e123f9b37edb8375fd74130d1f69c944bbf0a7b06761ae7211154b8759e94d2", size = 6595983, upload-time = "2026-06-11T12:45:26.963Z" },- { url = "https://files.pythonhosted.org/packages/b9/f3/19782aa04c960968bef8c5539329d8e3bbc3364e2e46d19eb5e5cc5e43b7/grpcio-1.81.1-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:2c2e2ae6867c2966b8daccc836d54a13218e0007e9a490aeb81dd05be64d22d7", size = 7303455, upload-time = "2026-06-11T12:45:29.707Z" },- { url = "https://files.pythonhosted.org/packages/eb/8c/dea020b6d91508cd84463917a63149ec196ee7db505d032ae43fcb3303b9/grpcio-1.81.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:766bc7c9a9c340342f4c864ccbda8e78111e4751f13b895812b9c148fb79e9d0", size = 6809167, upload-time = "2026-06-11T12:45:32.52Z" },- { url = "https://files.pythonhosted.org/packages/1c/c7/3030dd940408083bd32cd95d634777a71605ade4887154d93e8a89244946/grpcio-1.81.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b259a04a737cb3496be0901328eb8b7552ed8df4865d8c8f1cf1bffcfc0776a3", size = 7412536, upload-time = "2026-06-11T12:45:35.403Z" },- { url = "https://files.pythonhosted.org/packages/e0/dd/1172a9e42b168edcafefad6115346ef619a3fc02158bb170e66ced24bcdd/grpcio-1.81.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:85b10a45b8993d195c4f3ff57025b8d1e11834909ee475c403bfa60cb4caefaf", size = 8408276, upload-time = "2026-06-11T12:45:37.78Z" },- { url = "https://files.pythonhosted.org/packages/25/7a/71437c7f3596e5246155c515852795a85a1a8d228190212432b13b97a95d/grpcio-1.81.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8ea1936c26b99999b27479853039a7f34713f56c49375ad52b38535ec93a796c", size = 7849660, upload-time = "2026-06-11T12:45:40.627Z" },- { url = "https://files.pythonhosted.org/packages/65/40/7debc0da45d2efebafb82da75644be347497fe4ee250514b8cd3b86ae8bf/grpcio-1.81.1-cp312-cp312-win32.whl", hash = "sha256:a185a04039df6cae8648bc8ab6d6fde7bf94f7188ecf7828e76ac52eef1e41d6", size = 4185819, upload-time = "2026-06-11T12:45:43.027Z" },- { url = "https://files.pythonhosted.org/packages/2e/b9/8fe3ba5ed462067774ebc1f9c7f26aa7ebcc280ddd476be107153de1339e/grpcio-1.81.1-cp312-cp312-win_amd64.whl", hash = "sha256:3ad74f8bb1a18963914c5452d289422830b39459e8776ebbcd207be1fbfb1d94", size = 4930461, upload-time = "2026-06-11T12:45:45.775Z" },- { url = "https://files.pythonhosted.org/packages/7a/42/dcc2e4b600538ef18327c0839d56b7d3c3812337c5d710df5877dbb39b1e/grpcio-1.81.1-cp313-cp313-linux_armv7l.whl", hash = "sha256:b10e1ff4756ed27d5a29d7fc79cfce7ef1ff56ad20025b89bac7cf79e09abbbe", size = 6054466, upload-time = "2026-06-11T12:45:48.43Z" },- { url = "https://files.pythonhosted.org/packages/7b/4a/a36e03210183a8a7d4c80c3936acee679f4bd77d5861f369db47b2cc5f05/grpcio-1.81.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:819edbdcb42ab8598b494bcf0222684bbb7a3c772bd1b1f0be7e029a6063c28e", size = 12048795, upload-time = "2026-06-11T12:45:54.011Z" },- { url = "https://files.pythonhosted.org/packages/b0/d5/d68e30b29098f63beab6fe501100fe82674ff142b32c672532da86a99b3a/grpcio-1.81.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c5bf2dc311127d91230cc79b92188c082634a06cf66c5234db49a43b910183b0", size = 6599094, upload-time = "2026-06-11T12:45:57.799Z" },- { url = "https://files.pythonhosted.org/packages/3d/b3/e837954d279754f638a11cca5dcf6b24a005efb398984cefaf7735945a54/grpcio-1.81.1-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:e8ca6a1fcdb2943c9cbc1804a1baf3acb6071d72a471591678ded84218006e14", size = 7307182, upload-time = "2026-06-11T12:46:00.568Z" },- { url = "https://files.pythonhosted.org/packages/0d/1e/b47957057e729adc6cdf519a47f8be2562b7140e280f1418443eb4022192/grpcio-1.81.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e64dd101d380a115cc5a0c7856788adb535f1a4e21fc543775602f8be95180ae", size = 6810962, upload-time = "2026-06-11T12:46:03.312Z" },- { url = "https://files.pythonhosted.org/packages/40/26/569868e364e05b19ec8f969da53d230bcd89c962cd198f7c29943155c4d3/grpcio-1.81.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:98a07f9bf591e3a8919797bee1c53f026ba4acd587e5a4404c8e57c9ec36b2a5", size = 7415698, upload-time = "2026-06-11T12:46:06.005Z" },- { url = "https://files.pythonhosted.org/packages/36/0c/5440a0582cb5653fc42a6e262eeb22700943313f8076f9dc927491b20a59/grpcio-1.81.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:c261d74b1a945cf895a9d6eccd1685a8e837531beaab782da4d630a8d12deffb", size = 8407779, upload-time = "2026-06-11T12:46:08.84Z" },- { url = "https://files.pythonhosted.org/packages/ff/aa/66fe9f39871d766987d869a03ee0842a026f499c7b1e62decb9e78a8088e/grpcio-1.81.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:58ad1131c300d3c9b933802b3cc4dc69d380822935ba50b28703156ea826fbf7", size = 7844521, upload-time = "2026-06-11T12:46:12.171Z" },- { url = "https://files.pythonhosted.org/packages/f0/9e/69bb7194861bcd28fb3193261d4f9c3831b4446993f002cf59068943e7ab/grpcio-1.81.1-cp313-cp313-win32.whl", hash = "sha256:78e29211f26da2fdd0e9c6d2b79f489476140cf7029b6a64808ade7ca4156a42", size = 4182786, upload-time = "2026-06-11T12:46:15.192Z" },- { url = "https://files.pythonhosted.org/packages/0d/20/3da8bb0d637feccdc3e1e419bb511ce93651ce7d54164f95de22cc0b8b34/grpcio-1.81.1-cp313-cp313-win_amd64.whl", hash = "sha256:edb59506291b647a30884b1d51a599d605f40b20af4a7dc3d33786a47a31de60", size = 4928648, upload-time = "2026-06-11T12:46:17.823Z" },- { url = "https://files.pythonhosted.org/packages/b6/58/19414622b1bf6981bc9c05a365bd548e71876c89000083b3af489251e9c0/grpcio-1.81.1-cp314-cp314-linux_armv7l.whl", hash = "sha256:506f48f2f9c29b143fca3dad7b0d518c188b6c9648c75a2ae6e2d9f2c13a060b", size = 6055336, upload-time = "2026-06-11T12:46:20.557Z" },- { url = "https://files.pythonhosted.org/packages/32/f1/2ec88adb92b0eba970dd0e0e7dd086341daa3c75eba4f735f9e44bf684b0/grpcio-1.81.1-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:d865db4a6318e1c1bea83292e0ed231090538fc4ca45425b0f0480eb338bbc6e", size = 12056279, upload-time = "2026-06-11T12:46:24.255Z" },- { url = "https://files.pythonhosted.org/packages/41/36/e8c5f8c6ec71de73733695ebc809e98b178b534ec6d8eaa31a7ebab4ad4c/grpcio-1.81.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e2aa72e3ce1770317ef534f63d397b55e130725f5149bd36077c3b539019db27", size = 6608225, upload-time = "2026-06-11T12:46:27.601Z" },- { url = "https://files.pythonhosted.org/packages/30/22/96fc577a845ab093326d9ab1adb874bd4936c8cf98ac8ed2f3db13a0a2fb/grpcio-1.81.1-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:0490c30c261eded63f3f354979f9dc4502a9fb944cccb60cd9dc85f5a7349854", size = 7306576, upload-time = "2026-06-11T12:46:30.514Z" },- { url = "https://files.pythonhosted.org/packages/76/7b/61dab5d5969f28d97fb1009cead1df0a5cd987d3315e1b37f18a4449f8bc/grpcio-1.81.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:410482da976329fe5f4067270401b12cf2bd552ff8020f054ecfaddb5475f9d6", size = 6812165, upload-time = "2026-06-11T12:46:33.699Z" },- { url = "https://files.pythonhosted.org/packages/82/78/6e501929d4f5f96462fd82fd9f0f06e5f9612207582b862868d68757b27d/grpcio-1.81.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e3657301562ac3cb8018d30d0d3ebfa39932239f7b5703422057ef14b69949f5", size = 7422962, upload-time = "2026-06-11T12:46:36.511Z" },- { url = "https://files.pythonhosted.org/packages/2a/7e/f2157589e66daa78ebb3165942d05a08bdea93b9d11c2bc1e172aef89685/grpcio-1.81.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:24c8e57504c8f45b237e40b99262d181071e5099a07053695b75d97bb53053a0", size = 8408176, upload-time = "2026-06-11T12:46:39.803Z" },- { url = "https://files.pythonhosted.org/packages/da/df/c6717fef716e00d235ffb96123baf6dce76d6004f6233fa767c502861460/grpcio-1.81.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b427c19380991a4eaab2f6144b64b99b412043314c6bf4ab544f97bb31ee4190", size = 7846681, upload-time = "2026-06-11T12:46:43.013Z" },- { url = "https://files.pythonhosted.org/packages/36/84/3502e9f210a6a5c4438c8aca3f88edd2e04f6a27f3d41b26cf0a0024b096/grpcio-1.81.1-cp314-cp314-win32.whl", hash = "sha256:61233fe8951e5c85dff81c2458b6528624760166946b5b47ea150a589168411f", size = 4264615, upload-time = "2026-06-11T12:46:45.741Z" },- { url = "https://files.pythonhosted.org/packages/ff/b0/4af731ff7492c68a96e4c71bfd0f4590acde92b31c6fe4894e6465c10ff6/grpcio-1.81.1-cp314-cp314-win_amd64.whl", hash = "sha256:3768a5ff1b2125e6f552e561b6b2dca0e64982d8949689b4df145cf8b98d7821", size = 5070275, upload-time = "2026-06-11T12:46:48.486Z" },-]-[[package]]name = "h11"version = "0.16.0"@@ -1374,18 +1032,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/93/db/4b1cdae9460ae1f3ca020cd767f013430ce23eb1d9c890ae3a0609b38d26/huggingface_hub-1.13.0-py3-none-any.whl", hash = "sha256:e942cb50d6a08dd5306688b1ac05bda157fd2fcc88b63dae405f7bd0d3234005", size = 660643, upload-time = "2026-04-30T11:57:31.802Z" },]-[[package]]-name = "hvac"-version = "2.4.0"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "requests" },-]-sdist = { url = "https://files.pythonhosted.org/packages/e2/57/b46c397fb3842cfb02a44609aa834c887f38dd75f290c2fc5a34da4b2fee/hvac-2.4.0.tar.gz", hash = "sha256:e0056ad9064e7923e874e6769015b032580b639e29246f5ab1044f7959c1c7e0", size = 332543, upload-time = "2025-10-30T12:57:47.512Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/55/33/71e45a6bd6875f44a26f99da31c63b6840123e88bedf2c0b1ce429b8be12/hvac-2.4.0-py3-none-any.whl", hash = "sha256:008db5efd8c2f77bd37d2368ea5f713edceae1c65f11fd608393179478649e0f", size = 155921, upload-time = "2025-10-30T12:57:46.253Z" },-]-[[package]]name = "hyperframe"version = "6.1.0"@@ -1425,15 +1071,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },]-[[package]]-name = "isodate"-version = "0.7.2"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/54/4d/e940025e2ce31a8ce1202635910747e5a87cc3a6a6bb2d00973375014749/isodate-0.7.2.tar.gz", hash = "sha256:4cd1aa0f43ca76f4a6c6c0292a85f40b35ec2e43e315b59f06e6d32171a953e6", size = 29705, upload-time = "2024-10-08T23:04:11.5Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/15/aa/0aca39a37d3c7eb941ba736ede56d689e7be91cab5d9ca846bde3999eba6/isodate-0.7.2-py3-none-any.whl", hash = "sha256:28009937d8031054830160fce6d409ed342816b543597cece116d966c6d99e15", size = 22320, upload-time = "2024-10-08T23:04:09.501Z" },-]-[[package]]name = "jinja2"version = "3.1.6"@@ -1518,15 +1155,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/da/e9/1f9ada30cef7b05e74bb06f52127e7a724976c225f46adb65c37b1dadfb6/jiter-0.14.0-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:67f00d94b281174144d6532a04b66a12cb866cbdc47c3af3bfe2973677f9861a", size = 349613, upload-time = "2026-04-10T14:28:40.066Z" },]-[[package]]-name = "jmespath"-version = "1.1.0"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/d3/59/322338183ecda247fb5d1763a6cbe46eff7222eaeebafd9fa65d4bf5cb11/jmespath-1.1.0.tar.gz", hash = "sha256:472c87d80f36026ae83c6ddd0f1d05d4e510134ed462851fd5f754c8c3cbb88d", size = 27377, upload-time = "2026-01-22T16:35:26.279Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/14/2f/967ba146e6d58cf6a652da73885f52fc68001525b4197effc174321d70b4/jmespath-1.1.0-py3-none-any.whl", hash = "sha256:a5663118de4908c91729bea0acadca56526eb2698e83de10cd116ae0f4e97c64", size = 20419, upload-time = "2026-01-22T16:35:24.919Z" },-]-[[package]]name = "jsonschema"version = "4.26.0"@@ -1554,36 +1182,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" },]-[[package]]-name = "kubernetes"-version = "36.0.2"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "aiohttp" },- { name = "certifi" },- { name = "durationpy" },- { name = "python-dateutil" },- { name = "pyyaml" },- { name = "requests" },- { name = "requests-oauthlib" },- { name = "six" },- { name = "urllib3" },- { name = "websocket-client" },-]-sdist = { url = "https://files.pythonhosted.org/packages/2f/57/8b538af5076bc3372949d76f70ba3449bdfe52f9e6488170fa5d4f7cbe70/kubernetes-36.0.2.tar.gz", hash = "sha256:03551fcb49cae1f708f63624041e37403545b7aaed10cbf54e2b01a37a5438e3", size = 2336738, upload-time = "2026-06-01T18:20:30.785Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/46/2c/5c160dbdef7123f8cc97fd8ece7e0198627a426a2a49614845e9086feb8d/kubernetes-36.0.2-py2.py3-none-any.whl", hash = "sha256:faf9b5241b58de0c4a5069f2a0ffc8ac06fece7215156cd3d3ba081a78a858b6", size = 4617568, upload-time = "2026-06-01T18:20:28.737Z" },-]--[[package]]-name = "lark"-version = "1.3.1"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/da/34/28fff3ab31ccff1fd4f6c7c7b0ceb2b6968d8ea4950663eadcb5720591a0/lark-1.3.1.tar.gz", hash = "sha256:b426a7a6d6d53189d318f2b6236ab5d6429eaf09259f1ca33eb716eed10d2905", size = 382732, upload-time = "2025-10-27T18:25:56.653Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/82/3d/14ce75ef66813643812f3093ab17e46d3a206942ce7376d31ec2d36229e7/lark-1.3.1-py3-none-any.whl", hash = "sha256:c629b661023a014c37da873b4ff58a817398d12635d3bbb2c5a03be7fe5d1e12", size = 113151, upload-time = "2025-10-27T18:25:54.882Z" },-]-[[package]]name = "librt"version = "0.10.0"@@ -2134,56 +1732,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" },]-[[package]]-name = "nemo-platform"-version = "0.1.2"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "aiofiles" },- { name = "anthropic" },- { name = "anyio" },- { name = "base58" },- { name = "distro" },- { name = "docker" },- { name = "fastapi", extra = ["standard"] },- { name = "fsspec" },- { name = "httpx" },- { name = "huggingface-hub" },- { name = "hvac" },- { name = "kubernetes" },- { name = "lark" },- { name = "ngcsdk" },- { name = "nvidia-ml-py" },- { name = "openai" },- { name = "opentelemetry-exporter-otlp-proto-grpc" },- { name = "opentelemetry-exporter-otlp-proto-http" },- { name = "opentelemetry-exporter-prometheus" },- { name = "opentelemetry-instrumentation-fastapi" },- { name = "opentelemetry-instrumentation-httpx" },- { name = "opentelemetry-instrumentation-sqlalchemy" },- { name = "opentelemetry-instrumentation-system-metrics" },- { name = "opentelemetry-processor-baggage" },- { name = "opentelemetry-sdk" },- { name = "prometheus-client" },- { name = "prometheus-fastapi-instrumentator" },- { name = "prompt-toolkit" },- { name = "psutil" },- { name = "pydantic" },- { name = "pydantic-settings" },- { name = "pyjwt", extra = ["crypto"] },- { name = "pyyaml" },- { name = "requests" },- { name = "rich" },- { name = "sniffio" },- { name = "sqlalchemy" },- { name = "structlog" },- { name = "typer" },- { name = "typing-extensions" },-]-wheels = [- { url = "https://files.pythonhosted.org/packages/01/c8/52bbb016710d315e8298d98e9eca945c1d4ce629ac336f2a1451463e2139/nemo_platform-0.1.2-py3-none-any.whl", hash = "sha256:cc7d2462422a1b583355e0479c4de3a00df82722519f192a2b36f5ba425bf1c5", size = 7163845, upload-time = "2026-06-04T22:21:03.88Z" },-]-[[package]]name = "nemo-switchyard"version = "0.2.0"@@ -2202,7 +1750,6 @@ affinity-redis = [all = [{ name = "ddtrace" },{ name = "fastapi" },- { name = "nemo-platform" },{ name = "prompt-toolkit" },{ name = "redis" },{ name = "sse-starlette" },@@ -2211,9 +1758,6 @@ all = [cli = [{ name = "prompt-toolkit" },]-intake = [- { name = "nemo-platform" },-]server = [{ name = "fastapi" },{ name = "sse-starlette" },@@ -2253,8 +1797,7 @@ requires-dist = [{ name = "ddtrace", marker = "extra == 'tracing'", specifier = ">=2.9,<4" },{ name = "fastapi", marker = "extra == 'server'", specifier = ">=0.136.1,<1.0" },{ name = "httpx", specifier = ">=0.28.1,<1.0" },- { name = "nemo-platform", marker = "extra == 'intake'", specifier = ">=0.1.0,<1.0" },- { name = "nemo-switchyard", extras = ["server", "cli", "tracing", "intake", "affinity-redis"], marker = "extra == 'all'" },+ { name = "nemo-switchyard", extras = ["server", "cli", "tracing", "affinity-redis"], marker = "extra == 'all'" },{ name = "openai", specifier = ">=2.7,<3.0" },{ name = "prompt-toolkit", marker = "extra == 'cli'", specifier = ">=3.0.52,<4.0" },{ name = "pydantic", specifier = ">=2.13.3,<3.0" },@@ -2262,7 +1805,7 @@ requires-dist = [{ name = "sse-starlette", marker = "extra == 'server'", specifier = ">=3.4.1,<4.0" },{ name = "uvicorn", extras = ["standard"], marker = "extra == 'server'", specifier = ">=0.46.0,<1.0" },]-provides-extras = ["server", "cli", "tracing", "intake", "affinity-redis", "all"]+provides-extras = ["server", "cli", "tracing", "affinity-redis", "all"][package.metadata.requires-dev]dev = [@@ -2288,35 +1831,6 @@ docs = [{ name = "watchdog", specifier = ">=4.0.0,<5.0" },]-[[package]]-name = "ngcsdk"-version = "4.20.1"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "aiofiles" },- { name = "aiohttp" },- { name = "boto3" },- { name = "botocore" },- { name = "certifi" },- { name = "cryptography" },- { name = "docker" },- { name = "isodate" },- { name = "packaging" },- { name = "polling2" },- { name = "prettytable" },- { name = "psutil" },- { name = "python-dateutil" },- { name = "requests" },- { name = "requests-toolbelt" },- { name = "rich" },- { name = "shortuuid" },- { name = "urllib3" },- { name = "validators" },-]-wheels = [- { url = "https://files.pythonhosted.org/packages/af/53/501ca12b467a988c5544215ec300b68e6e7e473832d287ad001913a6d85a/ngcsdk-4.20.1-py3-none-any.whl", hash = "sha256:92a7e8626c0619f1af0085fa88d94c03be14d97762cbae1f7169bd54f43c003c", size = 2404583, upload-time = "2026-06-25T19:23:26.264Z" },-]-[[package]]name = "numpy"version = "2.4.4"@@ -2378,24 +1892,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/58/78/548fb8e07b1a341746bfbecb32f2c268470f45fa028aacdbd10d9bc73aab/numpy-2.4.4-cp314-cp314t-win_arm64.whl", hash = "sha256:ba203255017337d39f89bdd58417f03c4426f12beed0440cfd933cb15f8669c7", size = 10566643, upload-time = "2026-03-29T13:21:34.339Z" },]-[[package]]-name = "nvidia-ml-py"-version = "13.610.43"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/f0/b5/a8fbc356f768fa5c9cfd646668fd7d34bf55bdd1c6e20754642a64d930d4/nvidia_ml_py-13.610.43.tar.gz", hash = "sha256:65437eb73d68d0c62c931ca4d45038472faff03bd0b8729abba4b899f70d60f2", size = 52109, upload-time = "2026-06-01T18:54:08.829Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/23/45/caa600acfab94560807a20a64b5830d2cd3c3202b7f1328644d70b7d6bd8/nvidia_ml_py-13.610.43-py3-none-any.whl", hash = "sha256:f13c72698edef492f985cc225f14faafe68ae065a2e407f45bdf6f4b9b43fde8", size = 53163, upload-time = "2026-06-01T18:54:07.704Z" },-]--[[package]]-name = "oauthlib"-version = "3.3.1"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/0b/5f/19930f824ffeb0ad4372da4812c50edbd1434f678c90c2733e1188edfc63/oauthlib-3.3.1.tar.gz", hash = "sha256:0f0f8aa759826a193cf66c12ea1af1637f87b9b4622d46e866952bb022e538c9", size = 185918, upload-time = "2025-06-19T22:48:08.269Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/be/9c/92789c596b8df838baa98fa71844d84283302f7604ed565dafe5a6b5041a/oauthlib-3.3.1-py3-none-any.whl", hash = "sha256:88119c938d2b8fb88561af5f6ee0eec8cc8d552b7bb1f712743136eb7523b7a1", size = 160065, upload-time = "2025-06-19T22:48:06.508Z" },-]-[[package]]name = "openai"version = "2.34.0"@@ -2427,224 +1923,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/a3/ca/9520cc1f3dfbbd03ac5903bbf55833e257bc64b1cf30fa8b0d6df374d821/opentelemetry_api-1.42.1-py3-none-any.whl", hash = "sha256:51a69edacadbc03a8950ace1c4c21099cacc538820ac2c9e36277e78cebba714", size = 61311, upload-time = "2026-05-21T16:32:28.822Z" },]-[[package]]-name = "opentelemetry-exporter-otlp-proto-common"-version = "1.42.1"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "opentelemetry-proto" },-]-sdist = { url = "https://files.pythonhosted.org/packages/0e/9c/216acfeaedadf2e1937f4373929b20f73197c5c4a2546d4f584b7fa63813/opentelemetry_exporter_otlp_proto_common-1.42.1.tar.gz", hash = "sha256:04f1f01fb597c4249dfcd7f8b861c902c2102369d376d9d346ff38de4469a2ee", size = 21433, upload-time = "2026-05-21T16:32:55.526Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/d6/43/2375e7612e1121a4518c17603b6e0b03ad94f565aafad53f464dc5be2bf6/opentelemetry_exporter_otlp_proto_common-1.42.1-py3-none-any.whl", hash = "sha256:f48d395ab815b444da118868977e9798ea354c25737d5cf39578ae894011c140", size = 17327, upload-time = "2026-05-21T16:32:33.387Z" },-]--[[package]]-name = "opentelemetry-exporter-otlp-proto-grpc"-version = "1.42.1"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "googleapis-common-protos" },- { name = "grpcio" },- { name = "opentelemetry-api" },- { name = "opentelemetry-exporter-otlp-proto-common" },- { name = "opentelemetry-proto" },- { name = "opentelemetry-sdk" },- { name = "typing-extensions" },-]-sdist = { url = "https://files.pythonhosted.org/packages/87/87/ca7fc790dfdbcf4f9e9aab14a39ef1b7508ead13707e283de0b3131478d2/opentelemetry_exporter_otlp_proto_grpc-1.42.1.tar.gz", hash = "sha256:975c4461f167dd8ed8857d68d3b6b25f3d272eab896f6a9470d0f5b90e2faf15", size = 27140, upload-time = "2026-05-21T16:32:56.162Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/89/2b/28ba5b128f47fe8c3bab541000d6feb4b5a9bd26623ca013406f01c0fb60/opentelemetry_exporter_otlp_proto_grpc-1.42.1-py3-none-any.whl", hash = "sha256:0ae1177e2038b18a929b3098215243631ef91136cba26b7e2b12790ceb7e87cc", size = 19617, upload-time = "2026-05-21T16:32:34.278Z" },-]--[[package]]-name = "opentelemetry-exporter-otlp-proto-http"-version = "1.42.1"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "googleapis-common-protos" },- { name = "opentelemetry-api" },- { name = "opentelemetry-exporter-otlp-proto-common" },- { name = "opentelemetry-proto" },- { name = "opentelemetry-sdk" },- { name = "requests" },- { name = "typing-extensions" },-]-sdist = { url = "https://files.pythonhosted.org/packages/77/32/826bfa1d80ecea24f47808de03cd4a0d13c17ecc07712f45123f0f61e4ac/opentelemetry_exporter_otlp_proto_http-1.42.1.tar.gz", hash = "sha256:bf142a21035d7571ac3a09cb2e5639f49886f243972883cfe777ed3bf02b734d", size = 25406, upload-time = "2026-05-21T16:32:56.807Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/d3/96/82cb223a1502f0787d4bbff12907f5f8d870a50731febcd5818d93ef9555/opentelemetry_exporter_otlp_proto_http-1.42.1-py3-none-any.whl", hash = "sha256:00a16da1b312a1d6c7233d600d557c91df71125af73020f3b9a7765bd699d59d", size = 21793, upload-time = "2026-05-21T16:32:35.277Z" },-]--[[package]]-name = "opentelemetry-exporter-prometheus"-version = "0.63b1"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "opentelemetry-api" },- { name = "opentelemetry-sdk" },- { name = "prometheus-client" },-]-sdist = { url = "https://files.pythonhosted.org/packages/ac/2a/dfeddff262b12eff0c72f4ad9e258aab8889f48c4dc1417a0377a13bc427/opentelemetry_exporter_prometheus-0.63b1.tar.gz", hash = "sha256:31902e22c89431058a95b6dcdb644f9309f226aa4872cc755f0a780d2895e97f", size = 15234, upload-time = "2026-05-21T16:32:57.797Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/2f/ec/d7c7435e9000fb69837cf7753b7cbbbdeb5d0585203daf1b6ebf8fa93e02/opentelemetry_exporter_prometheus-0.63b1-py3-none-any.whl", hash = "sha256:0efd00aa6b1939345ddcc6de141b83ebffa2b4401a37a68f880e54217602701d", size = 12466, upload-time = "2026-05-21T16:32:36.622Z" },-]--[[package]]-name = "opentelemetry-instrumentation"-version = "0.63b1"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "opentelemetry-api" },- { name = "opentelemetry-semantic-conventions" },- { name = "packaging" },- { name = "wrapt" },-]-sdist = { url = "https://files.pythonhosted.org/packages/da/6d/4de72d97ff54db1ed270c7a59c9b904b917c0ac7af429c086c388b824ddb/opentelemetry_instrumentation-0.63b1.tar.gz", hash = "sha256:32368d6ae52c8de20aa790a6ad86b10a76f09956092337ae37d675773990e541", size = 41081, upload-time = "2026-05-21T16:36:14.206Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/35/a1/9314e621c143e4d82a5bf7a43c2ff7a745d31023506336857607c8c543cc/opentelemetry_instrumentation-0.63b1-py3-none-any.whl", hash = "sha256:f1986716d52cc316ea5f60189098726a9071d8ecc0eee96c9ed110be08bade9c", size = 35577, upload-time = "2026-05-21T16:34:56.818Z" },-]--[[package]]-name = "opentelemetry-instrumentation-asgi"-version = "0.63b1"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "asgiref" },- { name = "opentelemetry-api" },- { name = "opentelemetry-instrumentation" },- { name = "opentelemetry-semantic-conventions" },- { name = "opentelemetry-util-http" },-]-sdist = { url = "https://files.pythonhosted.org/packages/a0/b5/7ea3a9fd1b80e89786c14250bfaecf32a753c3fd08232690f4da8dc16e29/opentelemetry_instrumentation_asgi-0.63b1.tar.gz", hash = "sha256:267b422416d768f3c7f4054883b41d9c3a7c943d86d20032b738c99a3dbb5862", size = 26151, upload-time = "2026-05-21T16:36:18.368Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/57/7e/83986f27b421de04fab1e1a84e892621dac42e6432a9c66779505f4d1381/opentelemetry_instrumentation_asgi-0.63b1-py3-none-any.whl", hash = "sha256:1a22453dfa965f14799b10a674b8acbcb897a8a75c79136060af54214cc7886e", size = 15906, upload-time = "2026-05-21T16:35:04.162Z" },-]--[[package]]-name = "opentelemetry-instrumentation-fastapi"-version = "0.63b1"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "opentelemetry-api" },- { name = "opentelemetry-instrumentation" },- { name = "opentelemetry-instrumentation-asgi" },- { name = "opentelemetry-semantic-conventions" },- { name = "opentelemetry-util-http" },-]-sdist = { url = "https://files.pythonhosted.org/packages/32/d6/0c128fac2e34b7d526a8d3c6edc45b875a97f8a987861b00511151b6337d/opentelemetry_instrumentation_fastapi-0.63b1.tar.gz", hash = "sha256:cc42dff56c96d0a2921510c4abab2a4c2e27fe64b26dc1254727fb550df100ba", size = 25387, upload-time = "2026-05-21T16:36:32.071Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/b1/3d/2eae63f13f36d7a8ab5bf03d06ecaf169c2069b524547f24947be6d92094/opentelemetry_instrumentation_fastapi-0.63b1-py3-none-any.whl", hash = "sha256:52ee2cde9a2ac094bdd45d79f85860e03a972928a2553006071fe61d94cf7281", size = 12795, upload-time = "2026-05-21T16:35:28.68Z" },-]--[[package]]-name = "opentelemetry-instrumentation-httpx"-version = "0.63b1"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "opentelemetry-api" },- { name = "opentelemetry-instrumentation" },- { name = "opentelemetry-semantic-conventions" },- { name = "opentelemetry-util-http" },- { name = "wrapt" },-]-sdist = { url = "https://files.pythonhosted.org/packages/02/27/c2b4335bca030e893acbe5ff2b4f434868773bf94508be7e6bf5af981b24/opentelemetry_instrumentation_httpx-0.63b1.tar.gz", hash = "sha256:f41ec82f25c3abcdada621052db3e5fd648e3b43d55eec4b9c0c5d3ecb7b4ff4", size = 23557, upload-time = "2026-05-21T16:36:34.583Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/ba/b8/f536780996195c3b9f2354998554671e05a7a262df8c043f63fe9e5a6f0b/opentelemetry_instrumentation_httpx-0.63b1-py3-none-any.whl", hash = "sha256:14df6e99d81be9a8cd238f6639b6fa52404c4d3ce219058fcb5dc8c0f2211f86", size = 16336, upload-time = "2026-05-21T16:35:32.221Z" },-]--[[package]]-name = "opentelemetry-instrumentation-sqlalchemy"-version = "0.63b1"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "opentelemetry-api" },- { name = "opentelemetry-instrumentation" },- { name = "opentelemetry-semantic-conventions" },- { name = "packaging" },- { name = "wrapt" },-]-sdist = { url = "https://files.pythonhosted.org/packages/cb/97/e5cb3ad027aebf7128faadeefe4d4cb0fc07ed32ef95e8fc9d828a077a85/opentelemetry_instrumentation_sqlalchemy-0.63b1.tar.gz", hash = "sha256:621f9eb800ea24a98b4eda968373e3909bfede0ff47f77b96f8b8a18bc2a2a1a", size = 18006, upload-time = "2026-05-21T16:36:46.855Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/3c/bc/c0984c4c51da64cc2c37ce031b4fb7fab61d223f2188a6bc6b5f18035ae3/opentelemetry_instrumentation_sqlalchemy-0.63b1-py3-none-any.whl", hash = "sha256:d417414f6517963e9c1ee91ec971b94938b46904499114d035a43937bd62b6a1", size = 14410, upload-time = "2026-05-21T16:35:53.342Z" },-]--[[package]]-name = "opentelemetry-instrumentation-system-metrics"-version = "0.63b1"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "opentelemetry-api" },- { name = "opentelemetry-instrumentation" },- { name = "opentelemetry-semantic-conventions" },- { name = "psutil" },-]-sdist = { url = "https://files.pythonhosted.org/packages/2b/a4/c91a0e085808724ad4cb3bdd76bf9dac872c8a8910b24767cf95ffde67a5/opentelemetry_instrumentation_system_metrics-0.63b1.tar.gz", hash = "sha256:d6d4d7a1a854be4165143cf6420ee5894188762eb367d7bf9da5be4a83a4b632", size = 17412, upload-time = "2026-05-21T16:36:49.276Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/29/37/b8bddfab16c0a36af1941ec041b5bc8fe3c3d802997b4e819037908a90d5/opentelemetry_instrumentation_system_metrics-0.63b1-py3-none-any.whl", hash = "sha256:995051f47876d79461aed8b7aa205d4584d90794ef864342cc748929c389bb42", size = 14006, upload-time = "2026-05-21T16:35:56.979Z" },-]--[[package]]-name = "opentelemetry-processor-baggage"-version = "0.64b0"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "opentelemetry-api" },- { name = "opentelemetry-sdk" },- { name = "wrapt" },-]-sdist = { url = "https://files.pythonhosted.org/packages/34/db/fba2d128643a78461ba72e03e094660fe7ed3f69fa22859afcf62cfb50d4/opentelemetry_processor_baggage-0.64b0.tar.gz", hash = "sha256:6a84cf37c25d223dcaec142abfc02c73b1bb78b388f394397f9578b5fbd7a32a", size = 8834, upload-time = "2026-06-24T15:19:47.175Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/24/e9/e58dd215c3f1e9680c3fce2a7b550fc2602dea76855d520e29ffe94b8a38/opentelemetry_processor_baggage-0.64b0-py3-none-any.whl", hash = "sha256:bbe5cd75060ea158810f4a17040659032304a83877b90a94878919778f53c039", size = 9487, upload-time = "2026-06-24T15:19:06.384Z" },-]--[[package]]-name = "opentelemetry-proto"-version = "1.42.1"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "protobuf" },-]-sdist = { url = "https://files.pythonhosted.org/packages/b4/55/63eac3e1089b768ba014091fdd2ae8a9a440c821ef5e2b786909c94c8836/opentelemetry_proto-1.42.1.tar.gz", hash = "sha256:c6a51e6b4f05ae63565f3a113217f3d2bfaec68f78c02d7a6c85f9010d1cfca6", size = 45839, upload-time = "2026-05-21T16:33:03.937Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/41/9d/171c02c84a76940b7e601805b3bb536985aded9168fbcc9ba52f0a730fa2/opentelemetry_proto-1.42.1-py3-none-any.whl", hash = "sha256:dedb74cba2886c59c7789b227a7a670613025a07489040050aedff6e5c0fb43c", size = 71782, upload-time = "2026-05-21T16:32:44.867Z" },-]--[[package]]-name = "opentelemetry-sdk"-version = "1.42.1"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "opentelemetry-api" },- { name = "opentelemetry-semantic-conventions" },- { name = "typing-extensions" },-]-sdist = { url = "https://files.pythonhosted.org/packages/40/f7/b390bd9bfd703bf98a68fea1f27786c6872331fd617164a54b8a59bdc008/opentelemetry_sdk-1.42.1.tar.gz", hash = "sha256:8c834e8f8c9ba4171d4ec843d0cb8a67e4c7394d3f9e9297e582cbd9456ddbf7", size = 239262, upload-time = "2026-05-21T16:33:04.641Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/8f/6b/4287766cfbde577ae2272e8884abac325aeaac0d64f41c61d5b8cc595105/opentelemetry_sdk-1.42.1-py3-none-any.whl", hash = "sha256:083cd4bbfaa5aa7b5a9e552430d9951219967cfb27aa61feb13a77aba1fc839d", size = 170907, upload-time = "2026-05-21T16:32:45.894Z" },-]--[[package]]-name = "opentelemetry-semantic-conventions"-version = "0.63b1"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "opentelemetry-api" },- { name = "typing-extensions" },-]-sdist = { url = "https://files.pythonhosted.org/packages/93/99/4d7dd6df64795951413ce6e815f8cf1eb191daf7196ae86574589643d5f3/opentelemetry_semantic_conventions-0.63b1.tar.gz", hash = "sha256:3daf963611334b365e98a57438183eb012d3bfb40b2d931a9af613476b8701a9", size = 148340, upload-time = "2026-05-21T16:33:05.455Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/cb/7a/7fe66f5f3682b1dd47d88cc4e11f1c6c0966b737de2d16671146e23c39a5/opentelemetry_semantic_conventions-0.63b1-py3-none-any.whl", hash = "sha256:dfe5ef4dee82586b746f522b818ceb298d00b3d59f660042bd79404bff8d0682", size = 203713, upload-time = "2026-05-21T16:32:47.016Z" },-]--[[package]]-name = "opentelemetry-util-http"-version = "0.63b1"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/6c/d8/7bf5e4cec0578ac3c28c18eb7b88f34279139cbc8c568d6aa02b9c5ae53e/opentelemetry_util_http-0.63b1.tar.gz", hash = "sha256:ba1268f00922ee522dba2ae38458060f99486e7385a8056985901ca9685adfff", size = 11102, upload-time = "2026-05-21T16:36:56.675Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/e5/f1/34e047e8f6a3c67e5220acf1af7b9f62868c25d77791bca74457bd2180a6/opentelemetry_util_http-0.63b1-py3-none-any.whl", hash = "sha256:6284194028c59cd439f8acfe388145069a6127f11dc077e1344a2094adacc3f8", size = 8205, upload-time = "2026-05-21T16:36:09.736Z" },-]-[[package]]name = "packaging"version = "26.2"@@ -2742,15 +2020,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },]-[[package]]-name = "polling2"-version = "0.5.0"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/04/9d/6a560ab95e1b92dfce97321d8ffc9f20d352fa4b12a91525d4c575df1c74/polling2-0.5.0.tar.gz", hash = "sha256:90b7da82cf7adbb48029724d3546af93f21ab6e592ec37c8c4619aedd010e342", size = 6549, upload-time = "2021-07-19T18:06:54.951Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/a3/de/e5bf2556ebd6db12590788207575c7c75b1de62f5ddc8b4916b668e04e6b/polling2-0.5.0-py2.py3-none-any.whl", hash = "sha256:ad86d56fbd7502f0856cac2d0109d595c18fa6c7fb12c88cee5e5d16c17286c1", size = 6431, upload-time = "2021-07-19T18:06:53.681Z" },-]-[[package]]name = "postgrest"version = "2.30.0"@@ -2766,18 +2035,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/22/aa/ff2e09f99f95ea96fddeb373646bf907dd89a24fc00b5d38e5674ca7c9ca/postgrest-2.30.0-py3-none-any.whl", hash = "sha256:30631e7993da542419f4217cf3b60aa641084731ea15e66a18526a3a52e40a7d", size = 23108, upload-time = "2026-05-06T17:35:20.531Z" },]-[[package]]-name = "prettytable"-version = "3.18.0"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "wcwidth" },-]-sdist = { url = "https://files.pythonhosted.org/packages/81/74/ba08d81e668ccfe8658d7520a307e63c19862c08eb4ccb26f356c5239a7a/prettytable-3.18.0.tar.gz", hash = "sha256:439217116152244369caf3d9f1caf2f9fe29b03bd79e88d2928c8e718c95d680", size = 76373, upload-time = "2026-06-22T16:07:50.174Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/fe/be/2e6798ace5cc036f5d05d36b7b2fd85346f1a708c87060890b070d0ec607/prettytable-3.18.0-py3-none-any.whl", hash = "sha256:b3346e0e6f79180833aebaac088ae926340586cf6d7d991b9eb125b65f72313a", size = 37357, upload-time = "2026-06-22T16:07:48.595Z" },-]-[[package]]name = "prometheus-client"version = "0.25.0"@@ -2787,19 +2044,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/8d/9b/d4b1e644385499c8346fa9b622a3f030dce14cd6ef8a1871c221a17a67e7/prometheus_client-0.25.0-py3-none-any.whl", hash = "sha256:d5aec89e349a6ec230805d0df882f3807f74fd6c1a2fa86864e3c2279059fed1", size = 64154, upload-time = "2026-04-09T19:53:41.324Z" },]-[[package]]-name = "prometheus-fastapi-instrumentator"-version = "8.0.2"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "prometheus-client" },- { name = "starlette" },-]-sdist = { url = "https://files.pythonhosted.org/packages/1b/e9/2065686d1dfa62296fdc158b6e8fd25b0cb3dca09b0632cabeb5ae81fe4d/prometheus_fastapi_instrumentator-8.0.2.tar.gz", hash = "sha256:3c252e748151768a7aefd66824a04a870144f71de48a67aed211749a9ca2a548", size = 21342, upload-time = "2026-06-23T09:39:31.611Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/c6/c7/fa2b3f469a2e6001b829e0d6bc8680755349aa1329a87bf48731e9d5d30a/prometheus_fastapi_instrumentator-8.0.2-py3-none-any.whl", hash = "sha256:746002ec1e2c58b93f61444e1d104de959a9463a6a3f1c8909ac3757e16c3866", size = 20549, upload-time = "2026-06-23T09:39:32.616Z" },-]-[[package]]name = "prompt-toolkit"version = "3.0.52"@@ -2896,49 +2140,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", hash = "sha256:af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237", size = 13305, upload-time = "2025-10-08T19:49:00.792Z" },]-[[package]]-name = "protobuf"-version = "6.33.6"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/66/70/e908e9c5e52ef7c3a6c7902c9dfbb34c7e29c25d2f81ade3856445fd5c94/protobuf-6.33.6.tar.gz", hash = "sha256:a6768d25248312c297558af96a9f9c929e8c4cee0659cb07e780731095f38135", size = 444531, upload-time = "2026-03-18T19:05:00.988Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/fc/9f/2f509339e89cfa6f6a4c4ff50438db9ca488dec341f7e454adad60150b00/protobuf-6.33.6-cp310-abi3-win32.whl", hash = "sha256:7d29d9b65f8afef196f8334e80d6bc1d5d4adedb449971fefd3723824e6e77d3", size = 425739, upload-time = "2026-03-18T19:04:48.373Z" },- { url = "https://files.pythonhosted.org/packages/76/5d/683efcd4798e0030c1bab27374fd13a89f7c2515fb1f3123efdfaa5eab57/protobuf-6.33.6-cp310-abi3-win_amd64.whl", hash = "sha256:0cd27b587afca21b7cfa59a74dcbd48a50f0a6400cfb59391340ad729d91d326", size = 437089, upload-time = "2026-03-18T19:04:50.381Z" },- { url = "https://files.pythonhosted.org/packages/5c/01/a3c3ed5cd186f39e7880f8303cc51385a198a81469d53d0fdecf1f64d929/protobuf-6.33.6-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:9720e6961b251bde64edfdab7d500725a2af5280f3f4c87e57c0208376aa8c3a", size = 427737, upload-time = "2026-03-18T19:04:51.866Z" },- { url = "https://files.pythonhosted.org/packages/ee/90/b3c01fdec7d2f627b3a6884243ba328c1217ed2d978def5c12dc50d328a3/protobuf-6.33.6-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:e2afbae9b8e1825e3529f88d514754e094278bb95eadc0e199751cdd9a2e82a2", size = 324610, upload-time = "2026-03-18T19:04:53.096Z" },- { url = "https://files.pythonhosted.org/packages/9b/ca/25afc144934014700c52e05103c2421997482d561f3101ff352e1292fb81/protobuf-6.33.6-cp39-abi3-manylinux2014_s390x.whl", hash = "sha256:c96c37eec15086b79762ed265d59ab204dabc53056e3443e702d2681f4b39ce3", size = 339381, upload-time = "2026-03-18T19:04:54.616Z" },- { url = "https://files.pythonhosted.org/packages/16/92/d1e32e3e0d894fe00b15ce28ad4944ab692713f2e7f0a99787405e43533a/protobuf-6.33.6-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:e9db7e292e0ab79dd108d7f1a94fe31601ce1ee3f7b79e0692043423020b0593", size = 323436, upload-time = "2026-03-18T19:04:55.768Z" },- { url = "https://files.pythonhosted.org/packages/c4/72/02445137af02769918a93807b2b7890047c32bfb9f90371cbc12688819eb/protobuf-6.33.6-py3-none-any.whl", hash = "sha256:77179e006c476e69bf8e8ce866640091ec42e1beb80b213c3900006ecfba6901", size = 170656, upload-time = "2026-03-18T19:04:59.826Z" },-]--[[package]]-name = "psutil"-version = "7.2.2"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", hash = "sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372", size = 493740, upload-time = "2026-01-28T18:14:54.428Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/51/08/510cbdb69c25a96f4ae523f733cdc963ae654904e8db864c07585ef99875/psutil-7.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2edccc433cbfa046b980b0df0171cd25bcaeb3a68fe9022db0979e7aa74a826b", size = 130595, upload-time = "2026-01-28T18:14:57.293Z" },- { url = "https://files.pythonhosted.org/packages/d6/f5/97baea3fe7a5a9af7436301f85490905379b1c6f2dd51fe3ecf24b4c5fbf/psutil-7.2.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e78c8603dcd9a04c7364f1a3e670cea95d51ee865e4efb3556a3a63adef958ea", size = 131082, upload-time = "2026-01-28T18:14:59.732Z" },- { url = "https://files.pythonhosted.org/packages/37/d6/246513fbf9fa174af531f28412297dd05241d97a75911ac8febefa1a53c6/psutil-7.2.2-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1a571f2330c966c62aeda00dd24620425d4b0cc86881c89861fbc04549e5dc63", size = 181476, upload-time = "2026-01-28T18:15:01.884Z" },- { url = "https://files.pythonhosted.org/packages/b8/b5/9182c9af3836cca61696dabe4fd1304e17bc56cb62f17439e1154f225dd3/psutil-7.2.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:917e891983ca3c1887b4ef36447b1e0873e70c933afc831c6b6da078ba474312", size = 184062, upload-time = "2026-01-28T18:15:04.436Z" },- { url = "https://files.pythonhosted.org/packages/16/ba/0756dca669f5a9300d0cbcbfae9a4c30e446dfc7440ffe43ded5724bfd93/psutil-7.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:ab486563df44c17f5173621c7b198955bd6b613fb87c71c161f827d3fb149a9b", size = 139893, upload-time = "2026-01-28T18:15:06.378Z" },- { url = "https://files.pythonhosted.org/packages/1c/61/8fa0e26f33623b49949346de05ec1ddaad02ed8ba64af45f40a147dbfa97/psutil-7.2.2-cp313-cp313t-win_arm64.whl", hash = "sha256:ae0aefdd8796a7737eccea863f80f81e468a1e4cf14d926bd9b6f5f2d5f90ca9", size = 135589, upload-time = "2026-01-28T18:15:08.03Z" },- { url = "https://files.pythonhosted.org/packages/81/69/ef179ab5ca24f32acc1dac0c247fd6a13b501fd5534dbae0e05a1c48b66d/psutil-7.2.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:eed63d3b4d62449571547b60578c5b2c4bcccc5387148db46e0c2313dad0ee00", size = 130664, upload-time = "2026-01-28T18:15:09.469Z" },- { url = "https://files.pythonhosted.org/packages/7b/64/665248b557a236d3fa9efc378d60d95ef56dd0a490c2cd37dafc7660d4a9/psutil-7.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7b6d09433a10592ce39b13d7be5a54fbac1d1228ed29abc880fb23df7cb694c9", size = 131087, upload-time = "2026-01-28T18:15:11.724Z" },- { url = "https://files.pythonhosted.org/packages/d5/2e/e6782744700d6759ebce3043dcfa661fb61e2fb752b91cdeae9af12c2178/psutil-7.2.2-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fa4ecf83bcdf6e6c8f4449aff98eefb5d0604bf88cb883d7da3d8d2d909546a", size = 182383, upload-time = "2026-01-28T18:15:13.445Z" },- { url = "https://files.pythonhosted.org/packages/57/49/0a41cefd10cb7505cdc04dab3eacf24c0c2cb158a998b8c7b1d27ee2c1f5/psutil-7.2.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e452c464a02e7dc7822a05d25db4cde564444a67e58539a00f929c51eddda0cf", size = 185210, upload-time = "2026-01-28T18:15:16.002Z" },- { url = "https://files.pythonhosted.org/packages/dd/2c/ff9bfb544f283ba5f83ba725a3c5fec6d6b10b8f27ac1dc641c473dc390d/psutil-7.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:c7663d4e37f13e884d13994247449e9f8f574bc4655d509c3b95e9ec9e2b9dc1", size = 141228, upload-time = "2026-01-28T18:15:18.385Z" },- { url = "https://files.pythonhosted.org/packages/f2/fc/f8d9c31db14fcec13748d373e668bc3bed94d9077dbc17fb0eebc073233c/psutil-7.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:11fe5a4f613759764e79c65cf11ebdf26e33d6dd34336f8a337aa2996d71c841", size = 136284, upload-time = "2026-01-28T18:15:19.912Z" },- { url = "https://files.pythonhosted.org/packages/e7/36/5ee6e05c9bd427237b11b3937ad82bb8ad2752d72c6969314590dd0c2f6e/psutil-7.2.2-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486", size = 129090, upload-time = "2026-01-28T18:15:22.168Z" },- { url = "https://files.pythonhosted.org/packages/80/c4/f5af4c1ca8c1eeb2e92ccca14ce8effdeec651d5ab6053c589b074eda6e1/psutil-7.2.2-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979", size = 129859, upload-time = "2026-01-28T18:15:23.795Z" },- { url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9", size = 155560, upload-time = "2026-01-28T18:15:25.976Z" },- { url = "https://files.pythonhosted.org/packages/63/65/37648c0c158dc222aba51c089eb3bdfa238e621674dc42d48706e639204f/psutil-7.2.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e", size = 156997, upload-time = "2026-01-28T18:15:27.794Z" },- { url = "https://files.pythonhosted.org/packages/8e/13/125093eadae863ce03c6ffdbae9929430d116a246ef69866dad94da3bfbc/psutil-7.2.2-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8", size = 148972, upload-time = "2026-01-28T18:15:29.342Z" },- { url = "https://files.pythonhosted.org/packages/04/78/0acd37ca84ce3ddffaa92ef0f571e073faa6d8ff1f0559ab1272188ea2be/psutil-7.2.2-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc", size = 148266, upload-time = "2026-01-28T18:15:31.597Z" },- { url = "https://files.pythonhosted.org/packages/b4/90/e2159492b5426be0c1fef7acba807a03511f97c5f86b3caeda6ad92351a7/psutil-7.2.2-cp37-abi3-win_amd64.whl", hash = "sha256:eb7e81434c8d223ec4a219b5fc1c47d0417b12be7ea866e24fb5ad6e84b3d988", size = 137737, upload-time = "2026-01-28T18:15:33.849Z" },- { url = "https://files.pythonhosted.org/packages/8c/c7/7bb2e321574b10df20cbde462a94e2b71d05f9bbda251ef27d104668306a/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee", size = 134617, upload-time = "2026-01-28T18:15:36.514Z" },-]-[[package]]name = "pyarrow"version = "24.0.0"@@ -3006,11 +2207,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/f3/0a/fd7d723f8f8153418fb40cf9c940e82004fce7e987026b08a68a36dd3fe7/pydantic-2.13.3-py3-none-any.whl", hash = "sha256:6db14ac8dfc9a1e57f87ea2c0de670c251240f43cb0c30a5130e9720dc612927", size = 471981, upload-time = "2026-04-20T14:46:41.402Z" },]-[package.optional-dependencies]-email = [- { name = "email-validator" },-]-[[package]]name = "pydantic-core"version = "2.46.3"@@ -3086,19 +2282,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/17/eb/9d89ad2d9b0ba8cd65393d434471621b98912abb10fbe1df08e480ba57b5/pydantic_core-2.46.3-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd35aa21299def8db7ef4fe5c4ff862941a9a158ca7b63d61e66fe67d30416b4", size = 2137657, upload-time = "2026-04-20T14:42:45.149Z" },]-[[package]]-name = "pydantic-extra-types"-version = "2.11.1"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "pydantic" },- { name = "typing-extensions" },-]-sdist = { url = "https://files.pythonhosted.org/packages/66/71/dba38ee2651f84f7842206adbd2233d8bbdb59fb85e9fa14232486a8c471/pydantic_extra_types-2.11.1.tar.gz", hash = "sha256:46792d2307383859e923d8fcefa82108b1a141f8a9c0198982b3832ab5ef1049", size = 172002, upload-time = "2026-03-16T08:08:03.92Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/17/c1/3226e6d7f5a4f736f38ac11a6fbb262d701889802595cdb0f53a885ac2e0/pydantic_extra_types-2.11.1-py3-none-any.whl", hash = "sha256:1722ea2bddae5628ace25f2aa685b69978ef533123e5638cfbddb999e0100ec1", size = 79526, upload-time = "2026-03-16T08:08:02.533Z" },-]-[[package]]name = "pydantic-settings"version = "2.14.1"@@ -3577,31 +2760,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/d7/8e/7540e8a2036f79a125c1d2ebadf69ed7901608859186c856fa0388ef4197/requests-2.33.1-py3-none-any.whl", hash = "sha256:4e6d1ef462f3626a1f0a0a9c42dd93c63bad33f9f1c1937509b8c5c8718ab56a", size = 64947, upload-time = "2026-03-30T16:09:13.83Z" },]-[[package]]-name = "requests-oauthlib"-version = "2.0.0"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "oauthlib" },- { name = "requests" },-]-sdist = { url = "https://files.pythonhosted.org/packages/42/f2/05f29bc3913aea15eb670be136045bf5c5bbf4b99ecb839da9b422bb2c85/requests-oauthlib-2.0.0.tar.gz", hash = "sha256:b3dffaebd884d8cd778494369603a9e7b58d29111bf6b41bdc2dcd87203af4e9", size = 55650, upload-time = "2024-03-22T20:32:29.939Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/3b/5d/63d4ae3b9daea098d5d6f5da83984853c1bbacd5dc826764b249fe119d24/requests_oauthlib-2.0.0-py2.py3-none-any.whl", hash = "sha256:7dd8a5c40426b779b0868c404bdef9768deccf22749cde15852df527e6269b36", size = 24179, upload-time = "2024-03-22T20:32:28.055Z" },-]--[[package]]-name = "requests-toolbelt"-version = "1.0.0"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "requests" },-]-sdist = { url = "https://files.pythonhosted.org/packages/f3/61/d7545dafb7ac2230c70d38d31cbfe4cc64f7144dc41f6e4e4b78ecd9f5bb/requests-toolbelt-1.0.0.tar.gz", hash = "sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6", size = 206888, upload-time = "2023-05-01T04:11:33.229Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/3f/51/d4db610ef29373b879047326cbf6fa98b6c1969d6f6dc423279de2b1be2c/requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06", size = 54481, upload-time = "2023-05-01T04:11:28.427Z" },-]-[[package]]name = "respx"version = "0.23.1"@@ -3627,88 +2785,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/b3/76/6d163cfac87b632216f71879e6b2cf17163f773ff59c00b5ff4900a80fa3/rich-14.3.4-py3-none-any.whl", hash = "sha256:07e7adb4690f68864777b1450859253bed81a99a31ac321ac1817b2313558952", size = 310480, upload-time = "2026-04-11T02:57:47.484Z" },]-[[package]]-name = "rich-toolkit"-version = "0.20.1"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "click" },- { name = "rich" },- { name = "typing-extensions" },-]-sdist = { url = "https://files.pythonhosted.org/packages/29/63/3e427c62f1992945c997d4ec31e2fcb37d26aadbe5aa44ae5b29f7f64d26/rich_toolkit-0.20.1.tar.gz", hash = "sha256:c7336ae281f435c785acecaedc4b71d4b663dc73d9c8079fea96372527e822a4", size = 203473, upload-time = "2026-06-05T08:56:57.679Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/00/88/309f07d08155da2ba1d5ceb42d270fb42fbe34a807684543e3ffc10fe713/rich_toolkit-0.20.1-py3-none-any.whl", hash = "sha256:2a6d5f8e15759b9eba5a9ee63da10b275359ead20e5a0fc92bd5b4dbae8ce4bf", size = 35525, upload-time = "2026-06-05T08:56:58.586Z" },-]--[[package]]-name = "rignore"-version = "0.7.6"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/e5/f5/8bed2310abe4ae04b67a38374a4d311dd85220f5d8da56f47ae9361be0b0/rignore-0.7.6.tar.gz", hash = "sha256:00d3546cd793c30cb17921ce674d2c8f3a4b00501cb0e3dd0e82217dbeba2671", size = 57140, upload-time = "2025-11-05T21:41:21.968Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/0b/0e/012556ef3047a2628842b44e753bb15f4dc46806780ff090f1e8fe4bf1eb/rignore-0.7.6-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:03e82348cb7234f8d9b2834f854400ddbbd04c0f8f35495119e66adbd37827a8", size = 883488, upload-time = "2025-11-05T20:42:41.359Z" },- { url = "https://files.pythonhosted.org/packages/93/b0/d4f1f3fe9eb3f8e382d45ce5b0547ea01c4b7e0b4b4eb87bcd66a1d2b888/rignore-0.7.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b9e624f6be6116ea682e76c5feb71ea91255c67c86cb75befe774365b2931961", size = 820411, upload-time = "2025-11-05T20:42:24.782Z" },- { url = "https://files.pythonhosted.org/packages/4a/c8/dea564b36dedac8de21c18e1851789545bc52a0c22ece9843444d5608a6a/rignore-0.7.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bda49950d405aa8d0ebe26af807c4e662dd281d926530f03f29690a2e07d649a", size = 897821, upload-time = "2025-11-05T20:40:52.613Z" },- { url = "https://files.pythonhosted.org/packages/b3/2b/ee96db17ac1835e024c5d0742eefb7e46de60020385ac883dd3d1cde2c1f/rignore-0.7.6-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b5fd5ab3840b8c16851d327ed06e9b8be6459702a53e5ab1fc4073b684b3789e", size = 873963, upload-time = "2025-11-05T20:41:07.49Z" },- { url = "https://files.pythonhosted.org/packages/a5/8c/ad5a57bbb9d14d5c7e5960f712a8a0b902472ea3f4a2138cbf70d1777b75/rignore-0.7.6-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ced2a248352636a5c77504cb755dc02c2eef9a820a44d3f33061ce1bb8a7f2d2", size = 1169216, upload-time = "2025-11-05T20:41:23.73Z" },- { url = "https://files.pythonhosted.org/packages/80/e6/5b00bc2a6bc1701e6878fca798cf5d9125eb3113193e33078b6fc0d99123/rignore-0.7.6-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a04a3b73b75ddc12c9c9b21efcdaab33ca3832941d6f1d67bffd860941cd448a", size = 942942, upload-time = "2025-11-05T20:41:39.393Z" },- { url = "https://files.pythonhosted.org/packages/85/e5/7f99bd0cc9818a91d0e8b9acc65b792e35750e3bdccd15a7ee75e64efca4/rignore-0.7.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d24321efac92140b7ec910ac7c53ab0f0c86a41133d2bb4b0e6a7c94967f44dd", size = 959787, upload-time = "2025-11-05T20:42:09.765Z" },- { url = "https://files.pythonhosted.org/packages/55/54/2ffea79a7c1eabcede1926347ebc2a81bc6b81f447d05b52af9af14948b9/rignore-0.7.6-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:73c7aa109d41e593785c55fdaa89ad80b10330affa9f9d3e3a51fa695f739b20", size = 984245, upload-time = "2025-11-05T20:41:54.062Z" },- { url = "https://files.pythonhosted.org/packages/41/f7/e80f55dfe0f35787fa482aa18689b9c8251e045076c35477deb0007b3277/rignore-0.7.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1734dc49d1e9501b07852ef44421f84d9f378da9fbeda729e77db71f49cac28b", size = 1078647, upload-time = "2025-11-05T21:40:13.463Z" },- { url = "https://files.pythonhosted.org/packages/d4/cf/2c64f0b6725149f7c6e7e5a909d14354889b4beaadddaa5fff023ec71084/rignore-0.7.6-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5719ea14ea2b652c0c0894be5dfde954e1853a80dea27dd2fbaa749618d837f5", size = 1139186, upload-time = "2025-11-05T21:40:31.27Z" },- { url = "https://files.pythonhosted.org/packages/75/95/a86c84909ccc24af0d094b50d54697951e576c252a4d9f21b47b52af9598/rignore-0.7.6-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:8e23424fc7ce35726854f639cb7968151a792c0c3d9d082f7f67e0c362cfecca", size = 1117604, upload-time = "2025-11-05T21:40:48.07Z" },- { url = "https://files.pythonhosted.org/packages/7f/5e/13b249613fd5d18d58662490ab910a9f0be758981d1797789913adb4e918/rignore-0.7.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3efdcf1dd84d45f3e2bd2f93303d9be103888f56dfa7c3349b5bf4f0657ec696", size = 1127725, upload-time = "2025-11-05T21:41:05.804Z" },- { url = "https://files.pythonhosted.org/packages/c7/28/fa5dcd1e2e16982c359128664e3785f202d3eca9b22dd0b2f91c4b3d242f/rignore-0.7.6-cp312-cp312-win32.whl", hash = "sha256:ccca9d1a8b5234c76b71546fc3c134533b013f40495f394a65614a81f7387046", size = 646145, upload-time = "2025-11-05T21:41:51.096Z" },- { url = "https://files.pythonhosted.org/packages/26/87/69387fb5dd81a0f771936381431780b8cf66fcd2cfe9495e1aaf41548931/rignore-0.7.6-cp312-cp312-win_amd64.whl", hash = "sha256:c96a285e4a8bfec0652e0bfcf42b1aabcdda1e7625f5006d188e3b1c87fdb543", size = 726090, upload-time = "2025-11-05T21:41:36.485Z" },- { url = "https://files.pythonhosted.org/packages/24/5f/e8418108dcda8087fb198a6f81caadbcda9fd115d61154bf0df4d6d3619b/rignore-0.7.6-cp312-cp312-win_arm64.whl", hash = "sha256:a64a750e7a8277a323f01ca50b7784a764845f6cce2fe38831cb93f0508d0051", size = 656317, upload-time = "2025-11-05T21:41:25.305Z" },- { url = "https://files.pythonhosted.org/packages/b7/8a/a4078f6e14932ac7edb171149c481de29969d96ddee3ece5dc4c26f9e0c3/rignore-0.7.6-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:2bdab1d31ec9b4fb1331980ee49ea051c0d7f7bb6baa28b3125ef03cdc48fdaf", size = 883057, upload-time = "2025-11-05T20:42:42.741Z" },- { url = "https://files.pythonhosted.org/packages/f9/8f/f8daacd177db4bf7c2223bab41e630c52711f8af9ed279be2058d2fe4982/rignore-0.7.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:90f0a00ce0c866c275bf888271f1dc0d2140f29b82fcf33cdbda1e1a6af01010", size = 820150, upload-time = "2025-11-05T20:42:26.545Z" },- { url = "https://files.pythonhosted.org/packages/36/31/b65b837e39c3f7064c426754714ac633b66b8c2290978af9d7f513e14aa9/rignore-0.7.6-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c1ad295537041dc2ed4b540fb1a3906bd9ede6ccdad3fe79770cd89e04e3c73c", size = 897406, upload-time = "2025-11-05T20:40:53.854Z" },- { url = "https://files.pythonhosted.org/packages/ca/58/1970ce006c427e202ac7c081435719a076c478f07b3a23f469227788dc23/rignore-0.7.6-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f782dbd3a65a5ac85adfff69e5c6b101285ef3f845c3a3cae56a54bebf9fe116", size = 874050, upload-time = "2025-11-05T20:41:08.922Z" },- { url = "https://files.pythonhosted.org/packages/d4/00/eb45db9f90137329072a732273be0d383cb7d7f50ddc8e0bceea34c1dfdf/rignore-0.7.6-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65cece3b36e5b0826d946494734c0e6aaf5a0337e18ff55b071438efe13d559e", size = 1167835, upload-time = "2025-11-05T20:41:24.997Z" },- { url = "https://files.pythonhosted.org/packages/f3/f1/6f1d72ddca41a64eed569680587a1236633587cc9f78136477ae69e2c88a/rignore-0.7.6-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d7e4bb66c13cd7602dc8931822c02dfbbd5252015c750ac5d6152b186f0a8be0", size = 941945, upload-time = "2025-11-05T20:41:40.628Z" },- { url = "https://files.pythonhosted.org/packages/48/6f/2f178af1c1a276a065f563ec1e11e7a9e23d4996fd0465516afce4b5c636/rignore-0.7.6-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:297e500c15766e196f68aaaa70e8b6db85fa23fdc075b880d8231fdfba738cd7", size = 959067, upload-time = "2025-11-05T20:42:11.09Z" },- { url = "https://files.pythonhosted.org/packages/5b/db/423a81c4c1e173877c7f9b5767dcaf1ab50484a94f60a0b2ed78be3fa765/rignore-0.7.6-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a07084211a8d35e1a5b1d32b9661a5ed20669970b369df0cf77da3adea3405de", size = 984438, upload-time = "2025-11-05T20:41:55.443Z" },- { url = "https://files.pythonhosted.org/packages/31/eb/c4f92cc3f2825d501d3c46a244a671eb737fc1bcf7b05a3ecd34abb3e0d7/rignore-0.7.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:181eb2a975a22256a1441a9d2f15eb1292839ea3f05606620bd9e1938302cf79", size = 1078365, upload-time = "2025-11-05T21:40:15.148Z" },- { url = "https://files.pythonhosted.org/packages/26/09/99442f02794bd7441bfc8ed1c7319e890449b816a7493b2db0e30af39095/rignore-0.7.6-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:7bbcdc52b5bf9f054b34ce4af5269df5d863d9c2456243338bc193c28022bd7b", size = 1139066, upload-time = "2025-11-05T21:40:32.771Z" },- { url = "https://files.pythonhosted.org/packages/2c/88/bcfc21e520bba975410e9419450f4b90a2ac8236b9a80fd8130e87d098af/rignore-0.7.6-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:f2e027a6da21a7c8c0d87553c24ca5cc4364def18d146057862c23a96546238e", size = 1118036, upload-time = "2025-11-05T21:40:49.646Z" },- { url = "https://files.pythonhosted.org/packages/e2/25/d37215e4562cda5c13312636393aea0bafe38d54d4e0517520a4cc0753ec/rignore-0.7.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ee4a18b82cbbc648e4aac1510066682fe62beb5dc88e2c67c53a83954e541360", size = 1127550, upload-time = "2025-11-05T21:41:07.648Z" },- { url = "https://files.pythonhosted.org/packages/dc/76/a264ab38bfa1620ec12a8ff1c07778da89e16d8c0f3450b0333020d3d6dc/rignore-0.7.6-cp313-cp313-win32.whl", hash = "sha256:a7d7148b6e5e95035d4390396895adc384d37ff4e06781a36fe573bba7c283e5", size = 646097, upload-time = "2025-11-05T21:41:53.201Z" },- { url = "https://files.pythonhosted.org/packages/62/44/3c31b8983c29ea8832b6082ddb1d07b90379c2d993bd20fce4487b71b4f4/rignore-0.7.6-cp313-cp313-win_amd64.whl", hash = "sha256:b037c4b15a64dced08fc12310ee844ec2284c4c5c1ca77bc37d0a04f7bff386e", size = 726170, upload-time = "2025-11-05T21:41:38.131Z" },- { url = "https://files.pythonhosted.org/packages/aa/41/e26a075cab83debe41a42661262f606166157df84e0e02e2d904d134c0d8/rignore-0.7.6-cp313-cp313-win_arm64.whl", hash = "sha256:e47443de9b12fe569889bdbe020abe0e0b667516ee2ab435443f6d0869bd2804", size = 656184, upload-time = "2025-11-05T21:41:27.396Z" },- { url = "https://files.pythonhosted.org/packages/9a/b9/1f5bd82b87e5550cd843ceb3768b4a8ef274eb63f29333cf2f29644b3d75/rignore-0.7.6-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:8e41be9fa8f2f47239ded8920cc283699a052ac4c371f77f5ac017ebeed75732", size = 882632, upload-time = "2025-11-05T20:42:44.063Z" },- { url = "https://files.pythonhosted.org/packages/e9/6b/07714a3efe4a8048864e8a5b7db311ba51b921e15268b17defaebf56d3db/rignore-0.7.6-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6dc1e171e52cefa6c20e60c05394a71165663b48bca6c7666dee4f778f2a7d90", size = 820760, upload-time = "2025-11-05T20:42:27.885Z" },- { url = "https://files.pythonhosted.org/packages/ac/0f/348c829ea2d8d596e856371b14b9092f8a5dfbb62674ec9b3f67e4939a9d/rignore-0.7.6-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ce2268837c3600f82ab8db58f5834009dc638ee17103582960da668963bebc5", size = 899044, upload-time = "2025-11-05T20:40:55.336Z" },- { url = "https://files.pythonhosted.org/packages/f0/30/2e1841a19b4dd23878d73edd5d82e998a83d5ed9570a89675f140ca8b2ad/rignore-0.7.6-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:690a3e1b54bfe77e89c4bacb13f046e642f8baadafc61d68f5a726f324a76ab6", size = 874144, upload-time = "2025-11-05T20:41:10.195Z" },- { url = "https://files.pythonhosted.org/packages/c2/bf/0ce9beb2e5f64c30e3580bef09f5829236889f01511a125f98b83169b993/rignore-0.7.6-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:09d12ac7a0b6210c07bcd145007117ebd8abe99c8eeb383e9e4673910c2754b2", size = 1168062, upload-time = "2025-11-05T20:41:26.511Z" },- { url = "https://files.pythonhosted.org/packages/b9/8b/571c178414eb4014969865317da8a02ce4cf5241a41676ef91a59aab24de/rignore-0.7.6-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2a2b2b74a8c60203b08452479b90e5ce3dbe96a916214bc9eb2e5af0b6a9beb0", size = 942542, upload-time = "2025-11-05T20:41:41.838Z" },- { url = "https://files.pythonhosted.org/packages/19/62/7a3cf601d5a45137a7e2b89d10c05b5b86499190c4b7ca5c3c47d79ee519/rignore-0.7.6-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8fc5a531ef02131e44359419a366bfac57f773ea58f5278c2cdd915f7d10ea94", size = 958739, upload-time = "2025-11-05T20:42:12.463Z" },- { url = "https://files.pythonhosted.org/packages/5f/1f/4261f6a0d7caf2058a5cde2f5045f565ab91aa7badc972b57d19ce58b14e/rignore-0.7.6-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b7a1f77d9c4cd7e76229e252614d963442686bfe12c787a49f4fe481df49e7a9", size = 984138, upload-time = "2025-11-05T20:41:56.775Z" },- { url = "https://files.pythonhosted.org/packages/2b/bf/628dfe19c75e8ce1f45f7c248f5148b17dfa89a817f8e3552ab74c3ae812/rignore-0.7.6-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ead81f728682ba72b5b1c3d5846b011d3e0174da978de87c61645f2ed36659a7", size = 1079299, upload-time = "2025-11-05T21:40:16.639Z" },- { url = "https://files.pythonhosted.org/packages/af/a5/be29c50f5c0c25c637ed32db8758fdf5b901a99e08b608971cda8afb293b/rignore-0.7.6-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:12ffd50f520c22ffdabed8cd8bfb567d9ac165b2b854d3e679f4bcaef11a9441", size = 1139618, upload-time = "2025-11-05T21:40:34.507Z" },- { url = "https://files.pythonhosted.org/packages/2a/40/3c46cd7ce4fa05c20b525fd60f599165e820af66e66f2c371cd50644558f/rignore-0.7.6-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:e5a16890fbe3c894f8ca34b0fcacc2c200398d4d46ae654e03bc9b3dbf2a0a72", size = 1117626, upload-time = "2025-11-05T21:40:51.494Z" },- { url = "https://files.pythonhosted.org/packages/8c/b9/aea926f263b8a29a23c75c2e0d8447965eb1879d3feb53cfcf84db67ed58/rignore-0.7.6-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3abab3bf99e8a77488ef6c7c9a799fac22224c28fe9f25cc21aa7cc2b72bfc0b", size = 1128144, upload-time = "2025-11-05T21:41:09.169Z" },- { url = "https://files.pythonhosted.org/packages/a4/f6/0d6242f8d0df7f2ecbe91679fefc1f75e7cd2072cb4f497abaab3f0f8523/rignore-0.7.6-cp314-cp314-win32.whl", hash = "sha256:eeef421c1782953c4375aa32f06ecae470c1285c6381eee2a30d2e02a5633001", size = 646385, upload-time = "2025-11-05T21:41:55.105Z" },- { url = "https://files.pythonhosted.org/packages/d5/38/c0dcd7b10064f084343d6af26fe9414e46e9619c5f3224b5272e8e5d9956/rignore-0.7.6-cp314-cp314-win_amd64.whl", hash = "sha256:6aeed503b3b3d5af939b21d72a82521701a4bd3b89cd761da1e7dc78621af304", size = 725738, upload-time = "2025-11-05T21:41:39.736Z" },- { url = "https://files.pythonhosted.org/packages/d9/7a/290f868296c1ece914d565757ab363b04730a728b544beb567ceb3b2d96f/rignore-0.7.6-cp314-cp314-win_arm64.whl", hash = "sha256:104f215b60b3c984c386c3e747d6ab4376d5656478694e22c7bd2f788ddd8304", size = 656008, upload-time = "2025-11-05T21:41:29.028Z" },- { url = "https://files.pythonhosted.org/packages/ca/d2/3c74e3cd81fe8ea08a8dcd2d755c09ac2e8ad8fe409508904557b58383d3/rignore-0.7.6-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:bb24a5b947656dd94cb9e41c4bc8b23cec0c435b58be0d74a874f63c259549e8", size = 882835, upload-time = "2025-11-05T20:42:45.443Z" },- { url = "https://files.pythonhosted.org/packages/77/61/a772a34b6b63154877433ac2d048364815b24c2dd308f76b212c408101a2/rignore-0.7.6-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5b1e33c9501cefe24b70a1eafd9821acfd0ebf0b35c3a379430a14df089993e3", size = 820301, upload-time = "2025-11-05T20:42:29.226Z" },- { url = "https://files.pythonhosted.org/packages/71/30/054880b09c0b1b61d17eeb15279d8bf729c0ba52b36c3ada52fb827cbb3c/rignore-0.7.6-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bec3994665a44454df86deb762061e05cd4b61e3772f5b07d1882a8a0d2748d5", size = 897611, upload-time = "2025-11-05T20:40:56.475Z" },- { url = "https://files.pythonhosted.org/packages/1e/40/b2d1c169f833d69931bf232600eaa3c7998ba4f9a402e43a822dad2ea9f2/rignore-0.7.6-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:26cba2edfe3cff1dfa72bddf65d316ddebf182f011f2f61538705d6dbaf54986", size = 873875, upload-time = "2025-11-05T20:41:11.561Z" },- { url = "https://files.pythonhosted.org/packages/55/59/ca5ae93d83a1a60e44b21d87deb48b177a8db1b85e82fc8a9abb24a8986d/rignore-0.7.6-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ffa86694fec604c613696cb91e43892aa22e1fec5f9870e48f111c603e5ec4e9", size = 1167245, upload-time = "2025-11-05T20:41:28.29Z" },- { url = "https://files.pythonhosted.org/packages/a5/52/cf3dce392ba2af806cba265aad6bcd9c48bb2a6cb5eee448d3319f6e505b/rignore-0.7.6-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:48efe2ed95aa8104145004afb15cdfa02bea5cdde8b0344afeb0434f0d989aa2", size = 941750, upload-time = "2025-11-05T20:41:43.111Z" },- { url = "https://files.pythonhosted.org/packages/ec/be/3f344c6218d779395e785091d05396dfd8b625f6aafbe502746fcd880af2/rignore-0.7.6-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8dcae43eb44b7f2457fef7cc87f103f9a0013017a6f4e62182c565e924948f21", size = 958896, upload-time = "2025-11-05T20:42:13.784Z" },- { url = "https://files.pythonhosted.org/packages/c9/34/d3fa71938aed7d00dcad87f0f9bcb02ad66c85d6ffc83ba31078ce53646a/rignore-0.7.6-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2cd649a7091c0dad2f11ef65630d30c698d505cbe8660dd395268e7c099cc99f", size = 983992, upload-time = "2025-11-05T20:41:58.022Z" },- { url = "https://files.pythonhosted.org/packages/24/a4/52a697158e9920705bdbd0748d59fa63e0f3233fb92e9df9a71afbead6ca/rignore-0.7.6-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:42de84b0289d478d30ceb7ae59023f7b0527786a9a5b490830e080f0e4ea5aeb", size = 1078181, upload-time = "2025-11-05T21:40:18.151Z" },- { url = "https://files.pythonhosted.org/packages/ac/65/aa76dbcdabf3787a6f0fd61b5cc8ed1e88580590556d6c0207960d2384bb/rignore-0.7.6-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:875a617e57b53b4acbc5a91de418233849711c02e29cc1f4f9febb2f928af013", size = 1139232, upload-time = "2025-11-05T21:40:35.966Z" },- { url = "https://files.pythonhosted.org/packages/08/44/31b31a49b3233c6842acc1c0731aa1e7fb322a7170612acf30327f700b44/rignore-0.7.6-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:8703998902771e96e49968105207719f22926e4431b108450f3f430b4e268b7c", size = 1117349, upload-time = "2025-11-05T21:40:53.013Z" },- { url = "https://files.pythonhosted.org/packages/e9/ae/1b199a2302c19c658cf74e5ee1427605234e8c91787cfba0015f2ace145b/rignore-0.7.6-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:602ef33f3e1b04c1e9a10a3c03f8bc3cef2d2383dcc250d309be42b49923cabc", size = 1127702, upload-time = "2025-11-05T21:41:10.881Z" },- { url = "https://files.pythonhosted.org/packages/fc/d3/18210222b37e87e36357f7b300b7d98c6dd62b133771e71ae27acba83a4f/rignore-0.7.6-cp314-cp314t-win32.whl", hash = "sha256:c1d8f117f7da0a4a96a8daef3da75bc090e3792d30b8b12cfadc240c631353f9", size = 647033, upload-time = "2025-11-05T21:42:00.095Z" },- { url = "https://files.pythonhosted.org/packages/3e/87/033eebfbee3ec7d92b3bb1717d8f68c88e6fc7de54537040f3b3a405726f/rignore-0.7.6-cp314-cp314t-win_amd64.whl", hash = "sha256:ca36e59408bec81de75d307c568c2d0d410fb880b1769be43611472c61e85c96", size = 725647, upload-time = "2025-11-05T21:41:44.449Z" },- { url = "https://files.pythonhosted.org/packages/79/62/b88e5879512c55b8ee979c666ee6902adc4ed05007226de266410ae27965/rignore-0.7.6-cp314-cp314t-win_arm64.whl", hash = "sha256:b83adabeb3e8cf662cabe1931b83e165b88c526fa6af6b3aa90429686e474896", size = 656035, upload-time = "2025-11-05T21:41:31.13Z" },-]-[[package]]name = "rpds-py"version = "0.30.0"@@ -3815,18 +2891,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/c0/98/6beb4b351e472e5f4c4613f7c35a5290b8be2497e183825310c4c3a3984b/ruff-0.15.12-py3-none-win_arm64.whl", hash = "sha256:a538f7a82d061cee7be55542aca1d86d1393d55d81d4fcc314370f4340930d4f", size = 11120821, upload-time = "2026-04-24T18:16:57.979Z" },]-[[package]]-name = "s3transfer"-version = "0.19.0"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "botocore" },-]-sdist = { url = "https://files.pythonhosted.org/packages/f6/94/dcdaeb1713cab9c84def276cfac7388b17c7d9855bbcfe88d77e4dbafd44/s3transfer-0.19.0.tar.gz", hash = "sha256:ce436931687addc4c1712d52d40b32f53e88315723f107ffa20ba82b05a0f685", size = 165171, upload-time = "2026-06-16T19:44:51.599Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/46/5f/4c174edad94f82de888ac00a5ddd8d07b35609b6c94f0bdf4d74af57703e/s3transfer-0.19.0-py3-none-any.whl", hash = "sha256:777cc2415536f1debadb5c2ef7779275d0fc0fe0e042411cdd6caebeb2685262", size = 90101, upload-time = "2026-06-16T19:44:50.439Z" },-]-[[package]]name = "scantree"version = "0.0.4"@@ -3840,19 +2904,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/93/ce/828467ddfa0d2fe473673026442d2032d552a168e42cfbf25fd0e5264e0c/scantree-0.0.4-py3-none-any.whl", hash = "sha256:7616ab65aa6b7f16fcf8e6fa1d9afaa99a27ab72bba05c61b691853b96763174", size = 20690, upload-time = "2024-08-03T20:08:58.137Z" },]-[[package]]-name = "sentry-sdk"-version = "2.63.0"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "certifi" },- { name = "urllib3" },-]-sdist = { url = "https://files.pythonhosted.org/packages/ba/c8/b3c970a5b186722d276cd40a05b3254e03bccc0208560aff20f612e018e8/sentry_sdk-2.63.0.tar.gz", hash = "sha256:2a1502bf864769275dbc8c2c9fc7a0f7f5e18358180b615d262d13a31ffba216", size = 912449, upload-time = "2026-06-16T12:45:57.553Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/7b/57/cb205f7d93373120f666b9c5736dc0815524d96a9b278e7a728f018dc22a/sentry_sdk-2.63.0-py3-none-any.whl", hash = "sha256:3a9b5ddd403f79eb73bd670f75f04485819db53d28f76ced7bc09041cb0dfd6a", size = 495950, upload-time = "2026-06-16T12:45:55.819Z" },-]-[[package]]name = "shellingham"version = "1.5.4"@@ -3898,47 +2949,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/37/c3/6eeb6034408dac0fa653d126c9204ade96b819c936e136c5e8a6897eee9c/socksio-1.0.0-py3-none-any.whl", hash = "sha256:95dc1f15f9b34e8d7b16f06d74b8ccf48f609af32ab33c608d08761c5dcbb1f3", size = 12763, upload-time = "2020-04-17T15:50:31.878Z" },]-[[package]]-name = "sqlalchemy"-version = "2.0.51"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "greenlet", marker = "platform_machine == 'AMD64' or platform_machine == 'WIN32' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'ppc64le' or platform_machine == 'win32' or platform_machine == 'x86_64'" },- { name = "typing-extensions" },-]-sdist = { url = "https://files.pythonhosted.org/packages/02/f1/a7a892f18d4d224e6b26f706531eafccc41e37594d37d304786969ee13cb/sqlalchemy-2.0.51.tar.gz", hash = "sha256:804dccd8a4a6242c4e30ad961e540e18a588f6527202f2d6791b01845d59fdc9", size = 9912201, upload-time = "2026-06-15T15:41:20.012Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/d5/70/e868bc5412acd101a8280f25c95f10eeae0771c4eb806b02491142810ee8/sqlalchemy-2.0.51-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7d78702b26ba1c18b2d0fb2ea940ba7f17a9581b42e8361ff93920ebbee1235a", size = 2160291, upload-time = "2026-06-15T16:08:48.918Z" },- { url = "https://files.pythonhosted.org/packages/e5/1c/71ee0f8a6b9d7316a1ccd30430b4c62b6c2e36adc96017a4e3a72dce49d6/sqlalchemy-2.0.51-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:581921d849d6e6f994d560389192955e80e2950e18fcdfe2ccea863e01158e6e", size = 3343835, upload-time = "2026-06-15T16:19:42.613Z" },- { url = "https://files.pythonhosted.org/packages/2b/7c/7ab9f9aadc5944fdd06612484ed7918fe376ad871a5f50404dc1536e0194/sqlalchemy-2.0.51-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1d21ce524ab86c23046e992a5b81cb54c21079c6df6e78b8fc77d77cac70a6b9", size = 3358470, upload-time = "2026-06-15T16:26:38.011Z" },- { url = "https://files.pythonhosted.org/packages/d0/7d/ff77169fee6186de145a7f2b87006c39638391130abbab2b1f63ac6ea583/sqlalchemy-2.0.51-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c5d98a2709840027f5a347c3af0a7c3d5f6c1ff93af2ca1c54494e23cba8f389", size = 3289874, upload-time = "2026-06-15T16:19:45.212Z" },- { url = "https://files.pythonhosted.org/packages/6f/3b/6c505903710d781b55bc3141ee34a062bf9745a6b5bc7333305b9ed63b33/sqlalchemy-2.0.51-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1181256e0f16479691b5616d36375dc2620ad8332b25978763c3d206ad3f3f1d", size = 3321692, upload-time = "2026-06-15T16:26:39.747Z" },- { url = "https://files.pythonhosted.org/packages/3c/b7/c5ffe50aa2f4d947c9250e1519d939260329a07fe6272edfccd784b3d007/sqlalchemy-2.0.51-cp312-cp312-win32.whl", hash = "sha256:9f380393be5abeb6815f68fd39271b95127173511b6706b0a630a9995d53f8f5", size = 2119674, upload-time = "2026-06-15T16:23:09.543Z" },- { url = "https://files.pythonhosted.org/packages/25/dc/46a65916af68a06ef6b972c6050ba4c8f97070fe3fb33097d34229d9bef6/sqlalchemy-2.0.51-cp312-cp312-win_amd64.whl", hash = "sha256:2cf39aabdf48e87c1c2c2ed6d20d33ffa0733b3071ce9c5f66357947dd009080", size = 2146670, upload-time = "2026-06-15T16:23:11.048Z" },- { url = "https://files.pythonhosted.org/packages/54/fe/a210d52fd1a90ecfae8a78e9d8b27e18d733d60818a8bf250ff690b75120/sqlalchemy-2.0.51-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7c2056838b6685b72fdb36c99996cf862753461a62f2e84f4196371d3b2d6a07", size = 2157184, upload-time = "2026-06-15T16:08:50.374Z" },- { url = "https://files.pythonhosted.org/packages/17/6b/2dce8369b199cb855110e056032f94a9f66dacc2237d3d39c115a86eac56/sqlalchemy-2.0.51-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:483b11bd46bf35fc14c52faf338b04300c9e6ce554bce9b11be85bfec3bc3195", size = 3284735, upload-time = "2026-06-15T16:19:46.934Z" },- { url = "https://files.pythonhosted.org/packages/53/ff/dbc495b8a14da840faffb353857a72d4190113cac33727906fb997047f0f/sqlalchemy-2.0.51-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1bed1ee8b01da6088210aa9412023326fb98a599ba502e6118308601dcbef77f", size = 3302756, upload-time = "2026-06-15T16:26:41.336Z" },- { url = "https://files.pythonhosted.org/packages/cf/d5/fde8f4dddcf518ee15ab35a7c6a28acc32c8ba548d1d2aa451f96e6dbb0b/sqlalchemy-2.0.51-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:72ca54c952107ba5cd58854b67a5a6268631289d21651a1235396f3b98b47400", size = 3232055, upload-time = "2026-06-15T16:19:49.286Z" },- { url = "https://files.pythonhosted.org/packages/67/d1/43d3a0ac955a58601c24fa23038b1c55ee3a1ec02c0f96ebb1eae2bcf614/sqlalchemy-2.0.51-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b3e693d15533a45cd5906f0589f9c35090bef6ef45bf1e8195c424aa0ae06a8d", size = 3269850, upload-time = "2026-06-15T16:26:43.017Z" },- { url = "https://files.pythonhosted.org/packages/94/df/de669c7054cd47c4439ac34b1b2ee8b804a794791fbb10720e997a2c87c7/sqlalchemy-2.0.51-cp313-cp313-win32.whl", hash = "sha256:b93ab07b5292dbe7e6b8da89475275e7042744283921344b56105f3eeb0f828b", size = 2117721, upload-time = "2026-06-15T16:23:12.36Z" },- { url = "https://files.pythonhosted.org/packages/d0/8a/403c51d064196bae20a0bc2476577f83a3f8dd299719a97417086b7f2ec5/sqlalchemy-2.0.51-cp313-cp313-win_amd64.whl", hash = "sha256:0f053118c30e53161857a953e4de667d90e274980dccbe5dd3829bbbeece72a5", size = 2143615, upload-time = "2026-06-15T16:23:13.906Z" },- { url = "https://files.pythonhosted.org/packages/b1/49/a739be2e1d02a96a658eb71ab45d921c874249252358ad24a5bffdd02525/sqlalchemy-2.0.51-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6ea306caaae6bd5afd0a46050003c88f6bf33227377a49298c498c3cb88ff491", size = 2158999, upload-time = "2026-06-15T16:08:51.759Z" },- { url = "https://files.pythonhosted.org/packages/23/6b/2e0e38cf75c8780eca78d9b2e78164f8bcfd70125e5caa588ff5cbb9c9f4/sqlalchemy-2.0.51-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c45a496d6bc05dec41dcd4c3a2b183723f47473255c159cd80b503c8f246424d", size = 3282539, upload-time = "2026-06-15T16:19:51.065Z" },- { url = "https://files.pythonhosted.org/packages/dd/a1/e77854cb5336fd37dc3c6ae3b71de242c98caac5725120be0b526b31cbd0/sqlalchemy-2.0.51-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4004ada0aafe8ae1991b2cd1d99c6d9146126e123bd6f883c260d974aa012e54", size = 3287545, upload-time = "2026-06-15T16:26:44.735Z" },- { url = "https://files.pythonhosted.org/packages/f6/ab/9e17272fd4dac8df3b83c4fbe52b998a1c9d89a843c8c35ff29b74ff7364/sqlalchemy-2.0.51-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:0f6bcad487aee1c638d707235682fc96f741de00663619881ab235400d03289e", size = 3230929, upload-time = "2026-06-15T16:19:52.625Z" },- { url = "https://files.pythonhosted.org/packages/02/3c/52f408ea701781caee975606beccc48845f2aee8711ac29843d612c0306c/sqlalchemy-2.0.51-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:39a76529db6305693d8d4affa58ad5b5e2e18edd62daea628b29b97930b3513d", size = 3252888, upload-time = "2026-06-15T16:26:46.454Z" },- { url = "https://files.pythonhosted.org/packages/24/16/3efd2ee6bc4ca4693a30a1dd17a91b606cae15d517d2a4746611d9b73ce8/sqlalchemy-2.0.51-cp314-cp314-win32.whl", hash = "sha256:08a204d8b5638717c26a24df18fcf40af45a6b22e35b70b1d62f0113c2e278e8", size = 2120551, upload-time = "2026-06-15T16:23:15.629Z" },- { url = "https://files.pythonhosted.org/packages/7b/78/55b12e70f45bccc40d9e483925c065027b3b98ea4cbbdf6f8c2546feaf6c/sqlalchemy-2.0.51-cp314-cp314-win_amd64.whl", hash = "sha256:96747bfbadb055466e5b46d572618170046b45ce5a4879167f50d70a5319a499", size = 2146318, upload-time = "2026-06-15T16:23:17.108Z" },- { url = "https://files.pythonhosted.org/packages/21/db/a9574ed40fed418924b1b1a3e54f47ee3963053b3d3d325a0d36b41f2c08/sqlalchemy-2.0.51-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e5ea1a213be1fcd5e49d9904c3b9939211ded90bc2a64e93f4c01963474285de", size = 2178920, upload-time = "2026-06-15T15:59:56.285Z" },- { url = "https://files.pythonhosted.org/packages/bf/90/a1bb5c7cbba76b7bc1fbd586d0a5479a7bc9c27b4a8298f22ec9423b2bb3/sqlalchemy-2.0.51-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7c6b36ed71f41942bdcd2ad2522be46bfce09d5705be5640ecf19bbc7660e4b7", size = 3566534, upload-time = "2026-06-15T15:58:35.024Z" },- { url = "https://files.pythonhosted.org/packages/15/4b/481f1fed30e0e9e8dd24aecbb49f29eb57fe7657ece5cf06ee9b84bb97d8/sqlalchemy-2.0.51-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0c2c62877097e1a0db401fba5cb4debee33265e5b2a55c4ccb489c02c53b4f72", size = 3535844, upload-time = "2026-06-15T16:02:43.973Z" },- { url = "https://files.pythonhosted.org/packages/02/71/0aa64aeda645510af0a43f7d9ee70932f0d1dc4263aed34c50ee891d9df3/sqlalchemy-2.0.51-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0378d055e9e8cd6ce4d8dff683bdd3d7d413533c4ee51d67a2b1e0f9eacc0f23", size = 3475355, upload-time = "2026-06-15T15:58:36.592Z" },- { url = "https://files.pythonhosted.org/packages/05/db/6061db32316446135a3abae5f308d144ab988a34234726042da3e58b1c63/sqlalchemy-2.0.51-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6e46fc36029eff666391e0531e5387b62ce6c4f1d8e50b3fb3099eaca1b42522", size = 3486591, upload-time = "2026-06-15T16:02:45.346Z" },- { url = "https://files.pythonhosted.org/packages/0d/c9/f14fdf71bb8957e0c7e39db69bbdf12b5c80f4ef775fdfa127bf4e0d6760/sqlalchemy-2.0.51-cp314-cp314t-win32.whl", hash = "sha256:9161cfc9efce70d1715f47d6ff40f79c6778c00d53be4fbc09d70301e4b83ba7", size = 2151313, upload-time = "2026-06-15T16:03:39.127Z" },- { url = "https://files.pythonhosted.org/packages/6a/c6/673e618e6f4f297e126d9b56ea2f6478708f6c1af4e3223835c22e2c3697/sqlalchemy-2.0.51-cp314-cp314t-win_amd64.whl", hash = "sha256:159bb6ba32059f57ad7375a8f50d844dd2f19d14954ecf820cd33e20debd46b2", size = 2186280, upload-time = "2026-06-15T16:03:40.569Z" },- { url = "https://files.pythonhosted.org/packages/e2/22/dbf013a12ec759e54a34a119e9e217435b3f71b2dd5c61a7ade0a25dae87/sqlalchemy-2.0.51-py3-none-any.whl", hash = "sha256:bb024d8b621d0be75f4f44ecc7c950450026e76d66dc8f791bb5331d7fed59d5", size = 1944334, upload-time = "2026-06-15T16:09:22.418Z" },-]-[[package]]name = "sse-starlette"version = "3.4.1"@@ -4002,15 +3012,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/96/7c/a81ef5ef10978dd073a854e0fa93b5d8021d0594b639cc8f6453c3c78a1d/strictyaml-1.7.3-py3-none-any.whl", hash = "sha256:fb5c8a4edb43bebb765959e420f9b3978d7f1af88c80606c03fb420888f5d1c7", size = 123917, upload-time = "2023-03-10T12:50:17.242Z" },]-[[package]]-name = "structlog"-version = "26.1.0"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/5e/89/b4a0bcfdf4f71a3dea31379f095929613d7e4528a0996bca6aa964cd0dca/structlog-26.1.0.tar.gz", hash = "sha256:f63a716cbd1b1291cf7661de7794b455acfa4c43c5bcf1630e6ad5ddc1adb3b7", size = 1459881, upload-time = "2026-06-06T07:33:39.348Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/a9/18/489c97b834dfff9cf2fc2507cede4bcd4b11e67f84bc462acd1992496f86/structlog-26.1.0-py3-none-any.whl", hash = "sha256:e081a26d6c373e6d201eca24eede26d8ffab07f88f477822e679183428d3d91e", size = 73764, upload-time = "2026-06-06T07:33:38.046Z" },-]-[[package]]name = "supabase"version = "2.30.0"@@ -4270,15 +3271,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/e4/16/c1fd27e9549f3c4baf1dc9c20c456cd2f822dbf8de9f463824b0c0357e06/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6cde23eeda1a25c75b2e07d39970f3374105d5eafbaab2a4482be82f272d5a5e", size = 4296730, upload-time = "2025-10-16T22:17:00.744Z" },]-[[package]]-name = "validators"-version = "0.35.0"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/53/66/a435d9ae49850b2f071f7ebd8119dd4e84872b01630d6736761e6e7fd847/validators-0.35.0.tar.gz", hash = "sha256:992d6c48a4e77c81f1b4daba10d16c3a9bb0dbb79b3a19ea847ff0928e70497a", size = 73399, upload-time = "2025-05-01T05:42:06.7Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/fa/6e/3e955517e22cbdd565f2f8b2e73d52528b14b8bcfdb04f62466b071de847/validators-0.35.0-py3-none-any.whl", hash = "sha256:e8c947097eae7892cb3d26868d637f79f47b4a0554bc6b80065dfe5aac3705dd", size = 44712, upload-time = "2025-05-01T05:42:04.203Z" },-]-[[package]]name = "watchdog"version = "4.0.2"@@ -4382,15 +3374,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/41/52/e465037f5375f43533d1a80b6923955201596a99142ed524d77b571a1418/wcwidth-0.7.0-py3-none-any.whl", hash = "sha256:5d69154c429a82910e241c738cd0e2976fac8a2dd47a1a805f4afed1c0f136f2", size = 110825, upload-time = "2026-05-02T16:04:11.033Z" },]-[[package]]-name = "websocket-client"-version = "1.9.0"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/2c/41/aa4bf9664e4cda14c3b39865b12251e8e7d239f4cd0e3cc1b6c2ccde25c1/websocket_client-1.9.0.tar.gz", hash = "sha256:9e813624b6eb619999a97dc7958469217c3176312b3a16a4bd1bc7e08a46ec98", size = 70576, upload-time = "2025-10-07T21:16:36.495Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/34/db/b10e48aa8fff7407e67470363eac595018441cf32d5e1001567a7aeba5d2/websocket_client-1.9.0-py3-none-any.whl", hash = "sha256:af248a825037ef591efbf6ed20cc5faa03d3b47b9e5a2230a529eeee1c1fc3ef", size = 82616, upload-time = "2025-10-07T21:16:34.951Z" },-]-[[package]]name = "websockets"version = "15.0.1"