@fastino-ai/pioneer-cli 0.2.9 → 0.2.10

package/README.md

@@ -59,26 +59,37 @@ pioneer agent --mode research                       # Research mode (Pro subscri
 pioneer job list
 pioneer job get <id>
 pioneer job logs <id>
-pioneer job create --model-name "My Model" --dataset-ids ds_123,ds_456
+pioneer job delete <id>
+# To create a training job, use the agent — it will help you pick a base model
+# and datasets conversationally:
+pioneer agent
 
 # Models
-pioneer model endpoints list                          # List model catalog entries (/projects)
+pioneer model base-models                             # List available base models (tabular)
+pioneer model endpoints list                          # List model catalog entries
 pioneer model endpoints create                        # Create a model entry (interactive by default)
 pioneer model endpoints create --model "qwen/Qwen3-8B-Instruct" --repo https://github.com/fastino-ai/Pioneer
-pioneer model endpoints get <model-id>
+pioneer model endpoints get <model-id>                # Endpoint details (incl. attached dataset count)
 pioneer model endpoints update <model-id> --description "Updated model metadata"
 pioneer model endpoints delete <model-id>
-pioneer model endpoints dataset-count <model-id>
 pioneer model endpoints quality-metrics <model-id>
-pioneer model endpoints deploy <model-id> --job <training-job-id> [--reason "..." ]
+pioneer model endpoints deploy <model-id> [--job <training-job-id>] [--reason "..." ] [--all]
+                                                       # If --job is omitted, pick from a list of deployable jobs interactively.
+                                                       # The list is filtered to jobs whose base model matches the endpoint; pass --all to bypass that filter.
 pioneer model endpoints rollback <model-id> <deployment-id>
 
 pioneer model artifacts list                          # List trained and deployed artifacts
 pioneer model artifacts trained                       # List trained artifacts
 pioneer model artifacts deployed                      # List deployed artifacts
-pioneer model artifacts download <job-id>
+pioneer model artifacts download <job-id>             # Get a signed download URL for the artifact
 pioneer model artifacts upload <job-id> --to hf --repo username/model  # Push trained artifact to HF
 
+# Datasets
+pioneer dataset list                                  # List remote + local datasets (tabular)
+pioneer dataset get <name[:version]>                  # Dataset details (key/value layout)
+
+# Most read commands also accept --json for the raw JSON payload.
+
 # Aliases
 pioneer model_endpoints list
 pioneer model_artifacts list
@@ -129,14 +140,12 @@ pioneer agent
 
 ### Step 3: Create a Training Job
 
-Start training with one or more datasets:
+Use `pioneer agent` to create a training job. The agent will guide you through
+picking a base model, selecting datasets, and configuring hyperparameters
+without needing to remember flags or dataset IDs:
 
 ```bash
-pioneer job create \
-  --model-name "Medical NER Model v1" \
-  --dataset-ids "<dataset-id>" \
-  --base-model "fastino/gliner2-base-v1" \
-  --epochs 10
+pioneer agent
 ```
 
 ### Step 4: Monitor Training Progress

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastino-ai/pioneer-cli",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "description": "Pioneer CLI - AI training platform with chat agent",
   "type": "module",
   "files": [

package/src/api.ts

@@ -1271,10 +1271,12 @@ export interface TrainingJobListResponse {
 }
 
 export async function listJobs(
-  options: { status?: string } = {}
+  options: { status?: string; project_id?: string; limit?: number } = {}
 ): Promise<ApiResult<TrainingJobListResponse>> {
   const params = new URLSearchParams();
   if (options.status) params.set("status", options.status);
+  if (options.project_id) params.set("project_id", options.project_id);
+  if (options.limit !== undefined) params.set("limit", String(options.limit));
   const query = params.toString();
   const url = query ? `/felix/training-jobs?${query}` : "/felix/training-jobs";
   return request<TrainingJobListResponse>("GET", url);
@@ -1284,6 +1286,25 @@ export async function getJob(jobId: string): Promise<ApiResult<TrainingJob>> {
   return request<TrainingJob>("GET", `/felix/training-jobs/${jobId}`);
 }
 
+/**
+ * Assign (or unassign) a training job to a project. The deploy endpoint
+ * (`POST /projects/{id}/deployments`) requires the job's `project_id` to
+ * match the target project, so callers typically PATCH this before deploy.
+ *
+ * @param jobId Training job UUID.
+ * @param projectId Project UUID to attach to, or `null` to unassign.
+ */
+export async function updateTrainingJob(
+  jobId: string,
+  body: { project_id: string | null }
+): Promise<ApiResult<{ success?: boolean; message?: string }>> {
+  return request<{ success?: boolean; message?: string }>(
+    "PATCH",
+    `/felix/training-jobs/${jobId}`,
+    body
+  );
+}
+
 export interface TrainingJobCreateRequest {
   model_name: string;
   datasets: DatasetRef[];
@@ -1457,6 +1478,24 @@ export interface DeployedModelsListResponse {
   count: number;
 }
 
+interface AnthropicCompatibleModelEntry {
+  id?: string;
+  display_name?: string;
+  type?: string;
+  created_at?: string | null;
+  created?: number;
+  owned_by?: string;
+}
+
+interface AnthropicCompatibleModelsResponse {
+  data?: AnthropicCompatibleModelEntry[];
+}
+
+function isLikelyJobId(value: unknown): value is string {
+  if (typeof value !== "string") return false;
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+}
+
 export async function listModels(
   options: { includeBase?: boolean } = {}
 ): Promise<ApiResult<DeployedModelsListResponse>> {
@@ -1465,8 +1504,49 @@ export async function listModels(
     params.set("include_base", String(options.includeBase));
   }
   const query = params.toString();
-  const url = query ? `/felix/models?${query}` : "/felix/models";
-  return request<DeployedModelsListResponse>("GET", url);
+  const legacyUrl = query ? `/felix/models?${query}` : "/felix/models";
+  const legacy = await request<DeployedModelsListResponse>("GET", legacyUrl);
+  if (legacy.ok || legacy.status !== 404) {
+    return legacy;
+  }
+
+  // Backend removed /felix/models. Fall back to the canonical
+  // Anthropic/OpenAI-compatible catalog and adapt to DeployedModel.
+  const fallback = await request<AnthropicCompatibleModelsResponse>("GET", "/v1/models");
+  if (!fallback.ok) {
+    return {
+      ok: false,
+      status: fallback.status,
+      error: fallback.error ?? "Failed to list deployed models.",
+    };
+  }
+  const entries = fallback.data?.data ?? [];
+  const models: DeployedModel[] = entries
+    .filter((entry) => entry && (options.includeBase || entry.owned_by !== "anthropic"))
+    .map((entry) => {
+      const id = typeof entry.id === "string" ? entry.id : "";
+      return {
+        id,
+        job_id: isLikelyJobId(id) ? id : null,
+        model_name: entry.display_name || id || undefined,
+        is_base_model: entry.owned_by === "anthropic" || entry.owned_by === "openai",
+        deployed_at: entry.created_at ?? null,
+        last_used_at: null,
+        invocation_count: 0,
+        created_at: entry.created_at ?? null,
+        updated_at: entry.created_at ?? null,
+      };
+    });
+
+  return {
+    ok: true,
+    status: fallback.status,
+    data: {
+      success: true,
+      models,
+      count: models.length,
+    },
+  };
 }
 
 export async function deleteModel(jobId: string): Promise<ApiResult> {
@@ -1678,12 +1758,20 @@ export interface BaseModelInfo {
   id: string;
   name?: string;
   label?: string;
-  type?: "encoder" | "decoder" | string;
+  /**
+   * One of "encoder" | "decoder" — the architectural family of the model.
+   * Note: backend used to expose this as `type`; the field is now `task_type`.
+   */
   task_type?: string;
   supports_inference?: boolean;
   supports_on_demand_inference?: boolean;
   supports_training?: boolean;
   description?: string;
+  tier?: "enterprise" | "open" | string;
+  context_window?: number;
+  license?: string;
+  input_price_per_million?: number;
+  output_price_per_million?: number;
 }
 
 export interface BaseModelsResponse {
@@ -2820,10 +2908,23 @@ export interface ProjectDeploymentCreate {
 }
 
 export interface ProjectDeploymentResponse {
-  success: boolean;
-  message?: string;
+  /** Deployment record id. */
+  id?: string;
   project_id?: string;
-  training_job_id?: string;
+  /** Set when a fine-tuned checkpoint was deployed. */
+  training_job_id?: string | null;
+  /**
+   * Set to the stock HuggingFace base model id when a base-model deploy was
+   * performed. May also be populated for training-job deploys (post backend
+   * enrichment) so the record always carries "what stock model is serving".
+   */
+  base_model?: string | null;
+  deployed_by?: string;
+  reason?: string;
+  deployed_at?: string;
+  // Legacy/optional fields kept for older response shapes.
+  success?: boolean;
+  message?: string;
   deployment_id?: string;
 }