openpond 0.0.69 → 0.1.0

package/dist/chunks/{chunk-NPNIL6SQ.js → chunk-AN2EYCN3.js}

@@ -3,7 +3,7 @@ import { createRequire as __openpondCreateRequire } from "node:module"; var requ
 // ../server/src/constants.ts
 var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_PORT = 17874;
-var VERSION = "0.0.69";
+var VERSION = "0.1.0";
 var HOSTED_CHAT_SYSTEM_PROMPT = "You are OpenPond Chat. Respond in the user's language. If the user's latest message is language-neutral, ambiguous, or only a short test, respond in English. Be concise and directly answer the latest request. Do not use emojis. Use Markdown when it improves scanability. If you emit reasoning or thinking content, keep it sparse and user-readable: at most one short sentence for major progress, decisions, or blockers. Omit reasoning for routine searches, reads, tool calls, and obvious next steps. Do not restate the user request, narrate every action, or include code blocks, code excerpts, diffs, raw tool payloads, or markdown examples in reasoning. Put necessary code or exact snippets only in the final assistant answer. When the user asks to show or preview an image that is available as a workspace path or signed image URL, use Markdown image syntax like ![description](path-or-url) instead of a bare path or raw HTML. For workspace-backed answers, use a Codex-style shape: brief outcome first, then Changed Files if files changed, then Verification if checks ran. End with a concise final answer that summarizes the result and verification when relevant. Do not mention raw tool JSON, internal repo paths, or origin/remote URLs unless the user explicitly asks for them or they are necessary to explain a git/deploy failure.";
 var APP_PREFERENCES_CACHE_TYPE = "app_preferences";
 var APP_PREFERENCES_CACHE_KEY = "global";

package/dist/chunks/{chunk-F36ZVO6U.js → chunk-CNTM26OW.js}

@@ -28,7 +28,7 @@ import {
   compareSemver,
   fetchLatestNpmVersion,
   getInstalledCliVersion
-} from "./chunk-Y57RTLVV.js";
+} from "./chunk-N3TGCM7J.js";
 import {
   checkOpenPondApiHealth,
   createHeadlessApps,

package/dist/chunks/{chunk-FEOLMLYU.js → chunk-EFET7LB7.js}

@@ -12,7 +12,7 @@ import {
   saveConfig,
   saveProfileApiKey,
   setActiveProfile
-} from "./chunk-MMRJNSWY.js";
+} from "./chunk-6G6MDZLM.js";
 import {
   DEFAULT_OPENPOND_API_BASE_URL,
   DEFAULT_OPENPOND_WEB_BASE_URL
@@ -177,8 +177,9 @@ function findActiveAccount(config, requestedHandle, requestedBaseUrl) {
     if (exact)
       return exact;
     const sameHandle = accounts.filter((account) => handleEquals(account.handle, requestedProfile.handle));
-    if (!selectorBaseUrl(requestedProfile) && sameHandle.length === 1)
+    if (sameHandle.length === 1)
       return sameHandle[0] ?? null;
+    return null;
   }
   if (accounts[0])
     return accounts[0];
@@ -1186,6 +1187,23 @@ async function removeOpenPondAccount(input) {
   return loadOpenPondAccountContext();
 }
 
+// ../../packages/runtime/dist/sign-out-account.js
+async function signOutOpenPondAccount() {
+  const config = await loadGlobalConfig();
+  const activeProfile = normalizeActiveProfile(config.activeProfile);
+  const accounts = (config.accounts ?? []).map((account) => ({ ...account }));
+  const activeIndex = activeProfile ? accounts.findIndex((account) => accountMatchesSelector(account, activeProfile)) : 0;
+  if (activeIndex < 0 || !accounts[activeIndex]) {
+    throw new Error("No active OpenPond account to log out.");
+  }
+  const signedOutAccount = { ...accounts[activeIndex] };
+  delete signedOutAccount.apiKey;
+  delete signedOutAccount.session;
+  accounts[activeIndex] = signedOutAccount;
+  await saveConfig({ ...config, accounts });
+  return loadOpenPondAccountContext(signedOutAccount.handle, signedOutAccount.baseUrl);
+}
+
 // ../../packages/runtime/dist/update-account-config.js
 function findAccountIndex2(accounts, handle, currentBaseUrl) {
   const normalizedCurrentBaseUrl = normalizeBaseUrl(currentBaseUrl);
@@ -1304,6 +1322,7 @@ export {
   streamOpenPondHostedChatTurn,
   saveOpenPondAccount,
   removeOpenPondAccount,
+  signOutOpenPondAccount,
   updateOpenPondAccountConfig,
   getOpenPondAppEnvironment,
   getBundledRuntimeVersion,

package/dist/chunks/{training-5CPTZRVC.js → chunk-J7PYGDRY.js}

@@ -2,18 +2,17 @@ import { createRequire as __openpondCreateRequire } from "node:module"; var requ
 import {
   resolveApiBaseUrlOption
 } from "./chunk-SMNFI2FU.js";
-import "./chunk-KSRWKXRB.js";
 import {
   optionString,
   parseBooleanOption,
   parseIntegerOption,
   parseNumberOption
 } from "./chunk-MUMPWI4O.js";
-import "./chunk-UACZUFIA.js";
 
 // src/cli/training.ts
 import { readFile } from "node:fs/promises";
 import { request as requestHttp } from "node:http";
+import { randomUUID } from "node:crypto";
 import os from "node:os";
 import path from "node:path";
 import { createInterface } from "node:readline/promises";
@@ -35,12 +34,13 @@ async function runTrainingCommand(options, rest, dependencies = {}) {
     "cancel",
     "resume",
     "artifacts",
-    "benchmark"
+    "benchmark",
+    "create-project"
   ].includes(
     subcommand
   ) || !id) {
     throw new Error(
-      "usage: training <start|status|watch|logs|cancel|resume|artifacts|benchmark> <model-run-id|run-id|model-id>"
+      "usage: training <create-project|start|status|watch|logs|cancel|resume|artifacts|benchmark> <taskset-id|model-run-id|run-id|model-id>"
     );
   }
   if (rest.length > 2) {
@@ -52,6 +52,15 @@ async function runTrainingCommand(options, rest, dependencies = {}) {
     request: dependencies.request ?? await createLocalAuthenticatedRequest(baseUrl)
   });
   const json = parseBooleanOption(options.json);
+  if (subcommand === "create-project") {
+    const project = await createManagedModelProject({
+      client,
+      options,
+      tasksetId: id
+    });
+    printResult(project, json);
+    return;
+  }
   if (subcommand === "benchmark") {
     await startHarnessRefinerBenchmark({
       client,
@@ -193,6 +202,20 @@ var TrainingApiClient = class {
       body
     );
   }
+  prepareModelProject(id, body) {
+    return this.json(
+      `/v1/training/model-projects/${encodeURIComponent(id)}/training/prepare`,
+      "POST",
+      body
+    );
+  }
+  startModelProject(id, body) {
+    return this.json(
+      `/v1/training/model-projects/${encodeURIComponent(id)}/training/start`,
+      "POST",
+      body
+    );
+  }
   trainingState() {
     return this.json("/v1/training", "GET");
   }
@@ -203,6 +226,28 @@ var TrainingApiClient = class {
       body
     );
   }
+  importTasksetDraftPackage(body) {
+    return this.json("/v1/training/taskset-drafts/import", "POST", body);
+  }
+  publishTasksetDraft(draftId, modelId) {
+    return this.json(
+      `/v1/training/taskset-drafts/${encodeURIComponent(draftId)}/publish`,
+      "POST",
+      modelId ? { modelId } : {}
+    );
+  }
+  tasksetReadiness(tasksetId) {
+    return this.json("/v1/training/readiness", "POST", { tasksetId });
+  }
+  deleteTasksetDraft(draftId) {
+    return this.json(
+      `/v1/training/taskset-drafts/${encodeURIComponent(draftId)}`,
+      "DELETE"
+    );
+  }
+  saveModelProject(project) {
+    return this.json("/v1/training/models", "PUT", project);
+  }
   async json(pathname, method, body) {
     const response = await this.request(`${this.baseUrl}${pathname}`, {
       method,
@@ -231,9 +276,9 @@ var TrainingApiClient = class {
 async function startHarnessRefinerBenchmark(input) {
   const state = await input.client.trainingState();
   const project = modelProject(state, input.modelId);
-  const providerId = optionString(input.options, "provider") ?? "openpond";
-  const modelId = optionString(input.options, "model") ?? "openpond-chat";
-  const effort = optionString(input.options, "reasoningEffort") ?? "high";
+  const providerId = optionString(input.options, "provider") || "openpond";
+  const modelId = optionString(input.options, "model") || "openpond-chat";
+  const effort = optionString(input.options, "reasoningEffort") || "high";
   const maximumSpendUsd = parseNumberOption(input.options.maxSpend, "max-spend") ?? 10;
   if (maximumSpendUsd <= 0) throw new Error("max-spend must be greater than zero");
   if (parseBooleanOption(input.options.detach)) {
@@ -273,6 +318,188 @@ function objectString(value, key) {
   const candidate = value[key];
   return typeof candidate === "string" && candidate ? candidate : null;
 }
+async function createManagedModelProject(input) {
+  const recipePath = optionString(input.options, "recipe");
+  if (!recipePath) {
+    throw new Error("training create-project requires --recipe <versioned-recipe.json>");
+  }
+  const recipe = await readJsonObject(recipePath, "Training recipe");
+  const state = await input.client.trainingState();
+  const taskset = trainingStateRecord(state, "tasksets", input.tasksetId, "Taskset");
+  const profileId = optionString(input.options, "profile") || objectString(taskset, "profileId");
+  if (!profileId) {
+    throw new Error(
+      `The Taskset has no Profile id (received ${typeof taskset.profileId}: ${String(taskset.profileId)}).`
+    );
+  }
+  const tasksetProfileId = objectString(taskset, "profileId");
+  if (tasksetProfileId !== profileId) {
+    throw new Error(
+      `Taskset ${input.tasksetId} belongs to Profile ${tasksetProfileId ?? "unknown"}, not ${profileId}.`
+    );
+  }
+  const projectId = optionString(input.options, "projectId") || `model_${randomUUID()}`;
+  const projects = trainingStateRecords(state, "modelProjects");
+  const existingProject = projects.find(
+    (project) => objectString(project, "id") === projectId
+  );
+  const rolloutPlacement = enumOption(
+    input.options,
+    "rolloutPlacement",
+    ["local", "remote"],
+    "local"
+  );
+  const gpuPlacementObjective = enumOption(
+    input.options,
+    "gpuPlacementObjective",
+    ["fast", "balanced", "economical"],
+    "balanced"
+  );
+  const runPreset = enumOption(
+    input.options,
+    "runPreset",
+    ["small", "standard", "custom", "small_experiment"],
+    "custom"
+  );
+  const maximumSpendUsd = parseNumberOption(input.options.maxSpend, "max-spend") ?? null;
+  if (maximumSpendUsd !== null && maximumSpendUsd < 0) {
+    throw new Error("max-spend must be non-negative");
+  }
+  const retentionDays = parseIntegerOption(
+    input.options.retentionDays,
+    "retention-days"
+  ) ?? null;
+  if (retentionDays !== null && retentionDays < 0) {
+    throw new Error("retention-days must be non-negative");
+  }
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const contentHash = objectString(taskset, "contentHash");
+  const revision = objectNumber(taskset, "revision");
+  if (!contentHash || !revision || revision < 1) {
+    throw new Error("The Taskset does not have an immutable published revision.");
+  }
+  const method = objectString(recipe, "method");
+  if (!method) throw new Error("Training recipe must declare its method.");
+  const baseModel = managedBasePreferenceFromRecipe(recipe);
+  if (existingProject) {
+    const existingSetup = objectRecord(existingProject, "trainingSetup");
+    const existingTasksetRef = objectRecord(existingSetup, "tasksetRef");
+    if (objectString(existingTasksetRef, "id") !== input.tasksetId || objectString(existingProject, "profileId") !== profileId) {
+      throw new Error(
+        `Model Project ${projectId} already exists for a different Profile or Taskset.`
+      );
+    }
+    if (objectRecord(existingSetup, "baseModel")) {
+      throw new Error(`Model Project ${projectId} already exists.`);
+    }
+    return input.client.saveModelProject({
+      ...existingProject,
+      revision: objectNumber(existingProject, "revision") ?? 1,
+      defaultBaseModel: baseModel,
+      trainingSetup: {
+        ...existingSetup,
+        baseModel,
+        recipe
+      },
+      updatedAt: timestamp
+    });
+  }
+  return input.client.saveModelProject({
+    schemaVersion: "openpond.modelProject.v2",
+    id: projectId,
+    profileId,
+    revision: 1,
+    name: optionString(input.options, "name") || objectString(taskset, "name") || "Managed Model",
+    objective: optionString(input.options, "objective") || objectString(taskset, "objective"),
+    defaultBaseModel: baseModel,
+    defaultDestinationId: optionString(input.options, "destination") || "openpond_managed",
+    trainingSetup: {
+      tasksetRef: { id: input.tasksetId, revision, contentHash },
+      tasksetRelease: null,
+      harnessRelease: null,
+      baseModel,
+      method,
+      destinationId: optionString(input.options, "destination") || "openpond_managed",
+      managedRolloutPlacement: rolloutPlacement,
+      managedGpuPlacementObjective: gpuPlacementObjective,
+      managedGpuRequirement: "any",
+      runPreset,
+      recipe,
+      preferredMaximumSpendUsd: maximumSpendUsd,
+      preferredRetentionDays: retentionDays
+    },
+    hosted: null,
+    tasksetSyncs: [],
+    createdAt: timestamp,
+    updatedAt: timestamp
+  });
+}
+function managedBasePreferenceFromRecipe(recipe) {
+  const recipeBase = objectRecord(recipe, "baseModel");
+  const modelId = objectString(recipeBase, "id");
+  const revision = objectString(recipeBase, "revision");
+  const tokenizerRevision = objectString(recipeBase, "tokenizerRevision");
+  const chatTemplateHash = objectString(recipeBase, "chatTemplateHash");
+  if (!modelId || !revision || !tokenizerRevision || !chatTemplateHash) {
+    throw new Error(
+      "Managed GRPO recipe must pin baseModel id, revision, tokenizerRevision, and chatTemplateHash."
+    );
+  }
+  return {
+    schemaVersion: "openpond.baseModelPreference.v1",
+    modelId,
+    revision,
+    tokenizerRevision,
+    chatTemplateHash,
+    modelAssetId: null,
+    source: "managed"
+  };
+}
+function trainingStateRecord(state, key, id, label) {
+  const match = trainingStateRecords(state, key).find(
+    (candidate) => objectString(candidate, "id") === id
+  );
+  if (!match) throw new Error(`${label} ${id} was not found.`);
+  return match;
+}
+function trainingStateRecords(state, key) {
+  if (!state || typeof state !== "object" || !(key in state)) return [];
+  const value = state[key];
+  return Array.isArray(value) ? value.filter(
+    (candidate) => Boolean(candidate) && typeof candidate === "object" && !Array.isArray(candidate)
+  ) : [];
+}
+function objectNumber(value, key) {
+  if (!value || typeof value !== "object" || !(key in value)) return null;
+  const candidate = value[key];
+  return typeof candidate === "number" && Number.isFinite(candidate) ? candidate : null;
+}
+function objectRecord(value, key) {
+  if (!value || typeof value !== "object" || !(key in value)) return null;
+  const candidate = value[key];
+  return candidate && typeof candidate === "object" && !Array.isArray(candidate) ? candidate : null;
+}
+function enumOption(options, key, values, fallback) {
+  const value = optionString(options, key) || fallback;
+  if (!values.includes(value)) {
+    throw new Error(`${key} must be one of ${values.join(", ")}`);
+  }
+  return value;
+}
+async function readJsonObject(file, label) {
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(file, "utf8"));
+  } catch (error) {
+    throw new Error(
+      `Could not read ${label} ${file}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`${label} must be a JSON object.`);
+  }
+  return parsed;
+}
 async function startTraining(input) {
   const maximumSpendUsd = parseNumberOption(
     input.options.maxSpend,
@@ -287,11 +514,13 @@ async function startTraining(input) {
   }
   const manifestPath = optionString(input.options, "manifest");
   const manifest = manifestPath ? await readManifest(manifestPath) : void 0;
+  const comparisonSeriesEntryId = optionString(
+    input.options,
+    "comparisonSeriesEntry"
+  ) || null;
   const controls = { maximumSpendUsd, retentionDays };
-  const preparation = await input.client.modelRun(
+  const preparation = await input.client.prepareModelProject(
     input.modelRunId,
-    "prepare",
-    "POST",
     controls
   );
   if (!input.json) {
@@ -302,11 +531,14 @@ async function startTraining(input) {
   if (!confirmed) {
     throw new Error("Training start cancelled.");
   }
-  const result = await input.client.modelRun(
+  const result = await input.client.startModelProject(
     input.modelRunId,
-    "start",
-    "POST",
-    { ...controls, manifest }
+    {
+      ...controls,
+      exportApproved: parseBooleanOption(input.options.exportApproved),
+      manifest,
+      comparisonSeriesEntryId
+    }
   );
   printResult(result, input.json);
   if (parseBooleanOption(input.options.detach)) return;
@@ -393,7 +625,10 @@ function printResult(value, json) {
   }
   console.log(JSON.stringify(value, null, 2));
 }
+
 export {
-  TrainingApiClient,
-  runTrainingCommand
+  DEFAULT_LOCAL_TRAINING_API_URL,
+  runTrainingCommand,
+  createLocalAuthenticatedRequest,
+  TrainingApiClient
 };