@fastino-ai/pioneer-cli 0.2.10 → 0.3.0

package/src/api.ts

@@ -1,3187 +0,0 @@
-/**
- * Felix API client for Pioneer CLI.
- * Calls the real /felix/* endpoints.
- */
-
-import { getApiKey, getBaseUrl } from "./config.js";
-
-export interface ApiResult<T = unknown> {
-  ok: boolean;
-  status: number;
-  data?: T;
-  error?: string;
-}
-
-/**
- * Format authentication error with helpful fix instructions.
- */
-function formatAuthError(originalError?: string): string {
-  return [
-    "Authentication failed. Please login to Pioneer:",
-    "",
-    "  pioneer auth login",
-    "",
-    "Don't have an account? Sign up at https://agent.pioneer.ai/",
-    originalError ? `\nDetails: ${originalError}` : "",
-  ]
-    .filter(Boolean)
-    .join("\n");
-}
-
-/**
- * Check if error is authentication-related.
- */
-function isAuthError(status: number, errorText: string): boolean {
-  return (
-    status === 401 ||
-    status === 403 ||
-    errorText.toLowerCase().includes("authentication") ||
-    errorText.toLowerCase().includes("api key") ||
-    errorText.toLowerCase().includes("unauthorized")
-  );
-}
-
-function extractErrorMessage(payload: unknown): string | undefined {
-  if (!payload) return undefined;
-  if (typeof payload === "string") return payload;
-
-  if (Array.isArray(payload)) {
-    const parts = payload
-      .map((item) => extractErrorMessage(item))
-      .filter((item): item is string => Boolean(item && item.trim()));
-    return parts.length > 0 ? parts.join("; ") : undefined;
-  }
-
-  if (typeof payload === "object") {
-    const record = payload as Record<string, unknown>;
-
-    if (typeof record.detail === "string") return record.detail;
-    if (record.detail !== undefined) {
-      const detailMessage = extractErrorMessage(record.detail);
-      if (detailMessage) return detailMessage;
-    }
-
-    if (typeof record.message === "string") return record.message;
-    if (typeof record.error === "string") return record.error;
-    if (typeof record.msg === "string") return record.msg;
-
-    if (Array.isArray(record.loc) && typeof record.msg === "string") {
-      return `${record.loc.join(".")}: ${record.msg}`;
-    }
-  }
-
-  return undefined;
-}
-
-async function request<T = unknown>(
-  method: string,
-  path: string,
-  body?: unknown
-): Promise<ApiResult<T>> {
-  const baseUrl = getBaseUrl().replace(/\/$/, "");
-  const apiKey = getApiKey();
-  const url = `${baseUrl}${path}`;
-
-  const headers: Record<string, string> = {
-    "Content-Type": "application/json",
-    "User-Agent": "pioneer-cli/0.1.0",
-  };
-
-  if (apiKey) {
-    headers["X-API-Key"] = apiKey;
-  }
-
-  try {
-    const res = await fetch(url, {
-      method,
-      headers,
-      body: body ? JSON.stringify(body) : undefined,
-    });
-
-    const text = await res.text();
-    let data: T | undefined;
-    try {
-      data = JSON.parse(text) as T;
-    } catch {
-      // Not JSON
-    }
-
-    if (!res.ok) {
-      const rawError = data ? JSON.stringify(data) : text || `HTTP ${res.status}`;
-      const extractedError = extractErrorMessage(data) || text || `HTTP ${res.status}`;
-
-      // Format authentication errors with helpful instructions
-      if (isAuthError(res.status, rawError)) {
-        return {
-          ok: false,
-          status: res.status,
-          error: formatAuthError(extractedError),
-        };
-      }
-
-      return {
-        ok: false,
-        status: res.status,
-        error: extractedError,
-      };
-    }
-
-    return { ok: true, status: res.status, data };
-  } catch (err) {
-    return {
-      ok: false,
-      status: 0,
-      error: err instanceof Error ? err.message : String(err),
-    };
-  }
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Common Types
-// ─────────────────────────────────────────────────────────────────────────────
-
-export interface DatasetRef {
-  name: string;
-  version: string;
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Auth - validate API key by calling /felix/datasets
-// ─────────────────────────────────────────────────────────────────────────────
-
-export async function validateApiKey(apiKey: string): Promise<ApiResult> {
-  const baseUrl = getBaseUrl().replace(/\/$/, "");
-  const url = `${baseUrl}/felix/datasets`;
-
-  try {
-    const res = await fetch(url, {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-        "User-Agent": "pioneer-cli/0.1.0",
-        "X-API-Key": apiKey,
-      },
-    });
-
-    if (res.ok) {
-      return { ok: true, status: res.status };
-    }
-
-    if (res.status === 401 || res.status === 403) {
-      return { ok: false, status: res.status, error: "Invalid API key" };
-    }
-
-    const text = await res.text();
-    return { ok: false, status: res.status, error: text || `HTTP ${res.status}` };
-  } catch (err) {
-    return {
-      ok: false,
-      status: 0,
-      error: err instanceof Error ? err.message : String(err),
-    };
-  }
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Datasets
-// ─────────────────────────────────────────────────────────────────────────────
-
-export interface Dataset {
-  id: string;
-  user_id: string;
-  dataset_name: string;
-  dataset_path: string;
-  dataset_type: string;
-  size?: number;
-  sample_size?: number;
-  train_ratio?: number;
-  version_number?: string;
-  root_dataset_id?: string;
-  project_id?: string;
-  schema?: Record<string, unknown>;
-  schema_warnings?: string[];
-  validation?: Record<string, unknown>;
-  annotation_status?: "none" | "in_progress" | "completed";
-  annotation_config?: Record<string, unknown>;
-  annotation_progress?: Record<string, unknown>;
-  status?: "initialized" | "uploading" | "converting" | "validating" | "ready" | "failed" | "generating" | "queued";
-  processing_error?: string;
-  type?: "training" | "evaluation" | "benchmark";
-  visibility?: "private" | "public";
-  is_competition?: boolean;
-  labels?: string[];
-  generation_type?: string;
-  is_seed?: boolean;
-  synthesis_session_id?: string;
-  column_mapping?: Record<string, string>;
-  created_at: string;
-  updated_at?: string;
-}
-
-export interface DatasetListResponse {
-  success: boolean;
-  datasets: Dataset[];
-  count: number;
-}
-
-export async function listDatasets(
-  options: { includeAllVersions?: boolean } = {}
-): Promise<ApiResult<DatasetListResponse>> {
-  const params = new URLSearchParams();
-  if (options.includeAllVersions) {
-    params.set("include_all_versions", "true");
-  }
-  const query = params.toString();
-  const url = query ? `/felix/datasets?${query}` : "/felix/datasets";
-  return request<DatasetListResponse>("GET", url);
-}
-
-export async function getDataset(dataset: DatasetRef): Promise<ApiResult<Dataset>> {
-  return request<Dataset>("GET", `/felix/datasets/${dataset.name}/${dataset.version}`);
-}
-
-export interface UploadUrlRequest {
-  dataset_name: string;
-  dataset_type?: "classification" | "ner" | "custom" | "decoder";
-  format?: "jsonl" | "csv" | "parquet";
-  content_type?: string;
-}
-
-export interface UploadUrlResponse {
-  upload_url?: string;
-  presigned_url?: string;
-  dataset_id: string;
-  key: string;
-  expires_in: number;
-}
-
-export async function getUploadUrl(
-  req: UploadUrlRequest
-): Promise<ApiResult<UploadUrlResponse>> {
-  return request<UploadUrlResponse>("POST", "/felix/datasets/upload/url", req);
-}
-
-export interface ProcessUploadRequest {
-  dataset_id: string;
-  dataset_name: string;
-  dataset_type?: "classification" | "ner" | "custom" | "decoder";
-  format?: "jsonl" | "csv" | "parquet";
-  schema?: Record<string, string>;
-  project_id?: string;
-}
-
-export async function processUpload(
-  req: ProcessUploadRequest
-): Promise<ApiResult<Dataset>> {
-  return request<Dataset>("POST", "/felix/datasets/upload/process", req);
-}
-
-export async function deleteDataset(dataset: DatasetRef): Promise<ApiResult> {
-  return request("DELETE", `/felix/datasets/${dataset.name}/${dataset.version}`);
-}
-
-export async function deleteAllDatasetVersions(name: string): Promise<ApiResult> {
-  return request("DELETE", `/felix/datasets/${name}`);
-}
-
-export interface DatasetVersionsResponse {
-  success: boolean;
-  versions: Dataset[];
-  count: number;
-}
-
-export async function listDatasetVersions(
-  name: string
-): Promise<ApiResult<DatasetVersionsResponse>> {
-  return request<DatasetVersionsResponse>("GET", `/felix/datasets/${name}`);
-}
-
-export interface DatasetMetadataUpdate {
-  dataset_name?: string;
-  dataset_type?: "ner" | "classification" | "custom" | "decoder";
-  project_id?: string;
-}
-
-export async function updateDatasetMetadata(
-  dataset: DatasetRef,
-  update: DatasetMetadataUpdate
-): Promise<ApiResult<Dataset>> {
-  return request<Dataset>(
-    "PUT",
-    `/felix/datasets/${dataset.name}/${dataset.version}`,
-    update
-  );
-}
-
-export async function previewDataset(
-  dataset: DatasetRef,
-  options: { limit?: number; offset?: number } = {}
-): Promise<ApiResult<Record<string, unknown>>> {
-  const params = new URLSearchParams();
-  if (options.limit) params.set("limit", String(options.limit));
-  if (options.offset) params.set("offset", String(options.offset));
-  const query = params.toString();
-  const url = `/felix/datasets/${dataset.name}/${dataset.version}/preview${query ? `?${query}` : ""}`;
-  return request<Record<string, unknown>>("GET", url);
-}
-
-export interface DatasetUploadRequest {
-  dataset_name: string;
-  dataset_type?: "ner" | "classification" | "custom" | "decoder";
-  format?: "jsonl" | "csv" | "parquet";
-  schema?: Record<string, string>;
-  project_id?: string;
-}
-
-export async function uploadDataset(
-  filePath: string,
-  options: DatasetUploadRequest
-): Promise<ApiResult<Dataset>> {
-  try {
-    const fs = await import("fs");
-    const path = await import("path");
-    const fileContent = fs.readFileSync(filePath);
-    const filename = path.basename(filePath);
-
-    // Detect format from file extension if not provided
-    const ext = path.extname(filename).slice(1) as "jsonl" | "csv" | "parquet";
-    const format = options.format || ext || "jsonl";
-
-    // Step 1: Get presigned upload URL
-    const urlResult = await getUploadUrl({
-      dataset_name: options.dataset_name,
-      dataset_type: options.dataset_type,
-      format,
-      content_type: "application/octet-stream",
-    });
-
-    if (!urlResult.ok || !urlResult.data) {
-      return {
-        ok: false,
-        status: urlResult.status,
-        error: urlResult.error || "Failed to get upload URL",
-      };
-    }
-
-    const { dataset_id } = urlResult.data;
-    const uploadUrl = urlResult.data.upload_url || urlResult.data.presigned_url;
-    if (!uploadUrl) {
-      return {
-        ok: false,
-        status: 500,
-        error: "Upload URL not provided by backend",
-      };
-    }
-
-    // Step 2: Upload file directly to S3 via presigned URL
-    const uploadRes = await fetch(uploadUrl, {
-      method: "PUT",
-      headers: {
-        "Content-Type": "application/octet-stream",
-      },
-      body: fileContent,
-    });
-
-    if (!uploadRes.ok) {
-      return {
-        ok: false,
-        status: uploadRes.status,
-        error: `Failed to upload file to S3: HTTP ${uploadRes.status}`,
-      };
-    }
-
-    // Step 3: Trigger processing
-    const processResult = await processUpload({
-      dataset_id,
-      dataset_name: options.dataset_name,
-      dataset_type: options.dataset_type,
-      format,
-      schema: options.schema,
-      project_id: options.project_id,
-    });
-
-    return processResult;
-  } catch (err) {
-    return {
-      ok: false,
-      status: 0,
-      error: err instanceof Error ? err.message : String(err),
-    };
-  }
-}
-
-export interface DatasetDownloadResponse {
-  download_url: string;
-  file_path?: string;
-  size?: number;
-  dataset_name?: string;
-  version?: string;
-}
-
-export async function downloadDataset(
-  dataset: DatasetRef,
-  format: "csv" | "jsonl" | "parquet" = "jsonl",
-  outputPath?: string
-): Promise<ApiResult<DatasetDownloadResponse>> {
-  const baseUrl = getBaseUrl().replace(/\/$/, "");
-  const apiKey = getApiKey();
-  const downloadUrl = `${baseUrl}/felix/datasets/${dataset.name}/${dataset.version}/download?format=${format}`;
-
-  // Generate default filename if not specified
-  const safeDatasetName = dataset.name.replace(/[^a-zA-Z0-9-_]/g, "_");
-  if (!outputPath) {
-    outputPath = `${safeDatasetName}_${dataset.version}.${format}`;
-  }
-
-  // Download the file
-  const headers: Record<string, string> = {
-    "User-Agent": "pioneer-cli/0.1.0",
-  };
-
-  if (apiKey) {
-    headers["X-API-Key"] = apiKey;
-  }
-
-  try {
-    const res = await fetch(downloadUrl, {
-      method: "GET",
-      headers,
-    });
-
-    if (!res.ok) {
-      const text = await res.text();
-      return {
-        ok: false,
-        status: res.status,
-        error: text || `HTTP ${res.status}`,
-      };
-    }
-
-    // Write the file
-    const fs = await import("fs");
-    const path = await import("path");
-    const buffer = await res.arrayBuffer();
-    fs.writeFileSync(outputPath, Buffer.from(buffer));
-
-    // Resolve to absolute path for user feedback
-    const absolutePath = path.resolve(outputPath);
-
-    return {
-      ok: true,
-      status: 200,
-      data: {
-        download_url: downloadUrl,
-        file_path: absolutePath,
-        size: buffer.byteLength,
-        dataset_name: dataset.name,
-        version: dataset.version,
-      },
-    };
-  } catch (err) {
-    return {
-      ok: false,
-      status: 0,
-      error: err instanceof Error ? err.message : String(err),
-    };
-  }
-}
-
-export interface DatasetAnalysisRequest {
-  dataset: DatasetRef;
-  task_type: string;
-  analyses: string[];
-}
-
-// Diversity Analysis Types
-export interface DiversityPoint {
-  x?: number;
-  y?: number;
-  z?: number;
-  w?: number;
-  coordinates: number[];
-  text?: string;
-  token_count?: number;
-  labels?: string[];
-  metadata?: Record<string, unknown>;
-  sample_index?: number;
-  similarity_to_centroid?: number;
-  embedding?: number[];
-}
-
-export interface DiversityVisualization {
-  method: "pca" | "tsne";
-  dimensions: number;
-  points: DiversityPoint[];
-  tsne_perplexity?: number;
-  similarity_range?: { min: number; max: number };
-  token_count_range?: { min: number; max: number };
-}
-
-export interface DiversityLLMAnalysis {
-  reasoning_trace: string;
-  summary: string;
-  diversity_rating: "low" | "moderate" | "high" | "excellent";
-  key_observations: string[];
-  recommendations: string[];
-  model_used: string;
-}
-
-export interface DiversityAnalysis {
-  vendi_score: number;
-  sample_size: number;
-  interpretation?: string;
-  visualization?: DiversityVisualization;
-  llm_analysis?: DiversityLLMAnalysis;
-}
-
-// Distribution Analysis Types
-export interface DistributionAnalysis {
-  label_counts: Record<string, number>;
-  total_samples: number;
-  unique_labels: number;
-  most_common_label?: string;
-  least_common_label?: string;
-  imbalance_ratio?: number;
-}
-
-// Duplicates Analysis Types
-export interface DuplicatesAnalysis {
-  total_duplicates: number;
-  duplicate_groups: number;
-  duplicate_percentage: number;
-  examples?: Array<{ text: string; count: number }>;
-}
-
-// Outliers Analysis Types
-export interface OutliersAnalysis {
-  total_outliers: number;
-  outlier_percentage: number;
-  method: string;
-  threshold?: number;
-  examples?: Array<{ text: string; score: number; reason?: string }>;
-}
-
-// Splits Analysis Types
-export interface SplitsAnalysis {
-  train_size: number;
-  validation_size: number;
-  test_size?: number;
-  train_percentage: number;
-  validation_percentage: number;
-  test_percentage?: number;
-}
-
-export interface DatasetAnalysisResponse {
-  summary: Record<string, unknown>;
-  distribution?: DistributionAnalysis;
-  duplicates?: DuplicatesAnalysis;
-  outliers?: OutliersAnalysis;
-  correlations?: Record<string, unknown>;
-  splits?: SplitsAnalysis;
-  errors?: Record<string, unknown>;
-  diversity?: DiversityAnalysis;
-  natural_language_response?: string;
-}
-
-export async function analyzeDataset(
-  dataset: DatasetRef,
-  taskType: string,
-  analyses: string[]
-): Promise<ApiResult<DatasetAnalysisResponse>> {
-  return request<DatasetAnalysisResponse>("POST", "/felix/dataset/analyze", {
-    dataset_name: dataset.name,
-    dataset_version: dataset.version,
-    task_type: taskType,
-    analyses: analyses,
-  });
-}
-
-export interface DatasetLLMAnalysisRequest {
-  task_type: "ner" | "classification" | "generative";
-  task_description?: string;
-  labels?: string[];
-  dataset?: Record<string, unknown>[];
-  dataset_name?: string;
-  dataset_version?: string;
-}
-
-export async function analyzeDatasetLLM(
-  req: DatasetLLMAnalysisRequest
-): Promise<ApiResult<DiversityLLMAnalysis>> {
-  return request<DiversityLLMAnalysis>("POST", "/felix/dataset/analyze_llm", req);
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Dataset Generation
-// ─────────────────────────────────────────────────────────────────────────────
-
-export interface RecordField {
-  name: string;
-  type?: string;
-  description?: string;
-  allowed_values?: string[];
-}
-
-export interface ConstraintRequest {
-  description: string;
-  choices?: string[];
-  probability?: number;
-}
-
-export interface GenerateResponse {
-  success: boolean;
-  data: Record<string, unknown>[];
-  count: number;
-  task_type: string;
-  token_usage?: number;
-  dataset?: Record<string, unknown>;
-}
-
-export type GenerateTaskType =
-  | "ner"
-  | "classification"
-  | "custom"
-  | "decoder"
-  | "records"
-  | "fields";
-
-export interface GenerateAsyncResponse {
-  job_id: string;
-  status?: string;
-  dataset_name: string;
-  task_type: GenerateTaskType;
-  is_seed?: boolean;
-  message?: string;
-}
-
-export interface GenerateJobStatus {
-  job_id: string;
-  status: "queued" | "generating" | "ready" | "failed" | string;
-  data?: Record<string, unknown>[];
-  count?: number;
-  task_type?: string;
-  token_usage?: number;
-  dataset?: Record<string, unknown>;
-  error?: string;
-  is_seed?: boolean;
-  created_at?: string;
-}
-
-export interface GenerateRequest {
-  task_type: GenerateTaskType;
-  dataset_name: string;
-  num_examples?: number;
-  domain_description?: string;
-  temperature?: number;
-  quality?: "light" | "medium" | "heavy";
-  generation_profile?: "auto" | "fast" | "balanced" | "quality";
-  session_id?: string;
-  config_num_examples?: number;
-  seed?: number;
-  labels?: string[];
-  classified_examples?: Record<string, unknown>[];
-  multi_label?: boolean;
-  class_balance?: Record<string, number>;
-  batch_size?: number;
-  negative_ratio?: number;
-  fields?: RecordField[];
-  input_fields?: RecordField[];
-  output_fields?: RecordField[];
-  prompt?: string;
-  output_format?: Record<string, unknown>;
-  infer_output_format?: boolean;
-  instruction?: string;
-  constraints?: ConstraintRequest[];
-  multiplicator?: Record<string, unknown>;
-  include_reasoning_trace?: boolean;
-  reasoning_effort?: "low" | "medium" | "high";
-  use_meta_felix?: boolean;
-  min_criteria?: number;
-  target_choices?: number;
-  project_id?: string;
-  type?: "training" | "evaluation" | "split";
-  visibility?: "private" | "public";
-  split_ratio?: Record<string, number>;
-}
-
-const GENERATION_POLL_INTERVAL_MS = 2000;
-const GENERATION_MAX_ATTEMPTS = 300; // 10 minutes
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function makeDefaultDatasetName(taskType: GenerateTaskType): string {
-  return `${taskType}-dataset-${Date.now()}`;
-}
-
-export async function startGeneration(
-  req: GenerateRequest,
-  options: { isSeed?: boolean; synthesisSessionId?: string } = {}
-): Promise<ApiResult<GenerateAsyncResponse>> {
-  const params = new URLSearchParams();
-  if (options.isSeed) params.set("is_seed", "true");
-  if (options.synthesisSessionId) {
-    params.set("synthesis_session_id", options.synthesisSessionId);
-  }
-  const query = params.toString();
-  const url = query ? `/generate?${query}` : "/generate";
-  return request<GenerateAsyncResponse>("POST", url, req);
-}
-
-export async function getGenerationJobStatus(
-  jobId: string
-): Promise<ApiResult<GenerateJobStatus>> {
-  return request<GenerateJobStatus>("GET", `/generate/jobs/${jobId}`);
-}
-
-export async function waitForGenerationJob(
-  jobId: string,
-  options: { pollIntervalMs?: number; maxAttempts?: number } = {}
-): Promise<ApiResult<GenerateJobStatus>> {
-  const pollIntervalMs = options.pollIntervalMs ?? GENERATION_POLL_INTERVAL_MS;
-  const maxAttempts = options.maxAttempts ?? GENERATION_MAX_ATTEMPTS;
-
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    const statusResult = await getGenerationJobStatus(jobId);
-    if (!statusResult.ok || !statusResult.data) {
-      if (statusResult.status === 404 && attempt < 5) {
-        await sleep(pollIntervalMs);
-        continue;
-      }
-      return {
-        ok: false,
-        status: statusResult.status,
-        error: statusResult.error ?? "Failed to fetch generation status",
-      };
-    }
-
-    if (statusResult.data.status === "ready") {
-      return statusResult;
-    }
-
-    if (statusResult.data.status === "failed") {
-      return {
-        ok: false,
-        status: statusResult.status || 500,
-        error: statusResult.data.error ?? "Generation failed",
-      };
-    }
-
-    await sleep(pollIntervalMs);
-  }
-
-  return {
-    ok: false,
-    status: 408,
-    error: `Generation timed out for job ${jobId}. Use 'pioneer dataset get <name[:version]>' once ready.`,
-  };
-}
-
-async function generateDataset(req: GenerateRequest): Promise<ApiResult<GenerateJobStatus>> {
-  const startResult = await startGeneration(req);
-  if (!startResult.ok || !startResult.data) {
-    return {
-      ok: false,
-      status: startResult.status,
-      error: startResult.error ?? "Failed to start generation job",
-    };
-  }
-
-  return waitForGenerationJob(startResult.data.job_id);
-}
-
-export interface InferLabelsResponse {
-  success: boolean;
-  labels: string[];
-  count: number;
-}
-
-export interface InferFieldsResponse {
-  success: boolean;
-  input_fields: RecordField[];
-  output_fields: RecordField[];
-  mode: string;
-  reasoning: string;
-}
-
-// NER Generation
-export interface GenerateNERRequest {
-  labels: string[];
-  num_examples?: number;
-  domain_description?: string;
-  seed?: number;
-  session_id?: string;
-  config_num_examples?: number;
-  temperature?: number;
-  constraints?: ConstraintRequest[];
-  save_dataset?: boolean;
-  dataset_name?: string;
-  project_id?: string;
-  generation_profile?: "auto" | "fast" | "balanced" | "quality";
-  include_reasoning_trace?: boolean;
-  reasoning_effort?: "low" | "medium" | "high";
-  quality?: "light" | "medium" | "heavy";
-  type?: "training" | "evaluation" | "split";
-  visibility?: "private" | "public";
-  negative_ratio?: number;
-  split_ratio?: Record<string, number>;
-  multiplicator?: Record<string, unknown>;
-  use_meta_felix?: boolean;
-  min_criteria?: number;
-  target_choices?: number;
-  classified_examples?: Record<string, unknown>[];
-}
-
-export async function generateNER(
-  req: GenerateNERRequest
-): Promise<ApiResult<GenerateJobStatus>> {
-  return generateDataset({
-    task_type: "ner",
-    dataset_name: req.dataset_name ?? makeDefaultDatasetName("ner"),
-    labels: req.labels,
-    num_examples: req.num_examples,
-    domain_description: req.domain_description,
-    seed: req.seed,
-    session_id: req.session_id,
-    config_num_examples: req.config_num_examples,
-    temperature: req.temperature,
-    constraints: req.constraints,
-    project_id: req.project_id,
-    generation_profile: req.generation_profile,
-    include_reasoning_trace: req.include_reasoning_trace,
-    reasoning_effort: req.reasoning_effort,
-    quality: req.quality,
-    min_criteria: req.min_criteria,
-    target_choices: req.target_choices,
-    type: req.type,
-    visibility: req.visibility,
-    negative_ratio: req.negative_ratio,
-    split_ratio: req.split_ratio,
-    multiplicator: req.multiplicator,
-    use_meta_felix: req.use_meta_felix,
-    classified_examples: req.classified_examples,
-  });
-}
-
-export interface LabelExistingNERRequest {
-  labels: string[];
-  inputs: string[];
-  domain_description?: string;
-  seed?: number;
-  temperature?: number;
-  constraints?: ConstraintRequest[];
-  save_dataset?: boolean;
-  dataset_name?: string;
-  project_id?: string;
-}
-
-export async function labelExistingNER(
-  req: LabelExistingNERRequest
-): Promise<ApiResult<GenerateResponse>> {
-  return request<GenerateResponse>("POST", "/generate/ner/label-existing", req);
-}
-
-export interface InferNERLabelsRequest {
-  domain_description: string;
-}
-
-export async function inferNERLabels(
-  req: InferNERLabelsRequest
-): Promise<ApiResult<InferLabelsResponse>> {
-  return request<InferLabelsResponse>("POST", "/generate/ner/infer-labels", req);
-}
-
-// Classification Generation
-export interface GenerateClassificationRequest {
-  labels: string[];
-  num_examples?: number;
-  domain_description?: string;
-  seed?: number;
-  class_balance?: Record<string, number>;
-  session_id?: string;
-  config_num_examples?: number;
-  temperature?: number;
-  batch_size?: number;
-  constraints?: ConstraintRequest[];
-  multi_label?: boolean;
-  save_dataset?: boolean;
-  dataset_name?: string;
-  project_id?: string;
-  generation_profile?: "auto" | "fast" | "balanced" | "quality";
-  include_reasoning_trace?: boolean;
-  reasoning_effort?: "low" | "medium" | "high";
-  quality?: "light" | "medium" | "heavy";
-  min_criteria?: number;
-  target_choices?: number;
-  split_ratio?: Record<string, number>;
-  negative_ratio?: number;
-  multiplicator?: Record<string, unknown>;
-  use_meta_felix?: boolean;
-  type?: "training" | "evaluation" | "split";
-  visibility?: "private" | "public";
-}
-
-export async function generateClassification(
-  req: GenerateClassificationRequest
-): Promise<ApiResult<GenerateJobStatus>> {
-  return generateDataset({
-    task_type: "classification",
-    dataset_name: req.dataset_name ?? makeDefaultDatasetName("classification"),
-    labels: req.labels,
-    num_examples: req.num_examples,
-    domain_description: req.domain_description,
-    seed: req.seed,
-    class_balance: req.class_balance,
-    session_id: req.session_id,
-    config_num_examples: req.config_num_examples,
-    temperature: req.temperature,
-    batch_size: req.batch_size,
-    constraints: req.constraints,
-    multi_label: req.multi_label,
-    project_id: req.project_id,
-    generation_profile: req.generation_profile,
-    include_reasoning_trace: req.include_reasoning_trace,
-    reasoning_effort: req.reasoning_effort,
-    quality: req.quality,
-    min_criteria: req.min_criteria,
-    target_choices: req.target_choices,
-    split_ratio: req.split_ratio,
-    multiplicator: req.multiplicator,
-    use_meta_felix: req.use_meta_felix,
-    type: req.type,
-    visibility: req.visibility,
-    negative_ratio: req.negative_ratio,
-  });
-}
-
-export interface LabelExistingClassificationRequest {
-  labels: string[];
-  inputs: string[];
-  domain_description?: string;
-  seed?: number;
-  class_balance?: Record<string, number>;
-  temperature?: number;
-  batch_size?: number;
-  constraints?: ConstraintRequest[];
-  multi_label?: boolean;
-  save_dataset?: boolean;
-  dataset_name?: string;
-  project_id?: string;
-}
-
-export async function labelExistingClassification(
-  req: LabelExistingClassificationRequest
-): Promise<ApiResult<GenerateResponse>> {
-  return request<GenerateResponse>("POST", "/generate/classification/label-existing", req);
-}
-
-export interface InferClassificationLabelsRequest {
-  domain_description: string;
-}
-
-export async function inferClassificationLabels(
-  req: InferClassificationLabelsRequest
-): Promise<ApiResult<InferLabelsResponse>> {
-  return request<InferLabelsResponse>("POST", "/generate/classification/infer-labels", req);
-}
-
-// Custom Generation
-export interface GenerateCustomRequest {
-  prompt: string;
-  output_format?: Record<string, unknown>;
-  infer_output_format?: boolean;
-  num_examples?: number;
-  seed?: number;
-  session_id?: string;
-  temperature?: number;
-  constraints?: ConstraintRequest[];
-  save_dataset?: boolean;
-  dataset_name?: string;
-  project_id?: string;
-  generation_profile?: "auto" | "fast" | "balanced" | "quality";
-  include_reasoning_trace?: boolean;
-  reasoning_effort?: "low" | "medium" | "high";
-  quality?: "light" | "medium" | "heavy";
-  min_criteria?: number;
-  target_choices?: number;
-  split_ratio?: Record<string, number>;
-  negative_ratio?: number;
-  multiplicator?: Record<string, unknown>;
-  use_meta_felix?: boolean;
-  type?: "training" | "evaluation" | "split";
-  visibility?: "private" | "public";
-}
-
-export async function generateCustom(
-  req: GenerateCustomRequest
-): Promise<ApiResult<GenerateJobStatus>> {
-  return generateDataset({
-    task_type: "custom",
-    dataset_name: req.dataset_name ?? makeDefaultDatasetName("custom"),
-    prompt: req.prompt,
-    output_format: req.output_format,
-    infer_output_format: req.infer_output_format,
-    num_examples: req.num_examples,
-    seed: req.seed,
-    session_id: req.session_id,
-    min_criteria: req.min_criteria,
-    temperature: req.temperature,
-    constraints: req.constraints,
-    project_id: req.project_id,
-    generation_profile: req.generation_profile,
-    include_reasoning_trace: req.include_reasoning_trace,
-    reasoning_effort: req.reasoning_effort,
-    target_choices: req.target_choices,
-    quality: req.quality,
-    split_ratio: req.split_ratio,
-    negative_ratio: req.negative_ratio,
-    multiplicator: req.multiplicator,
-    use_meta_felix: req.use_meta_felix,
-    type: req.type,
-    visibility: req.visibility,
-  });
-}
-
-// Records Generation
-export interface GenerateRecordsRequest {
-  fields: RecordField[];
-  dataset_name?: string;
-  num_examples?: number;
-  domain_description?: string;
-  seed?: number;
-  temperature?: number;
-  constraints?: ConstraintRequest[];
-  quality?: "light" | "medium" | "heavy";
-  generation_profile?: "auto" | "fast" | "balanced" | "quality";
-  include_reasoning_trace?: boolean;
-  reasoning_effort?: "low" | "medium" | "high";
-  min_criteria?: number;
-  target_choices?: number;
-  split_ratio?: Record<string, number>;
-  negative_ratio?: number;
-  multiplicator?: Record<string, unknown>;
-  project_id?: string;
-  use_meta_felix?: boolean;
-  type?: "training" | "evaluation" | "split";
-  visibility?: "private" | "public";
-  classified_examples?: Record<string, unknown>[];
-}
-
-export async function generateRecords(
-  req: GenerateRecordsRequest
-): Promise<ApiResult<GenerateJobStatus>> {
-  return generateDataset({
-    task_type: "records",
-    dataset_name: req.dataset_name ?? makeDefaultDatasetName("records"),
-    fields: req.fields,
-    num_examples: req.num_examples,
-    domain_description: req.domain_description,
-    seed: req.seed,
-    temperature: req.temperature,
-    constraints: req.constraints,
-    project_id: req.project_id,
-    generation_profile: req.generation_profile,
-    include_reasoning_trace: req.include_reasoning_trace,
-    reasoning_effort: req.reasoning_effort,
-    quality: req.quality,
-    min_criteria: req.min_criteria,
-    target_choices: req.target_choices,
-    split_ratio: req.split_ratio,
-    negative_ratio: req.negative_ratio,
-    multiplicator: req.multiplicator,
-    use_meta_felix: req.use_meta_felix,
-    type: req.type,
-    visibility: req.visibility,
-    classified_examples: req.classified_examples,
-  });
-}
-
-// Fields Generation
-export interface GenerateFieldsRequest {
-  input_fields: RecordField[];
-  output_fields: RecordField[];
-  dataset_name?: string;
-  num_examples?: number;
-  domain_description?: string;
-  seed?: number;
-  temperature?: number;
-  constraints?: ConstraintRequest[];
-  save_dataset?: boolean;
-  quality?: "light" | "medium" | "heavy";
-  generation_profile?: "auto" | "fast" | "balanced" | "quality";
-  include_reasoning_trace?: boolean;
-  reasoning_effort?: "low" | "medium" | "high";
-  min_criteria?: number;
-  target_choices?: number;
-  split_ratio?: Record<string, number>;
-  negative_ratio?: number;
-  multiplicator?: Record<string, unknown>;
-  project_id?: string;
-  use_meta_felix?: boolean;
-  type?: "training" | "evaluation" | "split";
-  visibility?: "private" | "public";
-  classified_examples?: Record<string, unknown>[];
-}
-
-export async function generateFields(
-  req: GenerateFieldsRequest
-): Promise<ApiResult<GenerateJobStatus>> {
-  return generateDataset({
-    task_type: "fields",
-    dataset_name: req.dataset_name ?? makeDefaultDatasetName("fields"),
-    input_fields: req.input_fields,
-    output_fields: req.output_fields,
-    num_examples: req.num_examples,
-    domain_description: req.domain_description,
-    seed: req.seed,
-    temperature: req.temperature,
-    constraints: req.constraints,
-    project_id: req.project_id,
-    generation_profile: req.generation_profile,
-    include_reasoning_trace: req.include_reasoning_trace,
-    reasoning_effort: req.reasoning_effort,
-    quality: req.quality,
-    min_criteria: req.min_criteria,
-    target_choices: req.target_choices,
-    split_ratio: req.split_ratio,
-    negative_ratio: req.negative_ratio,
-    multiplicator: req.multiplicator,
-    use_meta_felix: req.use_meta_felix,
-    type: req.type,
-    visibility: req.visibility,
-    classified_examples: req.classified_examples,
-  });
-}
-
-export interface LabelExistingFieldsRequest {
-  input_fields: RecordField[];
-  output_fields: RecordField[];
-  inputs: Record<string, unknown>[];
-  domain_description?: string;
-  seed?: number;
-  temperature?: number;
-  constraints?: ConstraintRequest[];
-  save_dataset?: boolean;
-  dataset_name?: string;
-  project_id?: string;
-}
-
-export async function labelExistingFields(
-  req: LabelExistingFieldsRequest
-): Promise<ApiResult<GenerateResponse>> {
-  return request<GenerateResponse>("POST", "/generate/fields/label-existing", req);
-}
-
-export interface InferFieldsRequest {
-  domain_description: string;
-}
-
-export async function inferFields(
-  req: InferFieldsRequest
-): Promise<ApiResult<InferFieldsResponse>> {
-  return request<InferFieldsResponse>("POST", "/generate/fields/infer-fields", req);
-}
-
-export interface ImprovePromptRequest {
-  prompt: string;
-  data_type?: string;
-}
-
-export interface ImprovePromptResponse {
-  success: boolean;
-  improved_prompt: string;
-  summary: string;
-}
-
-export async function improvePrompt(
-  req: ImprovePromptRequest
-): Promise<ApiResult<ImprovePromptResponse>> {
-  return request<ImprovePromptResponse>("POST", "/generate/improve-prompt", req);
-}
-
-export interface InferAdvancedRequest {
-  prompt: string;
-  data_type?: string;
-  labels?: string[];
-}
-
-export interface InferredConstraint {
-  description: string;
-  choices?: string[];
-  probability?: number;
-}
-
-export interface InferredMultiplicator {
-  prompt: string;
-  choices: string[];
-}
-
-export interface InferAdvancedResponse {
-  success: boolean;
-  constraints: InferredConstraint[];
-  multiplicator?: InferredMultiplicator;
-}
-
-export async function inferAdvanced(
-  req: InferAdvancedRequest
-): Promise<ApiResult<InferAdvancedResponse>> {
-  return request<InferAdvancedResponse>("POST", "/generate/infer-advanced", req);
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Training Jobs
-// ─────────────────────────────────────────────────────────────────────────────
-
-export interface TrainingJob {
-  id: string;
-  user_id: string;
-  project_id?: string;
-  model_name?: string;
-  datasets: Array<{ name: string; version?: string }>;
-  base_model: string;
-  validation_data_percentage: number;
-  nr_epochs: number;
-  learning_rate: number;
-  batch_size: number;
-  trained_model_path?: string;
-  job_reference?: string;
-  instance_type?: string;
-  status: string;
-  error_message?: string;
-  created_at: string;
-  updated_at: string;
-  started_at?: string;
-  completed_at?: string;
-  model_auto_selected?: boolean;
-  model_selection_reason?: string;
-  task_type?: string;
-  labels?: string[];
-  example?: string;
-  deployment_status?: string;
-  metrics?: Record<string, unknown>;
-  version_number?: string;
-  root_job_id?: string;
-}
-
-export interface TrainingJobListResponse {
-  success: boolean;
-  training_jobs: TrainingJob[];
-  count: number;
-}
-
-export async function listJobs(
-  options: { status?: string; project_id?: string; limit?: number } = {}
-): Promise<ApiResult<TrainingJobListResponse>> {
-  const params = new URLSearchParams();
-  if (options.status) params.set("status", options.status);
-  if (options.project_id) params.set("project_id", options.project_id);
-  if (options.limit !== undefined) params.set("limit", String(options.limit));
-  const query = params.toString();
-  const url = query ? `/felix/training-jobs?${query}` : "/felix/training-jobs";
-  return request<TrainingJobListResponse>("GET", url);
-}
-
-export async function getJob(jobId: string): Promise<ApiResult<TrainingJob>> {
-  return request<TrainingJob>("GET", `/felix/training-jobs/${jobId}`);
-}
-
-/**
- * Assign (or unassign) a training job to a project. The deploy endpoint
- * (`POST /projects/{id}/deployments`) requires the job's `project_id` to
- * match the target project, so callers typically PATCH this before deploy.
- *
- * @param jobId Training job UUID.
- * @param projectId Project UUID to attach to, or `null` to unassign.
- */
-export async function updateTrainingJob(
-  jobId: string,
-  body: { project_id: string | null }
-): Promise<ApiResult<{ success?: boolean; message?: string }>> {
-  return request<{ success?: boolean; message?: string }>(
-    "PATCH",
-    `/felix/training-jobs/${jobId}`,
-    body
-  );
-}
-
-export interface TrainingJobCreateRequest {
-  model_name: string;
-  datasets: DatasetRef[];
-  base_model?: string;
-  auto_select_model?: boolean;
-  validation_data_percentage?: number;
-  nr_epochs?: number;
-  learning_rate?: number;
-  batch_size?: number;
-  save_steps?: number;
-  wandb_api_key?: string;
-  project_id?: string;
-  training_type?: "full" | "lora";
-  lora_r?: number;
-  lora_alpha?: number;
-  lora_dropout?: number;
-  enable_probe_override?: boolean;
-  probe_delta_threshold?: number;
-}
-
-export async function createJob(
-  req: TrainingJobCreateRequest
-): Promise<ApiResult<TrainingJob>> {
-  return request<TrainingJob>("POST", "/felix/training-jobs", req);
-}
-
-export interface TrainingLog {
-  id: string;
-  job_id: string;
-  timestamp: string;
-  level: string;
-  message: string;
-  source: string;
-}
-
-export interface TrainingLogsResponse {
-  job_id: string;
-  logs: TrainingLog[];
-  total_logs: number;
-}
-
-export async function getJobLogs(
-  jobId: string
-): Promise<ApiResult<TrainingLogsResponse>> {
-  return request<TrainingLogsResponse>("GET", `/felix/training-jobs/${jobId}/logs`);
-}
-
-export async function deleteJob(jobId: string): Promise<ApiResult> {
-  return request("DELETE", `/felix/training-jobs/${jobId}`);
-}
-
-export interface StopJobResponse {
-  success: boolean;
-  message: string;
-  job_id: string;
-  status: string;
-}
-
-export async function stopJob(
-  jobId: string
-): Promise<ApiResult<StopJobResponse>> {
-  return request<StopJobResponse>("POST", `/felix/training-jobs/${jobId}/stop`);
-}
-
-export interface TerminateJobResponse {
-  success: boolean;
-  message: string;
-  job_id: string;
-  deleted_checkpoints: number;
-}
-
-export async function terminateJob(
-  jobId: string
-): Promise<ApiResult<TerminateJobResponse>> {
-  return request<TerminateJobResponse>(
-    "POST",
-    `/felix/training-jobs/${jobId}/terminate`
-  );
-}
-
-export async function syncJob(jobId: string): Promise<ApiResult<TrainingJob>> {
-  return request<TrainingJob>("POST", `/felix/training-jobs/${jobId}/sync`);
-}
-
-export interface Checkpoint {
-  id: string;
-  job_id: string;
-  epoch: number;
-  step?: number;
-  training_loss?: number;
-  validation_loss?: number;
-  accuracy?: number;
-  learning_rate?: number;
-  gpu_memory_used?: number;
-  gpu_memory_total?: number;
-}
-
-export interface CheckpointListResponse {
-  success: boolean;
-  checkpoints: Checkpoint[];
-  count: number;
-}
-
-export async function listCheckpoints(
-  jobId: string
-): Promise<ApiResult<CheckpointListResponse>> {
-  return request<CheckpointListResponse>(
-    "GET",
-    `/felix/training-jobs/${jobId}/checkpoints`
-  );
-}
-
-export interface DeployCheckpointResponse {
-  success: boolean;
-  message: string;
-  job_id: string;
-  checkpoint_id: string;
-  mme_path: string;
-}
-
-export async function deployCheckpoint(
-  jobId: string,
-  checkpointId: string
-): Promise<ApiResult<DeployCheckpointResponse>> {
-  return request<DeployCheckpointResponse>(
-    "POST",
-    `/felix/training-jobs/${jobId}/checkpoints/${checkpointId}/deploy`
-  );
-}
-
-export interface UpdateModelNameResponse {
-  success: boolean;
-  message: string;
-  job_id: string;
-  model_name: string;
-}
-
-export async function updateModelName(
-  jobId: string,
-  modelName: string
-): Promise<ApiResult<UpdateModelNameResponse>> {
-  return request<UpdateModelNameResponse>(
-    "PATCH",
-    `/felix/training-jobs/${jobId}/model-name`,
-    { model_name: modelName }
-  );
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Models
-// ─────────────────────────────────────────────────────────────────────────────
-
-export interface DeployedModel {
-  id: string;
-  job_id: string | null;
-  model_name?: string;
-  s3_model_uri?: string;
-  mme_model_filename?: string;
-  endpoint_name?: string;
-  is_base_model: boolean;
-  deployed_at?: string | null;
-  last_used_at?: string | null;
-  invocation_count: number;
-  created_at?: string | null;
-  updated_at?: string | null;
-}
-
-export interface DeployedModelsListResponse {
-  success: boolean;
-  models: DeployedModel[];
-  count: number;
-}
-
-interface AnthropicCompatibleModelEntry {
-  id?: string;
-  display_name?: string;
-  type?: string;
-  created_at?: string | null;
-  created?: number;
-  owned_by?: string;
-}
-
-interface AnthropicCompatibleModelsResponse {
-  data?: AnthropicCompatibleModelEntry[];
-}
-
-function isLikelyJobId(value: unknown): value is string {
-  if (typeof value !== "string") return false;
-  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
-}
-
-export async function listModels(
-  options: { includeBase?: boolean } = {}
-): Promise<ApiResult<DeployedModelsListResponse>> {
-  const params = new URLSearchParams();
-  if (options.includeBase !== undefined) {
-    params.set("include_base", String(options.includeBase));
-  }
-  const query = params.toString();
-  const legacyUrl = query ? `/felix/models?${query}` : "/felix/models";
-  const legacy = await request<DeployedModelsListResponse>("GET", legacyUrl);
-  if (legacy.ok || legacy.status !== 404) {
-    return legacy;
-  }
-
-  // Backend removed /felix/models. Fall back to the canonical
-  // Anthropic/OpenAI-compatible catalog and adapt to DeployedModel.
-  const fallback = await request<AnthropicCompatibleModelsResponse>("GET", "/v1/models");
-  if (!fallback.ok) {
-    return {
-      ok: false,
-      status: fallback.status,
-      error: fallback.error ?? "Failed to list deployed models.",
-    };
-  }
-  const entries = fallback.data?.data ?? [];
-  const models: DeployedModel[] = entries
-    .filter((entry) => entry && (options.includeBase || entry.owned_by !== "anthropic"))
-    .map((entry) => {
-      const id = typeof entry.id === "string" ? entry.id : "";
-      return {
-        id,
-        job_id: isLikelyJobId(id) ? id : null,
-        model_name: entry.display_name || id || undefined,
-        is_base_model: entry.owned_by === "anthropic" || entry.owned_by === "openai",
-        deployed_at: entry.created_at ?? null,
-        last_used_at: null,
-        invocation_count: 0,
-        created_at: entry.created_at ?? null,
-        updated_at: entry.created_at ?? null,
-      };
-    });
-
-  return {
-    ok: true,
-    status: fallback.status,
-    data: {
-      success: true,
-      models,
-      count: models.length,
-    },
-  };
-}
-
-export async function deleteModel(jobId: string): Promise<ApiResult> {
-  return request("DELETE", `/felix/models/${jobId}`);
-}
-
-export interface TrainedModel {
-  id: string;
-  job_id?: string;
-  model_name?: string;
-  trained_model_path?: string;
-  datasets?: Array<{
-    name: string;
-    version: string;
-  }>;
-  base_model?: string;
-  validation_data_percentage?: number;
-  nr_epochs?: number;
-  learning_rate?: number;
-  batch_size?: number;
-  instance_type?: string;
-  status: string;
-  error_message?: string | null;
-  created_at?: string | null;
-  updated_at?: string | null;
-  started_at?: string | null;
-  completed_at?: string | null;
-  model_auto_selected?: boolean;
-  model_selection_reason?: string | null;
-  metrics?: {
-    final_training_loss?: number;
-    final_validation_loss?: number;
-    best_validation_loss?: number;
-    eval_f1_score?: number;
-    eval_precision?: number;
-    eval_recall?: number;
-    eval_accuracy?: number;
-    eval_validation_loss?: number;
-  };
-}
-
-export interface TrainedModelsListResponse {
-  success: boolean;
-  training_jobs: TrainedModel[];
-  count: number;
-}
-
-export async function listTrainedModels(): Promise<
-  ApiResult<TrainedModelsListResponse>
-> {
-  return request<TrainedModelsListResponse>("GET", "/felix/trained-models");
-}
-
-export interface AllModelsResponse {
-  deployed: DeployedModel[];
-  trained: TrainedModel[];
-  projects: ProjectResponse[];
-}
-
-export async function listAllModels(): Promise<ApiResult<AllModelsResponse>> {
-  const [deployedResult, trainedResult, projectsResult] = await Promise.all([
-    listModels(),
-    listTrainedModels(),
-    listProjects(),
-  ]);
-
-  if (!deployedResult.ok) {
-    return { ok: false, status: deployedResult.status, error: deployedResult.error };
-  }
-  if (!trainedResult.ok) {
-    return { ok: false, status: trainedResult.status, error: trainedResult.error };
-  }
-  if (!projectsResult.ok) {
-    return { ok: false, status: projectsResult.status, error: projectsResult.error };
-  }
-
-  return {
-    ok: true,
-    status: 200,
-    data: {
-      deployed: deployedResult.data?.models ?? [],
-      trained: trainedResult.data?.training_jobs ?? [],
-      projects: projectsResult.data?.projects ?? [],
-    },
-  };
-}
-
-export interface ModelDownloadResponse {
-  success?: boolean;
-  job_id?: string;
-  download_url: string;
-  expires_in_seconds?: number;
-  file_name?: string;
-  message?: string;
-}
-
-export async function downloadModel(
-  jobId: string
-): Promise<ApiResult<ModelDownloadResponse>> {
-  return request<ModelDownloadResponse>(
-    "GET",
-    `/felix/training-jobs/${jobId}/download`
-  );
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Inference
-// ─────────────────────────────────────────────────────────────────────────────
-
-export interface EncoderInferenceRequest {
-  model_id: string;
-  task: "extract_entities" | "classify_text" | "extract_json" | "schema";
-  text: string | string[];
-  schema: string[] | Record<string, unknown>;
-  threshold?: number;
-  include_confidence?: boolean;
-  include_spans?: boolean;
-  format_results?: boolean;
-  is_warmup?: boolean;
-  store?: boolean;
-  project_id?: string;
-}
-
-export interface InferenceMessage {
-  role: "system" | "user" | "assistant";
-  content: string;
-}
-
-export interface GenerateInferenceRequest {
-  model_id: string;
-  task: "generate";
-  messages: InferenceMessage[];
-  max_tokens?: number;
-  temperature?: number;
-  top_p?: number;
-  include_reasoning_trace?: boolean;
-  is_warmup?: boolean;
-  store?: boolean;
-  project_id?: string;
-}
-
-export type InferenceRequest = EncoderInferenceRequest | GenerateInferenceRequest;
-
-export interface EncoderInferenceResponse {
-  type: "encoder";
-  inference_id: string;
-  result: Record<string, unknown> | unknown[];
-  model_id: string;
-  latency_ms: number;
-  token_usage: number;
-  model_used: string;
-}
-
-export interface GenerateInferenceResponse {
-  type: "decoder";
-  inference_id: string;
-  completion: string;
-  reasoning_trace?: string | null;
-  model_id: string;
-  latency_ms: number;
-}
-
-export type InferenceResponse = EncoderInferenceResponse | GenerateInferenceResponse;
-
-export async function runInference(
-  req: InferenceRequest
-): Promise<ApiResult<InferenceResponse>> {
-  return request<InferenceResponse>("POST", "/inference", req);
-}
-
-export interface TextCompletionRequest {
-  model: string;
-  prompt: string;
-  temperature?: number;
-  max_tokens?: number;
-  stop?: string[] | string;
-  echo?: boolean;
-  extra_body?: Record<string, unknown>;
-}
-
-export interface TextCompletionUsage {
-  prompt_tokens: number;
-  completion_tokens: number;
-  total_tokens: number;
-}
-
-export interface TextCompletionChoice {
-  index?: number;
-  text: string;
-  finish_reason?: string | null;
-}
-
-export interface TextCompletionResponse {
-  id?: string;
-  object?: string;
-  created?: number;
-  model: string;
-  choices: TextCompletionChoice[];
-  usage: TextCompletionUsage;
-}
-
-export async function runTextCompletion(
-  req: TextCompletionRequest
-): Promise<ApiResult<TextCompletionResponse>> {
-  return request<TextCompletionResponse>("POST", "/v1/completions", req);
-}
-
-export interface BaseModelInfo {
-  id: string;
-  name?: string;
-  label?: string;
-  /**
-   * One of "encoder" | "decoder" — the architectural family of the model.
-   * Note: backend used to expose this as `type`; the field is now `task_type`.
-   */
-  task_type?: string;
-  supports_inference?: boolean;
-  supports_on_demand_inference?: boolean;
-  supports_training?: boolean;
-  description?: string;
-  tier?: "enterprise" | "open" | string;
-  context_window?: number;
-  license?: string;
-  input_price_per_million?: number;
-  output_price_per_million?: number;
-}
-
-export interface BaseModelsResponse {
-  models: BaseModelInfo[];
-}
-
-export async function listBaseModels(): Promise<
-  ApiResult<BaseModelsResponse | BaseModelInfo[]>
-> {
-  return request<BaseModelsResponse | BaseModelInfo[]>("GET", "/base-models");
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Agent chat
-// ─────────────────────────────────────────────────────────────────────────────
-
-export interface AgentChatHistoryItem {
-  role: "user" | "assistant" | "system" | string;
-  content: string;
-}
-
-export interface ChatSessionMessage {
-  id?: string;
-  session_id?: string;
-  role: string;
-  content: string;
-  message_index?: number;
-  created_at?: string;
-  tool_call_id?: string | null;
-  tool_calls?: Array<{
-    id?: string;
-    name?: string;
-    args?: Record<string, unknown>;
-  }> | null;
-  images?: Array<Record<string, unknown>> | null;
-}
-
-export interface ChatSessionResponse {
-  id: string;
-  user_id: string;
-  title: string;
-  created_at: string;
-  updated_at: string;
-  is_archived: boolean;
-  project_id: string | null;
-  modal_sandbox_id: string | null;
-  raw_message_tree_present?: boolean;
-  messages: ChatSessionMessage[];
-}
-
-export interface CreateChatSessionRequest {
-  first_message?: string;
-  title?: string;
-  project_id?: string;
-}
-
-export interface UpdateChatSessionRequest {
-  title?: string;
-  is_archived?: boolean;
-}
-
-export interface AppendSessionMessagesRequest {
-  messages: Array<{
-    role: string;
-    content: string;
-    tool_call_id?: string;
-    tool_calls?: Array<{
-      id?: string;
-      name?: string;
-      args?: Record<string, unknown>;
-      [key: string]: unknown;
-    }>;
-  }>;
-}
-
-export interface ChatSessionListResponse {
-  success: boolean;
-  sessions: Array<Pick<ChatSessionResponse, "id" | "user_id" | "title" | "created_at" | "updated_at" | "is_archived">>;
-}
-
-export interface AgentChatRequest {
-  message: string;
-  conversation_id?: string;
-  history?: AgentChatHistoryItem[];
-  resume_value?: string;
-}
-
-export interface AgentChatResponse {
-  answer: string;
-  conversation_id: string;
-  tool_calls_made?: number;
-}
-
-export interface AutoAgentRun {
-  agent_run_id: string;
-  status: string;
-  created_at?: string;
-  updated_at?: string;
-  project_id?: string;
-  model_id?: string;
-  result_url?: string;
-  run_type?: string;
-  [key: string]: unknown;
-}
-
-export async function agentChat(
-  req: AgentChatRequest
-): Promise<ApiResult<AgentChatResponse>> {
-  const baseUrl = getBaseUrl().replace(/\/$/, "");
-  const apiKey = getApiKey();
-  const url = `${baseUrl}/auto-agent/clarify`;
-  const headers: Record<string, string> = {
-    "Content-Type": "application/json",
-    "User-Agent": "pioneer-cli/0.1.0",
-  };
-
-  if (apiKey) {
-    headers["X-API-Key"] = apiKey;
-  }
-
-  try {
-    const res = await fetch(url, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(req),
-    });
-
-    const text = await res.text();
-
-    let parsedJson: unknown;
-    try {
-      parsedJson = JSON.parse(text);
-    } catch {
-      // Ignore; some responses may be SSE/event text or empty.
-    }
-
-    const parseAgentStream = (raw: string): AgentChatResponse | undefined => {
-      const direct = parseAgentPayload(raw);
-      if (direct) return direct;
-
-      const events = raw
-        .split("\n")
-        .map((line) => line.trim())
-        .filter((line) => line.startsWith("data:"));
-      const fallback: AgentChatResponse = {
-        answer: "",
-        conversation_id: "",
-      };
-
-      for (const eventLine of events) {
-        const payload = eventLine.slice(5).trim();
-        if (!payload) continue;
-
-        let event: Record<string, unknown> | undefined;
-        try {
-          event = JSON.parse(payload);
-        } catch {
-          continue;
-        }
-        if (typeof event === "object" && event) {
-          const type = typeof event.type === "string" ? event.type : undefined;
-
-          if (type === "delta" && typeof event.content === "string") {
-            fallback.answer += event.content;
-          }
-
-          if (typeof event.content === "string" && !fallback.answer) {
-            fallback.answer = event.content;
-          }
-
-          if (typeof event.answer === "string") {
-            fallback.answer = event.answer;
-          }
-
-          if (typeof event.conversation_id === "string") {
-            fallback.conversation_id = event.conversation_id;
-          }
-
-          if (typeof event.tool_calls_made === "number") {
-            fallback.tool_calls_made = event.tool_calls_made;
-          }
-
-          if (type === "complete") {
-            if (typeof event.conversation_id === "string") {
-              fallback.conversation_id = event.conversation_id;
-            }
-            if (typeof event.answer === "string") {
-              fallback.answer = event.answer;
-            }
-          }
-        }
-      }
-
-      if (fallback.answer || fallback.conversation_id) {
-        return fallback;
-      }
-      return undefined;
-    };
-
-    const parseAgentPayload = (raw: string): AgentChatResponse | undefined => {
-      if (!raw.trim()) {
-        return undefined;
-      }
-      if (typeof parsedJson !== "object" || parsedJson === null) {
-        return undefined;
-      }
-
-      const payload = parsedJson as Record<string, unknown>;
-      const answer = typeof payload.answer === "string" ? payload.answer : "";
-      const conversationId =
-        typeof payload.answer === "string" && typeof payload.conversation_id === "string"
-          ? payload.conversation_id
-          : typeof payload.conversation_id === "string"
-            ? payload.conversation_id
-            : "";
-
-      if (!answer && !conversationId && typeof payload.detail !== "string") {
-        return undefined;
-      }
-
-      return {
-        answer,
-        conversation_id: conversationId,
-        ...(typeof payload.tool_calls_made === "number"
-          ? { tool_calls_made: payload.tool_calls_made }
-          : {}),
-      };
-    };
-
-    const parsedResponse = parseAgentStream(text);
-
-    if (!res.ok) {
-      const rawError = parsedJson ? JSON.stringify(parsedJson) : text || `HTTP ${res.status}`;
-      const extractedError = extractErrorMessage(parsedJson) || text || `HTTP ${res.status}`;
-      if (isAuthError(res.status, rawError)) {
-        return {
-          ok: false,
-          status: res.status,
-          error: formatAuthError(extractedError),
-        };
-      }
-      return {
-        ok: false,
-        status: res.status,
-        error: extractedError,
-      };
-    }
-
-    if (parsedResponse) {
-      return { ok: true, status: res.status, data: parsedResponse };
-    }
-
-    return {
-      ok: true,
-      status: res.status,
-      data: {
-        answer: text || "",
-        conversation_id: "",
-      },
-    };
-  } catch (err) {
-    return {
-      ok: false,
-      status: 0,
-      error: err instanceof Error ? err.message : String(err),
-    };
-  }
-}
-
-// Agent session persistence APIs (Pioneer MLE agent)
-export async function createAgentSession(
-  req: CreateChatSessionRequest
-): Promise<ApiResult<ChatSessionResponse>> {
-  return request<ChatSessionResponse>("POST", "/mle-agent/sessions", req);
-}
-
-export async function getAgentSession(
-  sessionId: string
-): Promise<ApiResult<ChatSessionResponse>> {
-  return request<ChatSessionResponse>("GET", `/mle-agent/sessions/${sessionId}`);
-}
-
-export async function listAgentSessions(): Promise<ApiResult<ChatSessionListResponse>> {
-  return request<ChatSessionListResponse>("GET", "/mle-agent/sessions");
-}
-
-export async function appendSessionMessages(
-  sessionId: string,
-  req: AppendSessionMessagesRequest
-): Promise<ApiResult<{ success: boolean; session_id: string; messages_added: number }>> {
-  return request<{ success: boolean; session_id: string; messages_added: number }>(
-    "POST",
-    `/mle-agent/sessions/${sessionId}/messages`,
-    req
-  );
-}
-
-export async function updateAgentSession(
-  sessionId: string,
-  req: UpdateChatSessionRequest
-): Promise<ApiResult<ChatSessionResponse>> {
-  return request<ChatSessionResponse>("PATCH", `/mle-agent/sessions/${sessionId}`, req);
-}
-
-export async function deleteAgentSession(sessionId: string): Promise<ApiResult<{ success: boolean }>> {
-  return request<{ success: boolean }>("DELETE", `/mle-agent/sessions/${sessionId}`);
-}
-
-export async function listAutoAgentRuns(
-  limit = 20,
-  offset = 0
-): Promise<ApiResult<{ runs: AutoAgentRun[] }>> {
-  return request<{ runs: AutoAgentRun[] }>(
-    "GET",
-    `/auto-agent/runs?limit=${limit}&offset=${offset}`
-  );
-}
-
-export async function getAutoAgentRun(
-  runId: string
-): Promise<ApiResult<AutoAgentRun>> {
-  return request<AutoAgentRun>("GET", `/auto-agent/run/${runId}`);
-}
-
-export async function stopAutoAgentRun(
-  runId: string
-): Promise<ApiResult<{ success: boolean }>> {
-  return request<{ success: boolean }>("POST", `/auto-agent/run/${runId}/stop`);
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Decoder Generation
-// ─────────────────────────────────────────────────────────────────────────────
-
-export interface GenerateDecoderRequest {
-  domain_description: string;
-  instruction?: string;
-  num_examples?: number;
-  temperature?: number;
-  generation_profile?: "auto" | "fast" | "balanced" | "quality";
-  quality?: "light" | "medium" | "heavy";
-  include_reasoning_trace?: boolean;
-  reasoning_effort?: "low" | "medium" | "high";
-  constraints?: ConstraintRequest[];
-  save_dataset?: boolean;
-  dataset_name?: string;
-  project_id?: string;
-  use_meta_felix?: boolean;
-  session_id?: string;
-  config_num_examples?: number;
-  min_criteria?: number;
-  target_choices?: number;
-  split_ratio?: Record<string, number>;
-  negative_ratio?: number;
-  multiplicator?: Record<string, unknown>;
-  type?: "training" | "evaluation" | "split";
-  visibility?: "private" | "public";
-}
-
-export async function generateDecoder(
-  req: GenerateDecoderRequest
-): Promise<ApiResult<GenerateJobStatus>> {
-  return generateDataset({
-    task_type: "decoder",
-    dataset_name: req.dataset_name ?? makeDefaultDatasetName("decoder"),
-    domain_description: req.domain_description,
-    instruction: req.instruction,
-    num_examples: req.num_examples,
-    temperature: req.temperature,
-    generation_profile: req.generation_profile,
-    quality: req.quality,
-    constraints: req.constraints,
-    project_id: req.project_id,
-    include_reasoning_trace: req.include_reasoning_trace,
-    reasoning_effort: req.reasoning_effort,
-    use_meta_felix: req.use_meta_felix,
-    session_id: req.session_id,
-    config_num_examples: req.config_num_examples,
-    min_criteria: req.min_criteria,
-    target_choices: req.target_choices,
-    split_ratio: req.split_ratio,
-    negative_ratio: req.negative_ratio,
-    multiplicator: req.multiplicator,
-    type: req.type,
-    visibility: req.visibility,
-  });
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Evaluations
-// ─────────────────────────────────────────────────────────────────────────────
-
-export interface BaselineModel {
-  id: string;
-  name: string;
-  provider: string;
-  description: string;
-}
-
-export interface BaselineModelsResponse {
-  success: boolean;
-  models: BaselineModel[];
-  count: number;
-}
-
-export async function listBaselineModels(): Promise<ApiResult<BaselineModelsResponse>> {
-  return request<BaselineModelsResponse>("GET", "/felix/baseline-models");
-}
-
-export interface Evaluation {
-  id: string;
-  user_id: string;
-  project_id?: string;
-  model_id: string;
-  dataset_name: string;
-  dataset_version: string;
-  provider?: string;
-  model_name?: string;
-  f1_score?: number;
-  precision_score?: number;
-  recall_score?: number;
-  accuracy?: number;
-  validation_loss?: number;
-  total_tokens?: number;
-  total_cost_usd?: number;
-  total_latency_ms?: number;
-  max_examples?: number;
-  seed?: number;
-  sample_count?: number;
-  evaluation_time_ms?: number;
-  status: string;
-  job_reference?: string;
-  error_message?: string;
-  created_at: string;
-  completed_at?: string;
-}
-
-export interface EvaluationListResponse {
-  success: boolean;
-  evaluations: Evaluation[];
-  count: number;
-}
-
-export async function listEvaluations(): Promise<
-  ApiResult<EvaluationListResponse>
-> {
-  return request<EvaluationListResponse>("GET", "/felix/evaluations");
-}
-
-export async function getEvaluation(
-  evalId: string
-): Promise<ApiResult<Evaluation>> {
-  return request<Evaluation>("GET", `/felix/evaluations/${evalId}`);
-}
-
-export interface EvaluationCreateRequest {
-  dataset: DatasetRef;
-  model_id: string;
-  base_model?: string;
-  comparison_models?: string[];
-  dataset_names?: string[];
-  provider?: "felix" | "openai" | "together";
-  max_examples?: number;
-  seed?: number;
-  task_type?: string;
-  text_column?: string;
-  label_column?: string;
-  project_id?: string;
-}
-
-export interface EvaluationCreateResponse {
-  success: boolean;
-  evaluations: Evaluation[];
-  count: number;
-}
-
-export async function createEvaluation(
-  req: EvaluationCreateRequest
-): Promise<ApiResult<EvaluationCreateResponse>> {
-  const { dataset, ...rest } = req;
-  const baseModel = req.base_model ?? req.model_id;
-  return request<EvaluationCreateResponse>("POST", "/felix/evaluations", {
-    ...rest,
-    base_model: baseModel,
-    dataset_name: dataset.name,
-    dataset_version: dataset.version,
-  });
-}
-
-export interface ModelWithEvaluation {
-  model_id: string;
-  model_name: string;
-  is_base_model: boolean;
-  evaluation?: Evaluation;
-}
-
-export interface DatasetEvaluationsResponse {
-  success: boolean;
-  dataset_name: string;
-  dataset_version: string;
-  sample_count: number;
-  models: ModelWithEvaluation[];
-  count: number;
-}
-
-export async function getDatasetEvaluations(
-  dataset: DatasetRef
-): Promise<ApiResult<DatasetEvaluationsResponse>> {
-  return request<DatasetEvaluationsResponse>(
-    "GET",
-    `/felix/datasets/${dataset.name}/${dataset.version}/evaluations`
-  );
-}
-
-export interface DeleteEvaluationResponse {
-  success: boolean;
-  message: string;
-}
-
-export async function deleteEvaluation(
-  evaluationId: string
-): Promise<ApiResult<DeleteEvaluationResponse>> {
-  return request<DeleteEvaluationResponse>("DELETE", `/felix/evaluations/${evaluationId}`);
-}
-
-export interface UpdateEvaluationProjectRequest {
-  evaluation_id: string;
-  project_id?: string;
-}
-
-export interface UpdateEvaluationProjectResponse {
-  success: boolean;
-  message: string;
-}
-
-export async function updateEvaluationProject(
-  req: UpdateEvaluationProjectRequest
-): Promise<ApiResult<UpdateEvaluationProjectResponse>> {
-  return request<UpdateEvaluationProjectResponse>(
-    "PATCH",
-    `/felix/evaluations/${req.evaluation_id}/project`,
-    { project_id: req.project_id }
-  );
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Benchmarks
-// ─────────────────────────────────────────────────────────────────────────────
-
-export interface BenchmarkInfo {
-  name: string;
-  description: string;
-  task: string;
-  dataset_source?: string;
-  metrics: string[];
-}
-
-export interface ListBenchmarksResponse {
-  success: boolean;
-  benchmarks: Record<string, BenchmarkInfo[]>;
-  count: number;
-}
-
-export async function listBenchmarks(): Promise<ApiResult<ListBenchmarksResponse>> {
-  return request<ListBenchmarksResponse>("GET", "/felix/benchmarks");
-}
-
-export interface BenchmarkEvaluationRequest {
-  model_id: string;
-  task: "ner" | "text_classification";
-  benchmark: string;
-  max_samples?: number;
-  split?: string;
-  benchmark_config?: Record<string, unknown>;
-}
-
-export interface BenchmarkEvaluationResponse {
-  success: boolean;
-  evaluation_id: string;
-  status: "pending" | "running" | "complete" | "errored";
-  task: string;
-  benchmark: string;
-  model_id: string;
-  metrics?: Record<string, unknown>;
-  error_message?: string;
-  created_at: string;
-  completed_at?: string;
-}
-
-export async function startBenchmarkEvaluation(
-  req: BenchmarkEvaluationRequest
-): Promise<ApiResult<BenchmarkEvaluationResponse>> {
-  return request<BenchmarkEvaluationResponse>("POST", "/felix/benchmarks/evaluate", req);
-}
-
-export async function getBenchmarkEvaluation(
-  evaluationId: string
-): Promise<ApiResult<BenchmarkEvaluationResponse>> {
-  return request<BenchmarkEvaluationResponse>(
-    "GET",
-    `/felix/benchmarks/evaluate/${evaluationId}`
-  );
-}
-
-export async function cancelBenchmarkEvaluation(
-  evaluationId: string
-): Promise<ApiResult<{ success: boolean; message: string }>> {
-  return request<{ success: boolean; message: string }>(
-    "POST",
-    `/felix/benchmarks/evaluate/${evaluationId}/cancel`
-  );
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Data Editing (operates on persisted datasets)
-// ─────────────────────────────────────────────────────────────────────────────
-
-export interface PIIFinding {
-  row_index: number;
-  column: string;
-  entity_type: string;
-  text: string;
-  start: number;
-  end: number;
-  score: number;
-}
-
-export interface DataEditingScanRequest {
-  dataset: DatasetRef;
-  columns?: string[];
-  threshold?: number;
-}
-
-export interface DataEditingScanResponse {
-  success: boolean;
-  dataset_id: string;
-  scan_type: "pii" | "phd";
-  findings_count: number;
-  affected_rows: number;
-  findings: PIIFinding[];
-}
-
-export async function scanForPII(
-  req: DataEditingScanRequest
-): Promise<ApiResult<DataEditingScanResponse>> {
-  const { dataset, ...rest } = req;
-  return request<DataEditingScanResponse>("POST", "/felix/data-editing/scan-pii", {
-    ...rest,
-    dataset_name: dataset.name,
-    dataset_version: dataset.version,
-  });
-}
-
-export async function scanForPHD(
-  req: DataEditingScanRequest
-): Promise<ApiResult<DataEditingScanResponse>> {
-  const { dataset, ...rest } = req;
-  return request<DataEditingScanResponse>("POST", "/felix/data-editing/scan-phd", {
-    ...rest,
-    dataset_name: dataset.name,
-    dataset_version: dataset.version,
-  });
-}
-
-export interface DataEditingDismissOutlierRequest {
-  dataset: DatasetRef;
-  fingerprint: string;
-}
-
-export interface DataEditingDismissOutlierResponse {
-  success: boolean;
-}
-
-export async function dismissOutlier(
-  req: DataEditingDismissOutlierRequest
-): Promise<ApiResult<DataEditingDismissOutlierResponse>> {
-  const { dataset, ...rest } = req;
-  return request<DataEditingDismissOutlierResponse>("POST", "/felix/dataset/outliers/dismiss", {
-    ...rest,
-    dataset_name: dataset.name,
-    dataset_version: dataset.version,
-  });
-}
-
-export interface DataEditingRemoveRequest {
-  dataset: DatasetRef;
-  findings: PIIFinding[];
-  redaction_method?: "redact" | "remove_row" | "mask";
-  save_as_new?: boolean;
-}
-
-export interface DataEditingRemoveResponse {
-  success: boolean;
-  dataset_id: string;
-  new_dataset_id?: string;
-  rows_affected: number;
-  entities_removed: number;
-  message: string;
-}
-
-export async function removePII(
-  req: DataEditingRemoveRequest
-): Promise<ApiResult<DataEditingRemoveResponse>> {
-  const { dataset, ...rest } = req;
-  return request<DataEditingRemoveResponse>("POST", "/felix/data-editing/remove-pii", {
-    ...rest,
-    dataset_name: dataset.name,
-    dataset_version: dataset.version,
-  });
-}
-
-export interface DataEditingSubsampleRequest {
-  dataset: DatasetRef;
-  method?: "random" | "balanced" | "stratified";
-  n: number;
-  label_column?: string;
-  seed?: number;
-  save_as_new?: boolean;
-}
-
-export interface DataEditingSubsampleResponse {
-  success: boolean;
-  dataset_id: string;
-  new_dataset_id: string;
-  original_rows: number;
-  new_rows: number;
-  method: string;
-  message: string;
-}
-
-export async function subsampleDataset(
-  req: DataEditingSubsampleRequest
-): Promise<ApiResult<DataEditingSubsampleResponse>> {
-  const { dataset, ...rest } = req;
-  return request<DataEditingSubsampleResponse>("POST", "/felix/data-editing/subsample", {
-    ...rest,
-    dataset_name: dataset.name,
-    dataset_version: dataset.version,
-  });
-}
-
-export interface DataEditingCheckLabelsRequest {
-  dataset: DatasetRef;
-  text_column: string;
-  label_column: string;
-  sample_size?: number;
-}
-
-export interface LabelCheckResult {
-  row_index: number;
-  text: string;
-  current_label: string;
-  suggested_label: string;
-  confidence: number;
-  reasoning: string;
-}
-
-export interface DataEditingCheckLabelsResponse {
-  success: boolean;
-  dataset_id: string;
-  checked_count: number;
-  issues_found: number;
-  results: LabelCheckResult[];
-}
-
-export async function checkLabels(
-  req: DataEditingCheckLabelsRequest
-): Promise<ApiResult<DataEditingCheckLabelsResponse>> {
-  const { dataset, ...rest } = req;
-  return request<DataEditingCheckLabelsResponse>("POST", "/felix/data-editing/check-labels", {
-    ...rest,
-    dataset_name: dataset.name,
-    dataset_version: dataset.version,
-  });
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Hugging Face Integration
-// ─────────────────────────────────────────────────────────────────────────────
-
-export interface HuggingFacePushRequest {
-  hf_token: string;
-  repo_id: string;
-  private?: boolean;
-  commit_message?: string;
-}
-
-export interface HuggingFacePushResponse {
-  success: boolean;
-  url: string;
-  repo_id: string;
-  version: string;
-  message: string;
-}
-
-export async function pushDatasetToHub(
-  dataset: DatasetRef,
-  options: HuggingFacePushRequest
-): Promise<ApiResult<HuggingFacePushResponse>> {
-  return request<HuggingFacePushResponse>(
-    "POST",
-    `/felix/datasets/${dataset.name}/${dataset.version}/push-to-hub`,
-    options
-  );
-}
-
-export interface HuggingFacePushModelRequest {
-  hf_token: string;
-  repo_id: string;
-  private?: boolean;
-  commit_message?: string;
-}
-
-export interface HuggingFacePushModelResponse {
-  success: boolean;
-  url: string;
-  repo_id: string;
-  job_id: string;
-  message: string;
-}
-
-export async function pushModelToHub(
-  jobId: string,
-  options: HuggingFacePushModelRequest
-): Promise<ApiResult<HuggingFacePushModelResponse>> {
-  return request<HuggingFacePushModelResponse>(
-    "POST",
-    `/felix/training-jobs/${jobId}/push-to-hub`,
-    options
-  );
-}
-
-export interface HuggingFacePullRequest {
-  repo_id: string;
-  hf_token: string;
-  revision?: string;
-  name?: string;
-}
-
-export async function pullDatasetFromHub(
-  options: HuggingFacePullRequest
-): Promise<ApiResult<Dataset>> {
-  return request<Dataset>(
-    "POST",
-    "/felix/datasets/pull-from-hub",
-    options
-  );
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Constraints Generation
-// ─────────────────────────────────────────────────────────────────────────────
-
-export interface GenerateNERConstraintsRequest {
-  labels: string[];
-  domain_description?: string;
-  min_criteria?: number;
-}
-
-export interface GenerateClassificationConstraintsRequest {
-  labels: string[];
-  domain_description?: string;
-  min_criteria?: number;
-}
-
-export interface GenerateRecordsConstraintsRequest {
-  fields: RecordField[];
-  domain_description?: string;
-  min_criteria?: number;
-}
-
-export interface GenerateConstraintsResponse {
-  success: boolean;
-  constraints: ConstraintRequest[];
-  count: number;
-  token_usage?: number;
-}
-
-export async function generateNERConstraints(
-  req: GenerateNERConstraintsRequest
-): Promise<ApiResult<GenerateConstraintsResponse>> {
-  return request<GenerateConstraintsResponse>(
-    "POST",
-    "/felix/constraints/ner",
-    req
-  );
-}
-
-export async function generateClassificationConstraints(
-  req: GenerateClassificationConstraintsRequest
-): Promise<ApiResult<GenerateConstraintsResponse>> {
-  return request<GenerateConstraintsResponse>(
-    "POST",
-    "/felix/constraints/classification",
-    req
-  );
-}
-
-export async function generateRecordsConstraints(
-  req: GenerateRecordsConstraintsRequest
-): Promise<ApiResult<GenerateConstraintsResponse>> {
-  return request<GenerateConstraintsResponse>(
-    "POST",
-    "/felix/constraints/records",
-    req
-  );
-}
-
-export interface ExpandConstraintChoicesRequest {
-  constraint: ConstraintRequest;
-  task_description: string;
-  max_count?: number;
-}
-
-export interface ExpandConstraintChoicesResponse {
-  success: boolean;
-  constraint: ConstraintRequest;
-  expanded_choices: string[];
-  count: number;
-  token_usage?: number;
-}
-
-export async function expandConstraintChoices(
-  req: ExpandConstraintChoicesRequest
-): Promise<ApiResult<ExpandConstraintChoicesResponse>> {
-  return request<ExpandConstraintChoicesResponse>(
-    "POST",
-    "/felix/constraints/expand",
-    req
-  );
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Dataset Augmentation
-// ─────────────────────────────────────────────────────────────────────────────
-
-export interface AugmentationOperation {
-  type: "remove_duplicates" | "remove_outliers" | "balance";
-  enabled: boolean;
-}
-
-export interface DatasetAugmentationRequest {
-  task_type: "ner" | "classification";
-  operations: AugmentationOperation[];
-  new_dataset_name: string;
-  dataset_name?: string;
-  dataset_version?: string;
-  dataset?: Record<string, unknown>[];
-  target_distribution?: Record<string, number>;
-  domain_description?: string;
-  labels?: string[];
-}
-
-export interface DatasetAugmentationResponse {
-  success: boolean;
-  original_dataset_name?: string;
-  original_dataset_version?: string;
-  new_dataset: Dataset;
-  modifications: Record<string, unknown>;
-  distribution_comparison: Record<string, unknown>[];
-  message: string;
-}
-
-export async function augmentDataset(
-  req: DatasetAugmentationRequest
-): Promise<ApiResult<DatasetAugmentationResponse>> {
-  return request<DatasetAugmentationResponse>(
-    "POST",
-    "/felix/dataset/augment",
-    req
-  );
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Dataset Query
-// ─────────────────────────────────────────────────────────────────────────────
-
-export interface DatasetQueryRequest {
-  dataset_name: string;
-  code: string;
-  version?: string;
-  timeout?: number;
-  max_rows_returned?: number;
-}
-
-export interface DatasetQueryResponse {
-  success: boolean;
-  dataset_name: string;
-  dataset_version: string;
-  result: unknown;
-  result_type: "dataframe" | "series" | "scalar" | "string" | "none";
-  row_count?: number;
-  columns?: string[];
-  execution_time_ms: number;
-  truncated: boolean;
-  message: string;
-}
-
-export async function queryDataset(
-  req: DatasetQueryRequest
-): Promise<ApiResult<DatasetQueryResponse>> {
-  return request<DatasetQueryResponse>("POST", "/felix/dataset/query", req);
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Dataset Grow
-// ─────────────────────────────────────────────────────────────────────────────
-
-export interface GrowDatasetRequest {
-  dataset_id: string;
-  new_dataset_name: string;
-  target_size: number;
-  class_balance?: boolean;
-  domain_description?: string;
-  temperature?: number;
-  session_id?: string;
-}
-
-export interface GrowDatasetResponse {
-  success: boolean;
-  dataset: Record<string, unknown>;
-  original_size: number;
-  new_size: number;
-  generated_count: number;
-  distribution: Record<string, number>;
-  token_usage?: number;
-}
-
-export async function growDataset(
-  req: GrowDatasetRequest
-): Promise<ApiResult<GrowDatasetResponse>> {
-  return request<GrowDatasetResponse>("POST", "/felix/dataset/grow", req);
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Embeddings
-// ─────────────────────────────────────────────────────────────────────────────
-
-export interface EmbeddingsRequest {
-  text: string;
-  model?: string;
-}
-
-export interface EmbeddingsResponse {
-  embedding: number[];
-}
-
-export async function createEmbeddings(
-  req: EmbeddingsRequest
-): Promise<ApiResult<EmbeddingsResponse>> {
-  return request<EmbeddingsResponse>("POST", "/felix/embeddings", req);
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Activity
-// ─────────────────────────────────────────────────────────────────────────────
-
-export interface ActivityEvent {
-  id: string;
-  type: "project" | "dataset" | "model" | "evaluation" | "notebook" | "deployment";
-  name: string;
-  item_id: string;
-  created_by: string;
-  created_at: string;
-  project_id?: string;
-}
-
-export interface ActivityLogResponse {
-  success: boolean;
-  events?: ActivityEvent[];
-  count: number;
-}
-
-export async function listActivity(
-  options: { limit?: number } = {}
-): Promise<ApiResult<ActivityLogResponse>> {
-  const params = new URLSearchParams();
-  if (options.limit) params.set("limit", String(options.limit));
-  const query = params.toString();
-  const url = query ? `/felix/activity?${query}` : "/felix/activity";
-  return request<ActivityLogResponse>("GET", url);
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Projects
-// ─────────────────────────────────────────────────────────────────────────────
-
-export interface ProjectCreateRequest {
-  name?: string;
-  icon?: string;
-  repo?: string;
-  description?: string;
-  active_model_id?: string;
-  selected_model_id?: string;
-  example?: Record<string, unknown>;
-}
-
-export interface ProjectUpdateRequest {
-  name?: string;
-  icon?: string;
-  repo?: string;
-  description?: string;
-  selected_model_id?: string;
-}
-
-export interface ProjectResponse {
-  id: string;
-  user_id: string;
-  name: string;
-  icon?: string;
-  repo?: string;
-  description?: string;
-  selected_model_id?: string;
-  example?: Record<string, unknown>;
-  created_at: string;
-  updated_at: string;
-}
-
-export interface ProjectListResponse {
-  success: boolean;
-  projects: ProjectResponse[];
-  count: number;
-}
-
-export interface ProjectDeleteResponse {
-  success: boolean;
-  message: string;
-  project_id: string;
-}
-
-export interface ProjectDeploymentCreate {
-  training_job_id: string;
-  reason?: string;
-}
-
-export interface ProjectDeploymentResponse {
-  /** Deployment record id. */
-  id?: string;
-  project_id?: string;
-  /** Set when a fine-tuned checkpoint was deployed. */
-  training_job_id?: string | null;
-  /**
-   * Set to the stock HuggingFace base model id when a base-model deploy was
-   * performed. May also be populated for training-job deploys (post backend
-   * enrichment) so the record always carries "what stock model is serving".
-   */
-  base_model?: string | null;
-  deployed_by?: string;
-  reason?: string;
-  deployed_at?: string;
-  // Legacy/optional fields kept for older response shapes.
-  success?: boolean;
-  message?: string;
-  deployment_id?: string;
-}
-
-export interface ProjectDatasetCountResponse {
-  project_id: string;
-  dataset_count: number;
-  can_delete: boolean;
-}
-
-export interface QualityMetricsResponse {
-  project_id: string;
-  pass_count: number;
-  fail_count: number;
-  uncertain_count: number;
-  total_judged: number;
-  pass_rate: number;
-  fail_rate: number;
-}
-
-export async function listProjects(): Promise<ApiResult<ProjectListResponse>> {
-  return request<ProjectListResponse>("GET", "/projects");
-}
-
-export async function createProject(
-  req: ProjectCreateRequest
-): Promise<ApiResult<ProjectResponse>> {
-  return request<ProjectResponse>("POST", "/projects", req);
-}
-
-export async function getProject(projectId: string): Promise<ApiResult<ProjectResponse>> {
-  return request<ProjectResponse>("GET", `/projects/${projectId}`);
-}
-
-export async function updateProject(
-  projectId: string,
-  req: ProjectUpdateRequest
-): Promise<ApiResult<ProjectResponse>> {
-  return request<ProjectResponse>("PATCH", `/projects/${projectId}`, req);
-}
-
-export async function deleteProject(
-  projectId: string
-): Promise<ApiResult<ProjectDeleteResponse>> {
-  return request<ProjectDeleteResponse>("DELETE", `/projects/${projectId}`);
-}
-
-export async function getProjectDatasetCount(
-  projectId: string
-): Promise<ApiResult<ProjectDatasetCountResponse>> {
-  return request<ProjectDatasetCountResponse>(
-    "GET",
-    `/projects/${projectId}/dataset-count`
-  );
-}
-
-export async function getProjectQualityMetrics(
-  projectId: string
-): Promise<ApiResult<QualityMetricsResponse>> {
-  return request<QualityMetricsResponse>(
-    "GET",
-    `/projects/${projectId}/quality-metrics`
-  );
-}
-
-export async function deployTrainingJobToProject(
-  projectId: string,
-  req: ProjectDeploymentCreate
-): Promise<ApiResult<ProjectDeploymentResponse>> {
-  return request<ProjectDeploymentResponse>(
-    "POST",
-    `/projects/${projectId}/deployments`,
-    req
-  );
-}
-
-export async function rollbackProjectDeployment(
-  projectId: string,
-  deploymentId: string
-): Promise<ApiResult<ProjectDeploymentResponse>> {
-  return request<ProjectDeploymentResponse>(
-    "POST",
-    `/projects/${projectId}/deployments/${deploymentId}/rollback`
-  );
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Presets
-// ─────────────────────────────────────────────────────────────────────────────
-
-export interface PresetMetadata {
-  id: string;
-  name: string;
-  description: string;
-  task_type: string;
-  tags?: string[];
-}
-
-export interface PresetDetail {
-  id: string;
-  name: string;
-  description: string;
-  task_type: string;
-  config: Record<string, unknown>;
-  tags?: string[];
-}
-
-export async function listPresets(): Promise<ApiResult<PresetMetadata[]>> {
-  return request<PresetMetadata[]>("GET", "/felix/presets");
-}
-
-export async function getPreset(
-  presetId: string
-): Promise<ApiResult<PresetDetail>> {
-  return request<PresetDetail>("GET", `/felix/presets/${presetId}`);
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Adaptive Annotation
-// ─────────────────────────────────────────────────────────────────────────────
-
-export interface StartAnnotationSessionRequest {
-  column_name: string;
-  input_columns: string[];
-  task_description: string;
-  task_type?: "classification" | "scoring" | "entity_extraction" | "json_extraction";
-  output_dataset_name?: string;
-  possible_labels?: Array<{ name: string; description?: string }>;
-  scoring_criteria?: Array<Record<string, unknown>>;
-  entity_types?: Array<{ name: string; description?: string }>;
-  json_schema?: Array<Record<string, unknown>>;
-  auto_accept_threshold?: number;
-}
-
-export interface StartAnnotationSessionResponse {
-  success: boolean;
-  session_id: string;
-  dataset_id: string;
-  task_type: string;
-  total_items: number;
-}
-
-export async function startAnnotationSession(
-  datasetId: string,
-  req: StartAnnotationSessionRequest
-): Promise<ApiResult<StartAnnotationSessionResponse>> {
-  return request<StartAnnotationSessionResponse>(
-    "POST",
-    `/felix/datasets/annotate/${datasetId}/start`,
-    req
-  );
-}
-
-export interface NextAnnotationItemResponse {
-  complete: boolean;
-  rate_limited?: boolean;
-  auto_accepted_in_call?: number;
-  item_id?: number;
-  item_data?: Record<string, unknown>;
-  task_type?: string;
-  task_description?: string;
-  possible_labels?: string[];
-  scoring_criteria?: Array<Record<string, unknown>>;
-  entity_types?: Array<Record<string, unknown>>;
-  json_schema?: Array<Record<string, unknown>>;
-  suggestion?: Record<string, unknown>;
-  stats?: Record<string, unknown>;
-}
-
-export async function getNextAnnotationItem(
-  datasetId: string,
-  options: { maxAutoAccept?: number } = {}
-): Promise<ApiResult<NextAnnotationItemResponse>> {
-  const params = new URLSearchParams();
-  if (options.maxAutoAccept !== undefined) {
-    params.set("max_auto_accept", String(options.maxAutoAccept));
-  }
-  const query = params.toString();
-  const url = `/felix/datasets/annotate/${datasetId}/next${query ? `?${query}` : ""}`;
-  return request<NextAnnotationItemResponse>("GET", url);
-}
-
-export interface AnnotationFeedbackRequest {
-  item_id: number;
-  thumb: "up" | "down";
-  corrected_label?: string;
-  corrected_criteria?: Record<string, string>;
-  corrected_entities?: string[][];
-  corrected_json?: Record<string, unknown>;
-}
-
-export interface AnnotationFeedbackResponse {
-  success: boolean;
-  item_id: number;
-  action: "up" | "down";
-  was_correct: boolean;
-  similar_items_queued?: number;
-  stats?: Record<string, unknown>;
-}
-
-export async function submitAnnotationFeedback(
-  datasetId: string,
-  req: AnnotationFeedbackRequest
-): Promise<ApiResult<AnnotationFeedbackResponse>> {
-  return request<AnnotationFeedbackResponse>(
-    "POST",
-    `/felix/datasets/annotate/${datasetId}/feedback`,
-    req
-  );
-}
-
-export interface AnnotationStatsResponse {
-  total_items: number;
-  annotated: number;
-  remaining: number;
-  auto_accepted: number;
-  human_annotated: number;
-  auto_accept_rate: number;
-  label_stats?: Record<string, unknown>;
-}
-
-export async function getAnnotationStats(
-  datasetId: string
-): Promise<ApiResult<AnnotationStatsResponse>> {
-  return request<AnnotationStatsResponse>(
-    "GET",
-    `/felix/datasets/annotate/${datasetId}/stats`
-  );
-}
-
-export interface AnnotationDownloadResponse {
-  data: Record<string, unknown>[];
-  columns: string[];
-  rows: number;
-  stats?: AnnotationStatsResponse;
-}
-
-export async function downloadAnnotatedData(
-  datasetId: string
-): Promise<ApiResult<AnnotationDownloadResponse>> {
-  return request<AnnotationDownloadResponse>(
-    "GET",
-    `/felix/datasets/annotate/${datasetId}/download`
-  );
-}
-
-export interface EndAnnotationSessionResponse {
-  success: boolean;
-  message: string;
-  final_stats?: AnnotationStatsResponse;
-}
-
-export async function endAnnotationSession(
-  datasetId: string
-): Promise<ApiResult<EndAnnotationSessionResponse>> {
-  return request<EndAnnotationSessionResponse>(
-    "DELETE",
-    `/felix/datasets/annotate/${datasetId}/session`
-  );
-}
-