dwctl 8.38.2

The Doubleword Control Layer - A self-hostable observability and analytics platform for LLM applications
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227

//! API request/response models for file management.

use crate::api::models::Pagination;

use super::pagination::CursorPagination;
use serde::{Deserialize, Serialize};
use utoipa::{IntoParams, ToSchema};

/// Query parameters for listing files (OpenAI-compatible cursor-based pagination)
#[derive(Debug, Deserialize, IntoParams, ToSchema)]
pub struct ListFilesQuery {
    /// Pagination parameters
    #[serde(flatten)]
    #[param(inline)]
    pub pagination: CursorPagination,

    /// Sort order by created_at (asc or desc, default desc)
    #[serde(default = "default_order")]
    pub order: String,

    /// Only return files with the given purpose
    pub purpose: Option<String>,

    /// Search query to filter files by filename (case-insensitive substring match)
    pub search: Option<String>,

    /// If true, only return files uploaded by the current user (even if the user has ReadAll permission)
    #[serde(default)]
    pub own: bool,

    /// Filter by member user ID (resolves to api_key_id). Available in org context for any member, or in personal context for platform managers.
    pub member_id: Option<uuid::Uuid>,
}

fn default_order() -> String {
    "desc".to_string()
}

/// Query parameters for file content
#[derive(Debug, Deserialize, IntoParams, ToSchema)]
pub struct FileContentQuery {
    /// Pagination parameters
    #[serde(flatten)]
    #[param(inline)]
    pub pagination: Pagination,

    /// Search query to filter by custom_id (case-insensitive substring match)
    pub search: Option<String>,
}

/// Query parameters for file cost estimate
#[derive(Debug, Deserialize, IntoParams, ToSchema)]
pub struct FileCostEstimateQuery {
    /// Completion window (priority) for batch processing (e.g., "24h", "1h", "48h")
    /// If not provided, defaults to "24h"
    pub completion_window: Option<String>,
}

/// File object response (OpenAI-compatible)
#[derive(Debug, Serialize, Deserialize, ToSchema)]
#[schema(example = json!({
    "id": "file-abc123",
    "object": "file",
    "bytes": 12045,
    "created_at": 1703187200,
    "filename": "batch_requests.jsonl",
    "purpose": "batch"
}))]
pub struct FileResponse {
    #[schema(example = "file-abc123")]
    pub id: String,
    #[serde(rename = "object")]
    pub object_type: ObjectType,
    #[schema(example = 12045)]
    pub bytes: i64,
    #[schema(example = 1703187200)]
    pub created_at: i64, // Unix timestamp
    #[schema(example = "batch_requests.jsonl")]
    pub filename: String,
    pub purpose: Purpose,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub expires_at: Option<i64>, // Unix timestamp

    /// Email of the individual who created this file (resolved from api_key attribution)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_by_email: Option<String>,

    /// Context name: "Personal" for individual files, or the organization name
    #[serde(skip_serializing_if = "Option::is_none")]
    pub context_name: Option<String>,

    /// Context type: "personal" or "organization"
    #[serde(skip_serializing_if = "Option::is_none")]
    pub context_type: Option<String>,

    /// Source: "sync" if ingested from an external connection, absent for uploaded files
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source: Option<String>,

    /// Name of the source connection (e.g. "prod-s3-inputs")
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_name: Option<String>,
}

/// Object type - always "file"
#[derive(Debug, Serialize, Deserialize, ToSchema)]
#[serde(rename_all = "lowercase")]
pub enum ObjectType {
    File,
}

/// Purpose for file
#[derive(Debug, Serialize, Deserialize, ToSchema, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum Purpose {
    Batch,
    BatchOutput,
    BatchError,
}

/// Response for file deletion
#[derive(Debug, Serialize, Deserialize, ToSchema)]
#[schema(example = json!({
    "id": "file-abc123",
    "object": "file",
    "deleted": true
}))]
pub struct FileDeleteResponse {
    #[schema(example = "file-abc123")]
    pub id: String,
    #[serde(rename = "object")]
    pub object_type: ObjectType,
    #[schema(example = true)]
    pub deleted: bool,
}

/// Response for file list
#[derive(Debug, Serialize, Deserialize, ToSchema)]
#[schema(example = json!({
    "object": "list",
    "data": [{
        "id": "file-abc123",
        "object": "file",
        "bytes": 12045,
        "created_at": 1703187200,
        "filename": "batch_requests.jsonl",
        "purpose": "batch"
    }],
    "first_id": "file-abc123",
    "last_id": "file-abc123",
    "has_more": false
}))]
pub struct FileListResponse {
    #[serde(rename = "object")]
    pub object_type: ListObject,
    pub data: Vec<FileResponse>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[schema(example = "file-abc123")]
    pub first_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[schema(example = "file-abc123")]
    pub last_id: Option<String>,
    #[schema(example = false)]
    pub has_more: bool,
}

/// Object type for lists - always "list"
#[derive(Debug, Serialize, Deserialize, ToSchema)]
#[serde(rename_all = "lowercase")]
pub enum ListObject {
    List,
}

/// Per-model cost breakdown
#[derive(Debug, Serialize, Deserialize, ToSchema)]
#[schema(example = json!({
    "model": "Qwen/Qwen3-30B-A3B-FP8",
    "request_count": 100,
    "estimated_input_tokens": 50000,
    "estimated_output_tokens": 25000,
    "estimated_cost": "0.75"
}))]
pub struct ModelCostBreakdown {
    #[schema(example = "Qwen/Qwen3-30B-A3B-FP8")]
    pub model: String,
    #[schema(example = 100)]
    pub request_count: i64,
    #[schema(example = 50000)]
    pub estimated_input_tokens: i64,
    #[schema(example = 25000)]
    pub estimated_output_tokens: i64,
    /// Cost as string to preserve decimal precision
    #[schema(example = "0.75")]
    pub estimated_cost: String,
}

/// Response for file cost estimation
#[derive(Debug, Serialize, Deserialize, ToSchema)]
#[schema(example = json!({
    "file_id": "file-abc123",
    "total_requests": 100,
    "total_estimated_input_tokens": 50000,
    "total_estimated_output_tokens": 25000,
    "total_estimated_cost": "0.75",
    "models": [{
        "model": "Qwen/Qwen3-30B-A3B-FP8",
        "request_count": 100,
        "estimated_input_tokens": 50000,
        "estimated_output_tokens": 25000,
        "estimated_cost": "0.75"
    }]
}))]
pub struct FileCostEstimate {
    #[schema(example = "file-abc123")]
    pub file_id: String,
    #[schema(example = 100)]
    pub total_requests: i64,
    #[schema(example = 50000)]
    pub total_estimated_input_tokens: i64,
    #[schema(example = 25000)]
    pub total_estimated_output_tokens: i64,
    /// Total cost as string to preserve decimal precision
    #[schema(example = "0.75")]
    pub total_estimated_cost: String,
    /// Per-model breakdown
    pub models: Vec<ModelCostBreakdown>,
}