@fastino-ai/pioneer-cli 0.2.5 → 0.2.7

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,10 +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;
 }
@@ -191,90 +240,158 @@ 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 interface UploadUrlResponse {
+  upload_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 createDataset(
-  req: DatasetCreateRequest
+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> {
   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";
+  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: format === "parquet" ? "application/octet-stream" : "text/plain",
     });
 
-    const text = await res.text();
-
-    let data: Dataset | undefined;
-    try {
-      data = JSON.parse(text) as Dataset;
-    } catch {
-      // Not JSON
+    if (!urlResult.ok || !urlResult.data) {
+      return {
+        ok: false,
+        status: urlResult.status,
+        error: urlResult.error || "Failed to get upload URL",
+      };
     }
 
-    if (!res.ok) {
+    const { upload_url, dataset_id } = urlResult.data;
+
+    // Step 2: Upload file directly to S3 via presigned URL
+    const uploadRes = await fetch(upload_url, {
+      method: "PUT",
+      headers: {
+        "Content-Type": format === "parquet" ? "application/octet-stream" : "text/plain",
+      },
+      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,
@@ -366,9 +483,95 @@ export interface DatasetAnalysisRequest {
   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 {
-  success: boolean;
-  analysis: unknown;
+  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(
@@ -410,6 +613,157 @@ 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";
+  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>;
+  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[];
@@ -430,16 +784,39 @@ export interface GenerateNERRequest {
   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;
+  quality?: "light" | "medium" | "heavy";
+  type?: "training" | "evaluation" | "split";
+  visibility?: "private" | "public";
+  negative_ratio?: number;
 }
 
 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,
+    quality: req.quality,
+    type: req.type,
+    visibility: req.visibility,
+    negative_ratio: req.negative_ratio,
+  });
 }
 
 export interface LabelExistingNERRequest {
@@ -456,7 +833,7 @@ export interface LabelExistingNERRequest {
 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 {
@@ -466,7 +843,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
@@ -476,18 +853,44 @@ export interface GenerateClassificationRequest {
   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;
+  quality?: "light" | "medium" | "heavy";
+  type?: "training" | "evaluation" | "split";
+  visibility?: "private" | "public";
+  negative_ratio?: number;
 }
 
 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,
+    quality: req.quality,
+    type: req.type,
+    visibility: req.visibility,
+    negative_ratio: req.negative_ratio,
+  });
 }
 
 export interface LabelExistingClassificationRequest {
@@ -507,7 +910,7 @@ export interface LabelExistingClassificationRequest {
 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 {
@@ -517,31 +920,54 @@ 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
 export interface GenerateCustomRequest {
   prompt: string;
-  output_format: Record<string, unknown>;
+  output_format?: Record<string, unknown>;
+  infer_output_format?: boolean;
   num_examples?: number;
   seed?: number;
+  session_id?: string;
   min_criteria?: number;
   temperature?: number;
   constraints?: ConstraintRequest[];
   save_dataset?: boolean;
   dataset_name?: string;
+  project_id?: string;
+  quality?: "light" | "medium" | "heavy";
+  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,
+    quality: req.quality,
+    type: req.type,
+    visibility: req.visibility,
+  });
 }
 
 // Records Generation
 export interface GenerateRecordsRequest {
   fields: RecordField[];
+  dataset_name?: string;
   num_examples?: number;
   domain_description?: string;
   seed?: number;
@@ -551,27 +977,46 @@ export interface GenerateRecordsRequest {
 
 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,
+  });
 }
 
 // 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;
 }
 
 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,
+  });
 }
 
 export interface LabelExistingFieldsRequest {
@@ -589,7 +1034,7 @@ export interface LabelExistingFieldsRequest {
 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 {
@@ -599,7 +1044,7 @@ 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);
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -609,9 +1054,9 @@ export async function inferFields(
 export interface TrainingJob {
   id: string;
   user_id: string;
+  project_id?: string;
   model_name?: string;
-  dataset_ids: string[];
-  train_dataset_paths: string[];
+  datasets: Array<{ name: string; version?: string }>;
   base_model: string;
   validation_data_percentage: number;
   nr_epochs: number;
@@ -619,12 +1064,22 @@ export interface TrainingJob {
   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 {
@@ -633,8 +1088,14 @@ export interface TrainingJobListResponse {
   count: number;
 }
 
-export async function listJobs(): Promise<ApiResult<TrainingJobListResponse>> {
-  return request<TrainingJobListResponse>("GET", "/felix/training-jobs");
+export async function listJobs(
+  options: { status?: string } = {}
+): Promise<ApiResult<TrainingJobListResponse>> {
+  const params = new URLSearchParams();
+  if (options.status) params.set("status", options.status);
+  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>> {
@@ -645,10 +1106,20 @@ 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(
@@ -661,15 +1132,15 @@ export interface TrainingLog {
   id: string;
   job_id: string;
   timestamp: string;
-  level: "INFO" | "WARNING" | "ERROR" | "DEBUG";
+  level: string;
   message: string;
-  source: "stdout" | "stderr";
+  source: string;
 }
 
 export interface TrainingLogsResponse {
-  success: boolean;
+  job_id: string;
   logs: TrainingLog[];
-  count: number;
+  total_logs: number;
 }
 
 export async function getJobLogs(
@@ -682,6 +1153,103 @@ 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
 // ─────────────────────────────────────────────────────────────────────────────
@@ -707,8 +1275,16 @@ export interface DeployedModelsListResponse {
   count: number;
 }
 
-export async function listModels(): Promise<ApiResult<DeployedModelsListResponse>> {
-  return request<DeployedModelsListResponse>("GET", "/felix/models");
+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 url = query ? `/felix/models?${query}` : "/felix/models";
+  return request<DeployedModelsListResponse>("GET", url);
 }
 
 export async function deleteModel(jobId: string): Promise<ApiResult> {
@@ -791,7 +1367,12 @@ export async function listAllModels(): Promise<ApiResult<AllModelsResponse>> {
 }
 
 export interface ModelDownloadResponse {
+  success?: boolean;
+  job_id?: string;
   download_url: string;
+  expires_in_seconds?: number;
+  file_name?: string;
+  message?: string;
 }
 
 export async function downloadModel(
@@ -804,41 +1385,231 @@ export async function downloadModel(
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
-// Evaluations
+// Inference
 // ─────────────────────────────────────────────────────────────────────────────
 
-export interface Evaluation {
-  id: string;
-  user_id: string;
-  dataset_id: string;
-  model_id?: string;
-  status: string;
-  results?: unknown;
-  created_at: string;
-  completed_at?: string;
-  predictions?: Array<Record<string, unknown>>;
+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;
 }
 
-export async function getEvaluation(
-  evalId: string
-): Promise<ApiResult<Evaluation>> {
-  return request<Evaluation>("GET", `/felix/evaluations/${evalId}`);
+export interface GenerateInferenceRequest {
+  model_id: string;
+  task: "generate";
+  messages: Array<{ role: "system" | "user" | "assistant"; content: string }>;
+  max_tokens?: number;
+  temperature?: number;
+  top_p?: number;
 }
 
-export interface EvaluationCreateRequest {
-  dataset: DatasetRef;
+export type InferenceRequest = EncoderInferenceRequest | GenerateInferenceRequest;
+
+export interface EncoderInferenceResponse {
+  type: "encoder";
+  result: Record<string, unknown> | unknown[];
   model_id: string;
+  latency_ms: number;
+  token_usage: number;
+  model_used: string;
+}
+
+export interface GenerateInferenceResponse {
+  type: "decoder";
+  completion: string;
+  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 BaseModelInfo {
+  id: string;
+  name?: string;
+  label?: string;
+  type: "encoder" | "decoder" | string;
+  description?: string;
+}
+
+export interface BaseModelsResponse {
+  models: BaseModelInfo[];
+}
+
+export async function listBaseModels(): Promise<
+  ApiResult<BaseModelsResponse | BaseModelInfo[]>
+> {
+  return request<BaseModelsResponse | BaseModelInfo[]>("GET", "/inference/base-models");
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Adaptive Fine-tuning
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface AdaptiveFinetuningHistoryItem {
+  role: "user" | "assistant" | "system" | string;
+  content: string;
+}
+
+export interface AdaptiveFinetuningQueryFilters {
+  start_time?: string;
+  end_time?: string;
+  project_id?: string;
+  model_id?: string;
+}
+
+export interface AdaptiveFinetuningChatRequest {
+  message: string;
+  conversation_id?: string;
+  history?: AdaptiveFinetuningHistoryItem[];
+  filters?: AdaptiveFinetuningQueryFilters;
+}
+
+export interface AdaptiveFinetuningChatResponse {
+  answer: string;
+  conversation_id: string;
+  tool_calls_made?: number;
+}
+
+export async function adaptiveFinetuningChat(
+  req: AdaptiveFinetuningChatRequest
+): Promise<ApiResult<AdaptiveFinetuningChatResponse>> {
+  return request<AdaptiveFinetuningChatResponse>("POST", "/adaptive-finetuning/chat", req);
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Decoder Generation
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface GenerateDecoderRequest {
+  domain_description: string;
+  instruction?: string;
+  num_examples?: number;
+  temperature?: number;
+  quality?: "light" | "medium" | "heavy";
+  constraints?: ConstraintRequest[];
+  save_dataset?: boolean;
+  dataset_name?: string;
+  project_id?: string;
+  session_id?: string;
+  config_num_examples?: number;
+  min_criteria?: number;
+  target_choices?: number;
+  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,
+    quality: req.quality,
+    constraints: req.constraints,
+    project_id: req.project_id,
+    session_id: req.session_id,
+    config_num_examples: req.config_num_examples,
+    min_criteria: req.min_criteria,
+    target_choices: req.target_choices,
+    type: req.type,
+    visibility: req.visibility,
+  });
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Evaluations
+// ─────────────────────────────────────────────────────────────────────────────
+
+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<Evaluation>> {
+): Promise<ApiResult<EvaluationCreateResponse>> {
   const { dataset, ...rest } = req;
-  return request<Evaluation>("POST", "/felix/evaluations", {
+  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,
   });
@@ -853,8 +1624,8 @@ export interface ModelWithEvaluation {
 
 export interface DatasetEvaluationsResponse {
   success: boolean;
-  dataset_id: string;
   dataset_name: string;
+  dataset_version: string;
   sample_count: number;
   models: ModelWithEvaluation[];
   count: number;
@@ -1088,13 +1859,15 @@ export interface HuggingFacePushRequest {
   hf_token: string;
   repo_id: string;
   private?: boolean;
+  commit_message?: string;
 }
 
 export interface HuggingFacePushResponse {
   success: boolean;
-  repo_url: string;
+  url: string;
   repo_id: string;
-  message?: string;
+  version: string;
+  message: string;
 }
 
 export async function pushDatasetToHub(
@@ -1112,13 +1885,15 @@ export interface HuggingFacePushModelRequest {
   hf_token: string;
   repo_id: string;
   private?: boolean;
+  commit_message?: string;
 }
 
 export interface HuggingFacePushModelResponse {
   success: boolean;
-  repo_url: string;
+  url: string;
   repo_id: string;
-  message?: string;
+  job_id: string;
+  message: string;
 }
 
 export async function pushModelToHub(
@@ -1133,26 +1908,737 @@ export async function pushModelToHub(
 }
 
 export interface HuggingFacePullRequest {
-  hf_token?: string;
   repo_id: string;
-  dataset_name?: 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 HuggingFacePullResponse {
+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;
+  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 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`
+  );
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 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`
+  );
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 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;
-  sample_count: number;
-  message?: string;
+  dataset_type: string;
+  description?: string;
+  sample_count?: number;
+  labels?: string[];
+  sample_rows?: Record<string, unknown>[];
+  winner?: LeaderboardEntry;
+  total_entries: number;
 }
 
-export async function pullDatasetFromHub(
-  options: HuggingFacePullRequest
-): Promise<ApiResult<HuggingFacePullResponse>> {
-  return request<HuggingFacePullResponse>(
+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",
-    "/felix/datasets/pull-from-hub",
-    options
+    `/leaderboard/datasets/${datasetId}/submit`,
+    submission
+  );
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Notebook Execution
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface CreateNotebookSessionRequest {
+  gpu?: string;
+  load_felix_helpers?: boolean;
+  auto_terminate_seconds?: number;
+  tags?: string[];
+}
+
+export interface CreateNotebookSessionResponse {
+  session_id: string;
+  gpu: string;
+  message: string;
+  status: "creating" | "ready";
+}
+
+export interface SessionStatusResponse {
+  session_id: string;
+  status: "creating" | "ready" | "failed";
+  error?: string;
+}
+
+export interface ExecuteOutput {
+  type: string;
+  name?: string;
+  text?: string;
+  data?: Record<string, string>;
+  ename?: string;
+  evalue?: string;
+  traceback?: string[];
+}
+
+export interface ExecuteCodeRequest {
+  code: string;
+  session_id?: string;
+  cell_id?: string;
+  include_variables?: boolean;
+  gpu?: string;
+  load_felix_helpers?: boolean;
+}
+
+export interface ExecuteCodeResponse {
+  success: boolean;
+  outputs: ExecuteOutput[];
+  variables: Record<string, unknown>;
+  execution_time_ms: number;
+  gpu_used?: string;
+  cell_id?: string;
+  session_id: string;
+  error?: string;
+  session_created?: boolean;
+}
+
+export interface NotebookSessionInfo {
+  session_id: string;
+  gpu: string;
+  created_at: string;
+  last_activity: string;
+  status: string;
+}
+
+export interface ListSessionsResponse {
+  sessions: NotebookSessionInfo[];
+}
+
+export async function createNotebookSession(
+  req?: CreateNotebookSessionRequest
+): Promise<ApiResult<CreateNotebookSessionResponse>> {
+  return request<CreateNotebookSessionResponse>(
+    "POST",
+    "/felix/notebook/sessions",
+    req ?? {}
+  );
+}
+
+export async function getNotebookSessionStatus(
+  sessionId: string
+): Promise<ApiResult<SessionStatusResponse>> {
+  return request<SessionStatusResponse>(
+    "GET",
+    `/felix/notebook/sessions/${sessionId}/status`
+  );
+}
+
+export async function listNotebookSessions(): Promise<ApiResult<ListSessionsResponse>> {
+  return request<ListSessionsResponse>("GET", "/felix/notebook/sessions");
+}
+
+export async function executeNotebookCode(
+  req: ExecuteCodeRequest
+): Promise<ApiResult<ExecuteCodeResponse>> {
+  return request<ExecuteCodeResponse>("POST", "/felix/notebook/execute", req);
+}
+
+export async function terminateNotebookSession(
+  sessionId: string
+): Promise<ApiResult<{ message: string }>> {
+  return request<{ message: string }>(
+    "DELETE",
+    `/felix/notebook/sessions/${sessionId}`
   );
 }