Skip to content

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.md
index 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 Style
diff --git a/INSTALLATION.md b/INSTALLATION.md
index 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 Combinations
diff --git a/crates/switchyard-components/src/intake.rs b/crates/switchyard-components/src/intake.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
index 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.rs
deleted file mode 100644
index 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.rs
index 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.rs
deleted file mode 100644
index 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.rs
index 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.rs
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
deleted file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.lock
index 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.toml
index 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 optional
diff --git a/switchyard/__init__.py b/switchyard/__init__.py
index 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 IntakeResponseProcessor
from switchyard.lib.processors.rl_logging_request_processor import RlLoggingRequestProcessor
from switchyard.lib.processors.rl_logging_response_processor import RlLoggingResponseProcessor
from switchyard.lib.profiles import (
@@ -71,6 +65,7 @@ from switchyard.lib.profiles import (
profile_config,
profile_config_type,
)
+from switchyard.lib.request_metadata import RequestMetadata
from 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 case
diff --git a/switchyard/cli/intake_cli_config.py b/switchyard/cli/intake_cli_config.py
deleted file mode 100644
index 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.py
index 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) is
call-site runtime state, not bundle data. ``serve`` and launchers may pass
processors through the table builder, but route YAML never declares
those 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`` are
call-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.py
index cd82216b5..05e7dacce 100644
--- a/switchyard/cli/switchyard_cli.py
+++ b/switchyard/cli/switchyard_cli.py
@@ -9,24 +9,17 @@ from __future__ import annotations
import argparse
import logging
import os
-from collections.abc import Sequence
from importlib.metadata import PackageNotFoundError, version
-from inspect import signature
-from typing import Any
from switchyard.cli.command_utils import (
quiet_dependency_loggers as _quiet_dependency_loggers,
)
-from switchyard.cli.intake_cli_config import IntakeCliConfig
from 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 IntakeResponseProcessor
from switchyard.lib.processors.rl_logging_response_processor import build_rl_logging_processors
from 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__.py
deleted file mode 100644
index 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.py
deleted file mode 100644
index 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__.py
index 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.py
deleted file mode 100644
index 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.py
deleted file mode 100644
index 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.py
deleted file mode 100644
index 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.py
deleted file mode 100644
index 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.py
index 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.py
index 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.py
index 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.py
index 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.py
index 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 dataclass
from typing import Any
from switchyard.lib.proxy_context import CTX_CALLER_API_KEY
-from switchyard_rust.components import IntakeRequestMetadata, RequestMetadata
CTX_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] = metadata
if 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 None
def 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__.py
index 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 AnthropicNativeBackend
from switchyard_rust.components import BackendFormat as BackendFormat
from 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 IntakeSinkConfig
from switchyard_rust.components import LlmTarget as LlmTarget
from switchyard_rust.components import LlmTargetBackend as LlmTargetBackend
from 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 RequestMetadata
from switchyard_rust.components import StatsAccumulator as StatsAccumulator
from switchyard_rust.components import StatsLlmBackend as StatsLlmBackend
from 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.py
index 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.pyi
index 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.py
index 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.py
index 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: F401
diff --git a/tests/test_intake_cli_flags.py b/tests/test_intake_cli_flags.py
deleted file mode 100644
index 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.py
deleted file mode 100644
index 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.py
deleted file mode 100644
index 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 True
diff --git a/tests/test_llm_classifier_request_processor.py b/tests/test_llm_classifier_request_processor.py
index 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.py
index 76a9dd44b..285544b78 100644
--- a/tests/test_request_metadata.py
+++ b/tests/test_request_metadata.py
@@ -10,12 +10,12 @@ import pytest
from switchyard.lib.proxy_context import CTX_CALLER_API_KEY, ProxyContext
from 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 RequestMetadata
class 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.py
index 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) -> No
args = 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.py
index 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.py
index 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_metadata
from switchyard_rust.core import ChatResponse, ProxyContext
TASK_HEADERS = {
diff --git a/tests/test_stage_router_classifier.py b/tests/test_stage_router_classifier.py
index 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 json
from dataclasses import dataclass
-from types import SimpleNamespace
from typing import Any
from 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_prompt
assert "msg-0" not in user_prompt
assert "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.py
index 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() -> None
anthropic_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.py
deleted file mode 100644
index 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.lock
index 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"