@fastino-ai/pioneer-cli 0.2.6 → 0.2.8

package/src/api.ts

@@ -41,6 +41,38 @@ function isAuthError(status: number, errorText: string): boolean {
   );
 }
 
+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,
@@ -76,20 +108,21 @@ async function request<T = unknown>(
 
     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(),
+          error: formatAuthError(extractedError),
         };
       }
 
       return {
         ok: false,
         status: res.status,
-        error: rawError,
+        error: extractedError,
       };
     }
 
@@ -161,14 +194,26 @@ export interface Dataset {
   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;
 }
@@ -195,18 +240,40 @@ export async function getDataset(dataset: DatasetRef): Promise<ApiResult<Dataset
   return request<Dataset>("GET", `/felix/datasets/${dataset.name}/${dataset.version}`);
 }
 
-export interface DatasetCreateRequest {
+export interface UploadUrlRequest {
   dataset_name: string;
-  dataset_path: string;
-  dataset_type?: "classification" | "ner" | "custom";
-  size?: number;
-  sample_size?: number;
+  dataset_type?: "classification" | "ner" | "custom" | "decoder";
+  format?: "jsonl" | "csv" | "parquet";
+  content_type?: string;
 }
 
-export async function createDataset(
-  req: DatasetCreateRequest
+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", req);
+  return request<Dataset>("POST", "/felix/datasets/upload/process", req);
 }
 
 export async function deleteDataset(dataset: DatasetRef): Promise<ApiResult> {
@@ -231,7 +298,7 @@ export async function listDatasetVersions(
 
 export interface DatasetMetadataUpdate {
   dataset_name?: string;
-  dataset_type?: "ner" | "classification" | "custom";
+  dataset_type?: "ner" | "classification" | "custom" | "decoder";
   project_id?: string;
 }
 
@@ -240,7 +307,7 @@ export async function updateDatasetMetadata(
   update: DatasetMetadataUpdate
 ): Promise<ApiResult<Dataset>> {
   return request<Dataset>(
-    "PATCH",
+    "PUT",
     `/felix/datasets/${dataset.name}/${dataset.version}`,
     update
   );
@@ -260,70 +327,80 @@ export async function previewDataset(
 
 export interface DatasetUploadRequest {
   dataset_name: string;
-  dataset_type?: "ner" | "classification" | "custom";
+  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>> {
-  const baseUrl = getBaseUrl().replace(/\/$/, "");
-  const apiKey = getApiKey();
-  const url = `${baseUrl}/felix/datasets/upload`;
-
-  const headers: Record<string, string> = {
-    "User-Agent": "pioneer-cli/0.1.0",
-  };
-
-  if (apiKey) {
-    headers["X-API-Key"] = apiKey;
-  }
-
   try {
     const fs = await import("fs");
     const path = await import("path");
     const fileContent = fs.readFileSync(filePath);
     const filename = path.basename(filePath);
 
-    const formData = new FormData();
-    formData.append("file", new Blob([fileContent]), filename);
-    formData.append("dataset_name", options.dataset_name);
-    if (options.dataset_type) {
-      formData.append("dataset_type", options.dataset_type);
-    }
-    if (options.format) {
-      formData.append("format", options.format);
-    }
-    if (options.schema) {
-      formData.append("schema", JSON.stringify(options.schema));
-    }
+    // 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";
 
-    const res = await fetch(url, {
-      method: "POST",
-      headers,
-      body: formData,
+    // 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",
     });
 
-    const text = await res.text();
+    if (!urlResult.ok || !urlResult.data) {
+      return {
+        ok: false,
+        status: urlResult.status,
+        error: urlResult.error || "Failed to get upload URL",
+      };
+    }
 
-    let data: Dataset | undefined;
-    try {
-      data = JSON.parse(text) as Dataset;
-    } catch {
-      // Not JSON
+    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",
+      };
     }
 
-    if (!res.ok) {
+    // 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: res.status,
-        error: data ? JSON.stringify(data) : text || `HTTP ${res.status}`,
+        status: uploadRes.status,
+        error: `Failed to upload file to S3: HTTP ${uploadRes.status}`,
       };
     }
 
-    return { ok: true, status: res.status, data };
+    // 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,
@@ -519,6 +596,21 @@ export async function analyzeDataset(
   });
 }
 
+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
 // ─────────────────────────────────────────────────────────────────────────────
@@ -545,6 +637,160 @@ export interface GenerateResponse {
   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[];
@@ -572,12 +818,50 @@ export interface GenerateNERRequest {
   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<GenerateResponse>> {
-  return request<GenerateResponse>("POST", "/felix/generate/ner", req);
+): 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 {
@@ -589,12 +873,13 @@ export interface LabelExistingNERRequest {
   constraints?: ConstraintRequest[];
   save_dataset?: boolean;
   dataset_name?: string;
+  project_id?: string;
 }
 
 export async function labelExistingNER(
   req: LabelExistingNERRequest
 ): Promise<ApiResult<GenerateResponse>> {
-  return request<GenerateResponse>("POST", "/felix/generate/ner/label-existing", req);
+  return request<GenerateResponse>("POST", "/generate/ner/label-existing", req);
 }
 
 export interface InferNERLabelsRequest {
@@ -604,7 +889,7 @@ export interface InferNERLabelsRequest {
 export async function inferNERLabels(
   req: InferNERLabelsRequest
 ): Promise<ApiResult<InferLabelsResponse>> {
-  return request<InferLabelsResponse>("POST", "/felix/generate/ner/infer-labels", req);
+  return request<InferLabelsResponse>("POST", "/generate/ner/infer-labels", req);
 }
 
 // Classification Generation
@@ -623,12 +908,51 @@ export interface GenerateClassificationRequest {
   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<GenerateResponse>> {
-  return request<GenerateResponse>("POST", "/felix/generate/classification", req);
+): 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 {
@@ -643,12 +967,13 @@ export interface LabelExistingClassificationRequest {
   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", "/felix/generate/classification/label-existing", req);
+  return request<GenerateResponse>("POST", "/generate/classification/label-existing", req);
 }
 
 export interface InferClassificationLabelsRequest {
@@ -658,7 +983,7 @@ export interface InferClassificationLabelsRequest {
 export async function inferClassificationLabels(
   req: InferClassificationLabelsRequest
 ): Promise<ApiResult<InferLabelsResponse>> {
-  return request<InferLabelsResponse>("POST", "/felix/generate/classification/infer-labels", req);
+  return request<InferLabelsResponse>("POST", "/generate/classification/infer-labels", req);
 }
 
 // Custom Generation
@@ -669,53 +994,164 @@ export interface GenerateCustomRequest {
   num_examples?: number;
   seed?: number;
   session_id?: string;
-  min_criteria?: 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";
+  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<GenerateResponse>> {
-  return request<GenerateResponse>("POST", "/felix/generate/custom", req);
+): 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<GenerateResponse>> {
-  return request<GenerateResponse>("POST", "/felix/generate/records", req);
+): 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;
-  dataset_name?: string;
+  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<GenerateResponse>> {
-  return request<GenerateResponse>("POST", "/felix/generate/fields", req);
+): 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 {
@@ -728,12 +1164,13 @@ export interface LabelExistingFieldsRequest {
   constraints?: ConstraintRequest[];
   save_dataset?: boolean;
   dataset_name?: string;
+  project_id?: string;
 }
 
 export async function labelExistingFields(
   req: LabelExistingFieldsRequest
 ): Promise<ApiResult<GenerateResponse>> {
-  return request<GenerateResponse>("POST", "/felix/generate/fields/label-existing", req);
+  return request<GenerateResponse>("POST", "/generate/fields/label-existing", req);
 }
 
 export interface InferFieldsRequest {
@@ -743,7 +1180,53 @@ export interface InferFieldsRequest {
 export async function inferFields(
   req: InferFieldsRequest
 ): Promise<ApiResult<InferFieldsResponse>> {
-  return request<InferFieldsResponse>("POST", "/felix/generate/fields/infer-fields", req);
+  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);
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -753,6 +1236,7 @@ export async function inferFields(
 export interface TrainingJob {
   id: string;
   user_id: string;
+  project_id?: string;
   model_name?: string;
   datasets: Array<{ name: string; version?: string }>;
   base_model: string;
@@ -771,7 +1255,13 @@ export interface TrainingJob {
   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 {
@@ -1033,12 +1523,14 @@ export async function listTrainedModels(): Promise<
 export interface AllModelsResponse {
   deployed: DeployedModel[];
   trained: TrainedModel[];
+  projects: ProjectResponse[];
 }
 
 export async function listAllModels(): Promise<ApiResult<AllModelsResponse>> {
-  const [deployedResult, trainedResult] = await Promise.all([
+  const [deployedResult, trainedResult, projectsResult] = await Promise.all([
     listModels(),
     listTrainedModels(),
+    listProjects(),
   ]);
 
   if (!deployedResult.ok) {
@@ -1047,6 +1539,9 @@ export async function listAllModels(): Promise<ApiResult<AllModelsResponse>> {
   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,
@@ -1054,12 +1549,18 @@ export async function listAllModels(): Promise<ApiResult<AllModelsResponse>> {
     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(
@@ -1072,64 +1573,583 @@ export async function downloadModel(
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
-// Evaluations
+// Inference
 // ─────────────────────────────────────────────────────────────────────────────
 
-export interface Evaluation {
-  id: string;
-  user_id: string;
-  project_id?: string;
+export interface EncoderInferenceRequest {
   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;
+  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 EvaluationListResponse {
-  success: boolean;
-  evaluations: Evaluation[];
-  count: number;
+export interface InferenceMessage {
+  role: "system" | "user" | "assistant";
+  content: string;
 }
 
-export async function listEvaluations(): Promise<
-  ApiResult<EvaluationListResponse>
-> {
-  return request<EvaluationListResponse>("GET", "/felix/evaluations");
+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 async function getEvaluation(
-  evalId: string
-): Promise<ApiResult<Evaluation>> {
-  return request<Evaluation>("GET", `/felix/evaluations/${evalId}`);
+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 EvaluationCreateRequest {
-  dataset: DatasetRef;
+export interface GenerateInferenceResponse {
+  type: "decoder";
+  inference_id: string;
+  completion: string;
+  reasoning_trace?: string | null;
   model_id: string;
-  dataset_names?: string[];
-  provider?: "felix" | "openai" | "together";
-  max_examples?: number;
-  seed?: number;
-  task_type?: string;
-  text_column?: 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;
+  type?: "encoder" | "decoder" | string;
+  task_type?: string;
+  supports_inference?: boolean;
+  supports_on_demand_inference?: boolean;
+  supports_training?: boolean;
+  description?: string;
+}
+
+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;
 }
@@ -1144,8 +2164,10 @@ 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,
   });
@@ -1176,6 +2198,37 @@ export async function getDatasetEvaluations(
   );
 }
 
+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
 // ─────────────────────────────────────────────────────────────────────────────
@@ -1295,6 +2348,26 @@ export async function scanForPHD(
   });
 }
 
+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[];
@@ -1694,6 +2767,148 @@ export async function listActivity(
   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 {
+  success: boolean;
+  message?: string;
+  project_id?: string;
+  training_job_id?: 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
 // ─────────────────────────────────────────────────────────────────────────────
@@ -1869,100 +3084,3 @@ export async function endAnnotationSession(
   );
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Leaderboard / Competitions
-// ─────────────────────────────────────────────────────────────────────────────
-
-export interface LeaderboardEntry {
-  id: string;
-  dataset_id: string;
-  evaluation_id: string;
-  user_id: string;
-  display_name: string;
-  model_name: string;
-  model_id?: string;
-  f1_score: number;
-  precision_score?: number;
-  recall_score?: number;
-  accuracy?: number;
-  created_at: string;
-  updated_at: string;
-  rank?: number;
-}
-
-export interface CompetitionInfo {
-  dataset_id: string;
-  dataset_name: string;
-  dataset_type: string;
-  description?: string;
-  sample_count?: number;
-  labels?: string[];
-  sample_rows?: Record<string, unknown>[];
-  winner?: LeaderboardEntry;
-  total_entries: number;
-}
-
-export interface CompetitionsResponse {
-  success: boolean;
-  competitions: CompetitionInfo[];
-}
-
-export interface CompetitionSamplesResponse {
-  dataset_id: string;
-  sample_rows: Record<string, unknown>[];
-}
-
-export interface LeaderboardEntriesResponse {
-  success: boolean;
-  dataset_id: string;
-  dataset_name: string;
-  entries: LeaderboardEntry[];
-  total_entries: number;
-}
-
-export interface LeaderboardSubmission {
-  evaluation_id: string;
-  display_name: string;
-}
-
-export interface LeaderboardSubmitResponse {
-  success: boolean;
-  entry: LeaderboardEntry;
-  rank: number;
-  is_new_best: boolean;
-}
-
-export async function listCompetitions(): Promise<ApiResult<CompetitionsResponse>> {
-  return request<CompetitionsResponse>("GET", "/leaderboard/competitions");
-}
-
-export async function getCompetitionSamples(
-  datasetId: string
-): Promise<ApiResult<CompetitionSamplesResponse>> {
-  return request<CompetitionSamplesResponse>(
-    "GET",
-    `/leaderboard/competitions/${datasetId}/samples`
-  );
-}
-
-export async function getLeaderboardEntries(
-  datasetId: string,
-  limit?: number
-): Promise<ApiResult<LeaderboardEntriesResponse>> {
-  const params = new URLSearchParams();
-  if (limit) params.set("limit", String(limit));
-  const query = params.toString();
-  const url = `/leaderboard/datasets/${datasetId}/entries${query ? `?${query}` : ""}`;
-  return request<LeaderboardEntriesResponse>("GET", url);
-}
-
-export async function submitToLeaderboard(
-  datasetId: string,
-  submission: LeaderboardSubmission
-): Promise<ApiResult<LeaderboardSubmitResponse>> {
-  return request<LeaderboardSubmitResponse>(
-    "POST",
-    `/leaderboard/datasets/${datasetId}/submit`,
-    submission
-  );
-}