antpath 0.10.15 → 0.11.4

package/dist/cli.mjs

@@ -58,8 +58,6 @@ var TERMINAL_RUN_STATUSES = [
 var terminalRunStatuses = new Set(TERMINAL_RUN_STATUSES);
 
 // ../shared/dist/blueprint.js
-var SKILL_ID_PATTERN = /^skl_[A-Za-z0-9_-]{8,128}$/;
-var SKILL_NAME_PATTERN = /^[a-z0-9][a-z0-9_-]{0,127}$/;
 var SKILL_BUNDLE_LIMITS = {
   /** Compressed (.zip) ceiling. */
   maxCompressedBytes: 10 * 1024 * 1024,
@@ -76,26 +74,14 @@ var SKILL_BUNDLE_LIMITS = {
   /** Stored directory mode. */
   defaultDirMode: 493
 };
-var TRANSIENT_SLOT_PATTERN = /^[a-z][a-z0-9_-]{0,63}$/;
-var TRANSIENT_CONTENT_HASH_PATTERN = /^sha256:[0-9a-f]{64}$/;
-function parseSkillRef(input, path, options = {}) {
+var INLINE_CONTENT_HASH_PATTERN = /^sha256:[0-9a-f]{64}$/;
+var R2_ASSET_PATH_PATTERN = /^assets\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\/[0-9a-f]{64}$/;
+function parseSkillRef(input, path) {
   if (input === null || typeof input !== "object" || Array.isArray(input)) {
     throw new Error(`${path} must be a SkillRef object`);
   }
   const record = input;
   const kind = record.kind;
-  if (kind === "workspace") {
-    for (const key of Object.keys(record)) {
-      if (key !== "kind" && key !== "id") {
-        throw new Error(`${path} contains unexpected field for workspace SkillRef: ${key}`);
-      }
-    }
-    const id = record.id;
-    if (typeof id !== "string" || !SKILL_ID_PATTERN.test(id)) {
-      throw new Error(`${path}.id must match ${SKILL_ID_PATTERN.source}`);
-    }
-    return { kind: "workspace", id };
-  }
   if (kind === "provider") {
     for (const key of Object.keys(record)) {
       if (key !== "kind" && key !== "vendor" && key !== "skillId" && key !== "version") {
@@ -121,30 +107,50 @@ function parseSkillRef(input, path, options = {}) {
       ...version !== void 0 ? { version } : {}
     };
   }
-  if (kind === "transient") {
-    if (options.allowTransient === false) {
-      throw new Error(`${path} carries a transient SkillRef, which cannot round-trip through JSON \u2014 transient skills must be supplied at submitRun time with their bytes attached`);
-    }
-    for (const key of Object.keys(record)) {
-      if (key !== "kind" && key !== "slot" && key !== "name" && key !== "contentHash") {
-        throw new Error(`${path} contains unexpected field for transient SkillRef: ${key}`);
-      }
-    }
-    const slot = record.slot;
-    if (typeof slot !== "string" || !TRANSIENT_SLOT_PATTERN.test(slot)) {
-      throw new Error(`${path}.slot must match ${TRANSIENT_SLOT_PATTERN.source}`);
-    }
-    const name = record.name;
-    if (typeof name !== "string" || !SKILL_NAME_PATTERN.test(name)) {
-      throw new Error(`${path}.name must match ${SKILL_NAME_PATTERN.source}`);
-    }
-    const contentHash = record.contentHash;
-    if (typeof contentHash !== "string" || !TRANSIENT_CONTENT_HASH_PATTERN.test(contentHash)) {
-      throw new Error(`${path}.contentHash must match ${TRANSIENT_CONTENT_HASH_PATTERN.source}`);
+  if (kind === "r2") {
+    return parseR2RefFields(record, path);
+  }
+  throw new Error(`${path}.kind must be 'provider' or 'r2'`);
+}
+function parseR2RefFields(record, path) {
+  for (const key of Object.keys(record)) {
+    if (key !== "kind" && key !== "path" && key !== "hash" && key !== "sizeBytes" && key !== "name" && key !== "mountPath") {
+      throw new Error(`${path} contains unexpected field for r2 ref: ${key}`);
     }
-    return { kind: "transient", slot, name, contentHash };
   }
-  throw new Error(`${path}.kind must be 'workspace', 'provider', or 'transient'`);
+  const r2Path = record.path;
+  if (typeof r2Path !== "string" || !R2_ASSET_PATH_PATTERN.test(r2Path)) {
+    throw new Error(`${path}.path must match ${R2_ASSET_PATH_PATTERN.source}`);
+  }
+  const hash = record.hash;
+  if (typeof hash !== "string" || !INLINE_CONTENT_HASH_PATTERN.test(hash)) {
+    throw new Error(`${path}.hash must match ${INLINE_CONTENT_HASH_PATTERN.source}`);
+  }
+  const pathHash = r2Path.slice(r2Path.length - 64);
+  const hashHex = hash.slice("sha256:".length);
+  if (pathHash !== hashHex) {
+    throw new Error(`${path}.path hash segment does not match ${path}.hash`);
+  }
+  const sizeBytes = record.sizeBytes;
+  if (typeof sizeBytes !== "number" || !Number.isInteger(sizeBytes) || sizeBytes <= 0) {
+    throw new Error(`${path}.sizeBytes must be a positive integer`);
+  }
+  const name = record.name;
+  if (typeof name !== "string" || name.length === 0 || name.length > 128) {
+    throw new Error(`${path}.name must be a non-empty string (<= 128 chars)`);
+  }
+  const mountPath = record.mountPath;
+  if (mountPath !== void 0 && (typeof mountPath !== "string" || mountPath.length === 0)) {
+    throw new Error(`${path}.mountPath, when provided, must be a non-empty string`);
+  }
+  return {
+    kind: "r2",
+    path: r2Path,
+    hash,
+    sizeBytes,
+    name,
+    ...mountPath !== void 0 ? { mountPath } : {}
+  };
 }
 var SkillBundleValidationError = class extends Error {
   constructor(message) {
@@ -205,15 +211,19 @@ function validateSkillBundleEntry(input) {
   }
   return { path, size: input.size, mode };
 }
+var REMOTE_MCP_TRANSPORTS = ["http", "sse"];
+var REMOTE_MCP_STDIO_REJECTED_MESSAGE = "stdio MCP servers are not supported by Antpath. Antpath supports remote MCP servers over HTTP/SSE only.";
+var STDIO_ONLY_FIELDS = ["command", "args", "env"];
 var MCP_SERVER_NAME_PATTERN = /^[a-z][a-z0-9_-]{0,62}$/;
 function parseMcpServerRef(input, path) {
   if (input === null || typeof input !== "object" || Array.isArray(input)) {
     throw new Error(`${path} must be an object`);
   }
   const record = input;
+  rejectStdioMcpShape(record);
   for (const key of Object.keys(record)) {
-    if (key !== "name" && key !== "url") {
-      throw new Error(`${path}.${key} is not an allowed field for McpServerRef; permitted: name, url`);
+    if (key !== "name" && key !== "url" && key !== "transport") {
+      throw new Error(`${path}.${key} is not an allowed field for McpServerRef; permitted: name, url, transport`);
     }
   }
   const name = record.name;
@@ -238,19 +248,42 @@ function parseMcpServerRef(input, path) {
     }
     throw new Error(`${path}.url is not a valid URL: ${url}`);
   }
-  return { name, url };
+  const transport = parseRemoteMcpTransport(record.transport, `${path}.transport`);
+  return transport ? { name, url, transport } : { name, url };
+}
+function rejectStdioMcpShape(record) {
+  if (record.transport === "stdio") {
+    throw new Error(REMOTE_MCP_STDIO_REJECTED_MESSAGE);
+  }
+  for (const field of STDIO_ONLY_FIELDS) {
+    if (record[field] !== void 0) {
+      throw new Error(REMOTE_MCP_STDIO_REJECTED_MESSAGE);
+    }
+  }
+}
+function parseRemoteMcpTransport(input, field) {
+  if (input === void 0) {
+    return void 0;
+  }
+  if (typeof input !== "string" || !REMOTE_MCP_TRANSPORTS.includes(input)) {
+    throw new Error(`${field} must be one of: ${REMOTE_MCP_TRANSPORTS.join(", ")} (got ${JSON.stringify(input)})`);
+  }
+  return input;
 }
 function parseBlueprintMcpServerRef(input, path) {
   if (input === null || typeof input !== "object" || Array.isArray(input)) {
     throw new Error(`${path} must be an object`);
   }
   const record = input;
+  rejectStdioMcpShape(record);
   for (const key of Object.keys(record)) {
-    if (key !== "name" && key !== "url" && key !== "headers") {
-      throw new Error(`${path}.${key} is not an allowed field for BlueprintMcpServer; permitted: name, url, headers`);
+    if (key !== "name" && key !== "url" && key !== "headers" && key !== "transport") {
+      throw new Error(`${path}.${key} is not an allowed field for BlueprintMcpServer; permitted: name, url, transport, headers`);
     }
   }
   const stripped = { name: record.name, url: record.url };
+  if (record.transport !== void 0)
+    stripped.transport = record.transport;
   const ref = parseMcpServerRef(stripped, path);
   const rawHeaders = record.headers;
   if (rawHeaders === void 0) {
@@ -307,7 +340,7 @@ function parseBlueprint(input) {
     ...skills !== void 0 ? { skills } : {},
     ...mcpServers !== void 0 ? { mcpServers } : {},
     // environment / cleanup / proxyEndpoints / metadata: passed through
-    // as-is — the BFF revalidates them via `parseFlatRunSubmissionRequest`,
+    // as-is — the BFF revalidates them via `parseRunSubmissionRequest`,
     // so duplicating the heavyweight parsers here would mean two sources
     // of truth. The CLI surfaces structural errors at submission time.
     ...record.environment !== void 0 ? { environment: record.environment } : {},
@@ -346,7 +379,7 @@ function parseBlueprintSkills(value) {
   if (!Array.isArray(value)) {
     throw new Error("Blueprint.skills must be an array");
   }
-  return value.map((item, index) => parseSkillRef(item, `Blueprint.skills[${index}]`, { allowTransient: false }));
+  return value.map((item, index) => parseSkillRef(item, `Blueprint.skills[${index}]`));
 }
 function parseBlueprintMcpServers(value) {
   if (value === void 0) {
@@ -367,6 +400,15 @@ function parseBlueprintMcpServers(value) {
 }
 
 // ../shared/dist/submission.js
+var RUN_PROVIDERS = [
+  "anthropic",
+  "deepseek",
+  "openai",
+  "gemini",
+  "mistral"
+];
+var DEFAULT_RUN_PROVIDER = "anthropic";
+var RUNTIME_KINDS = ["native", "managed"];
 var PROXY_ENDPOINT_DEFAULTS = {
   allowHeaders: [],
   responseMode: "headers_only",
@@ -377,9 +419,22 @@ var PROXY_ENDPOINT_DEFAULTS = {
   responseByteBudget: 1024 * 1024
 };
 
+// ../shared/dist/runtime-manifest.js
+var ANTHROPIC_PATHS = Object.freeze({
+  skillsRoot: "/workspace/skills",
+  filesRoot: "/mnt/session/uploads/antpath/files",
+  assetsRoot: "/mnt/session/uploads/antpath/assets",
+  outputsRoot: "/mnt/session/outputs",
+  antpathCli: "/mnt/session/uploads/antpath/antpath",
+  indexJson: "/mnt/session/uploads/antpath/index.json",
+  readme: "/mnt/session/uploads/antpath/SKILLS.md",
+  runtimeJson: "/mnt/session/uploads/antpath/RUNTIME.json",
+  runtimeEnv: "/mnt/session/uploads/antpath/RUNTIME.env"
+});
+
 // ../shared/dist/stable.js
 import { createHash } from "node:crypto";
-var ANTPATH_DEFAULT_BASE_URL = "https://www.antpath.ai";
+var ANTPATH_DEFAULT_BASE_URL = "https://api.antpath.ai";
 
 // ../shared/dist/sdk-secrets.js
 var SECRET_PATTERNS = [
@@ -553,8 +608,7 @@ __export(operations_exports, {
   listSkills: () => listSkills,
   streamRunEventsSse: () => streamRunEventsSse,
   submitRun: () => submitRun,
-  submitRunFlat: () => submitRunFlat,
-  submitRunFlatMultipart: () => submitRunFlatMultipart,
+  submitRunMultipart: () => submitRunMultipart,
   whoami: () => whoami
 });
 
@@ -727,12 +781,6 @@ function findLineBreak(buffer) {
 }
 
 // ../shared/dist/operations.js
-async function submitRun(http, request) {
-  return http.request("/api/runs", {
-    method: "POST",
-    body: JSON.stringify(request)
-  });
-}
 async function getRun(http, runId) {
   const result = await http.request(`/api/runs/${encodeURIComponent(runId)}`);
   return hasRun(result) ? result.run : result;
@@ -883,28 +931,28 @@ async function downloadRunArchive(http, runId) {
   const { response } = await http.download(`/api/runs/${encodeURIComponent(runId)}/download`);
   return response;
 }
-async function submitRunFlat(http, request) {
+async function submitRun(http, request) {
   return http.request("/api/runs", {
     method: "POST",
     body: JSON.stringify(request)
   });
 }
-async function submitRunFlatMultipart(http, request, bundles, agentsMdParts, fileParts) {
+async function submitRunMultipart(http, request, bundles, agentsMdParts, fileParts) {
   const hasBundles = Array.isArray(bundles) && bundles.length > 0;
   const hasAgentsMd = Array.isArray(agentsMdParts) && agentsMdParts.length > 0;
   const hasFiles = Array.isArray(fileParts) && fileParts.length > 0;
   if (!hasBundles && !hasAgentsMd && !hasFiles) {
-    throw new Error("submitRunFlatMultipart: bundles, agentsMdParts, or fileParts must be non-empty");
+    throw new Error("submitRunMultipart: bundles, agentsMdParts, or fileParts must be non-empty");
   }
   const form = new FormData();
   form.append("submission", new Blob([JSON.stringify(request)], { type: "application/json" }), "submission.json");
   const seen = /* @__PURE__ */ new Set();
   for (const bundle of bundles) {
     if (typeof bundle.slot !== "string" || !bundle.slot) {
-      throw new Error("submitRunFlatMultipart: each bundle must have a non-empty slot id");
+      throw new Error("submitRunMultipart: each bundle must have a non-empty slot id");
     }
     if (seen.has(bundle.slot)) {
-      throw new Error(`submitRunFlatMultipart: duplicate transient skill slot "${bundle.slot}"`);
+      throw new Error(`submitRunMultipart: duplicate inline skill slot "${bundle.slot}"`);
     }
     seen.add(bundle.slot);
     const blob = toBlob(bundle.bytes, "application/zip");
@@ -912,11 +960,11 @@ async function submitRunFlatMultipart(http, request, bundles, agentsMdParts, fil
   }
   for (const part of agentsMdParts ?? []) {
     if (typeof part.slot !== "string" || !part.slot) {
-      throw new Error("submitRunFlatMultipart: each agentsMd part must have a non-empty slot id");
+      throw new Error("submitRunMultipart: each agentsMd part must have a non-empty slot id");
     }
     const partKey = `agentsmd:${part.slot}`;
     if (seen.has(partKey)) {
-      throw new Error(`submitRunFlatMultipart: duplicate agentsMd slot "${part.slot}"`);
+      throw new Error(`submitRunMultipart: duplicate agentsMd slot "${part.slot}"`);
     }
     seen.add(partKey);
     const blob = new Blob([part.content], { type: "text/plain" });
@@ -924,11 +972,11 @@ async function submitRunFlatMultipart(http, request, bundles, agentsMdParts, fil
   }
   for (const part of fileParts ?? []) {
     if (typeof part.slot !== "string" || !part.slot) {
-      throw new Error("submitRunFlatMultipart: each file part must have a non-empty slot id");
+      throw new Error("submitRunMultipart: each file part must have a non-empty slot id");
     }
     const partKey = `file:${part.slot}`;
     if (seen.has(partKey)) {
-      throw new Error(`submitRunFlatMultipart: duplicate file slot "${part.slot}"`);
+      throw new Error(`submitRunMultipart: duplicate file slot "${part.slot}"`);
     }
     seen.add(partKey);
     const blob = toBlob(part.bytes, "application/zip");
@@ -1104,7 +1152,7 @@ var USAGE_ERR = { code: 2 };
 var RUNTIME_ERR = { code: 1 };
 function parseCommonHostFlags(argv) {
   let apiToken = null;
-  let dashboardUrl = null;
+  let antpathUrl = null;
   const rest = [];
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
@@ -1115,11 +1163,11 @@ function parseCommonHostFlags(argv) {
       apiToken = v;
       continue;
     }
-    if (arg === "--dashboard-url") {
+    if (arg === "--antpath-url") {
       const v = argv[++i];
       if (v === void 0)
-        return { ok: false, reason: "--dashboard-url requires a value" };
-      dashboardUrl = v;
+        return { ok: false, reason: "--antpath-url requires a value" };
+      antpathUrl = v;
       continue;
     }
     if (arg === "--workspace" || arg === "--workspace-id") {
@@ -1134,13 +1182,13 @@ function parseCommonHostFlags(argv) {
     return { ok: false, reason: "--api-token is required" };
   return {
     ok: true,
-    flags: { apiToken, dashboardUrl: dashboardUrl ?? ANTPATH_DEFAULT_BASE_URL },
+    flags: { apiToken, antpathUrl: antpathUrl ?? ANTPATH_DEFAULT_BASE_URL },
     rest
   };
 }
 function makeHttpClient(io2, flags) {
   return new HttpClient({
-    baseUrl: flags.dashboardUrl,
+    baseUrl: flags.antpathUrl,
     apiToken: flags.apiToken,
     fetch: io2.fetchImpl
   });
@@ -1593,17 +1641,69 @@ async function runRunCmd(io2, argv) {
     return USAGE_ERR;
   }
   let rest = common.rest;
-  const anthropicKey = takeFlagValue(rest, "--anthropic-api-key");
-  if (anthropicKey.error) {
-    io2.stderr(`${anthropicKey.error}
+  const providerFlag = takeFlagValue(rest, "--provider");
+  if (providerFlag.error) {
+    io2.stderr(`${providerFlag.error}
+`);
+    return USAGE_ERR;
+  }
+  rest = providerFlag.remaining;
+  let provider = DEFAULT_RUN_PROVIDER;
+  if (providerFlag.value !== null) {
+    if (!RUN_PROVIDERS.includes(providerFlag.value)) {
+      io2.stderr(`--provider must be one of: ${RUN_PROVIDERS.join(", ")} (got: ${providerFlag.value})
+`);
+      return USAGE_ERR;
+    }
+    provider = providerFlag.value;
+  }
+  const providerKeyValues = {};
+  for (const p of RUN_PROVIDERS) {
+    const flag = takeFlagValue(rest, `--${p}-api-key`);
+    if (flag.error) {
+      io2.stderr(`${flag.error}
+`);
+      return USAGE_ERR;
+    }
+    rest = flag.remaining;
+    if (flag.value !== null)
+      providerKeyValues[p] = flag.value;
+  }
+  if (!providerKeyValues[provider]) {
+    io2.stderr(`--${provider}-api-key is required when --provider is ${provider} (the platform does not store provider keys on your behalf)
 `);
     return USAGE_ERR;
   }
-  rest = anthropicKey.remaining;
-  if (!anthropicKey.value) {
-    io2.stderr("--anthropic-api-key is required (the platform does not store provider keys on your behalf)\n");
+  for (const p of RUN_PROVIDERS) {
+    if (p === provider)
+      continue;
+    if (providerKeyValues[p] !== void 0) {
+      io2.stderr(`--${p}-api-key is not allowed when --provider is ${provider}
+`);
+      return USAGE_ERR;
+    }
+  }
+  const runtimeFlag = takeFlagValue(rest, "--runtime");
+  if (runtimeFlag.error) {
+    io2.stderr(`${runtimeFlag.error}
+`);
     return USAGE_ERR;
   }
+  rest = runtimeFlag.remaining;
+  let runtime;
+  if (runtimeFlag.value !== null) {
+    if (!RUNTIME_KINDS.includes(runtimeFlag.value)) {
+      io2.stderr(`--runtime must be one of: ${RUNTIME_KINDS.join(", ")} (got: ${runtimeFlag.value})
+`);
+      return USAGE_ERR;
+    }
+    runtime = runtimeFlag.value;
+    if (runtime === "native" && provider !== "anthropic") {
+      io2.stderr(`--runtime native is only supported for --provider anthropic (got: ${provider})
+`);
+      return USAGE_ERR;
+    }
+  }
   const idempotency = takeFlagValue(rest, "--idempotency-key");
   if (idempotency.error) {
     io2.stderr(`${idempotency.error}
@@ -1652,13 +1752,6 @@ async function runRunCmd(io2, argv) {
     return USAGE_ERR;
   }
   rest = promptFlags.remaining;
-  const skillFlags = collectRepeated(rest, "--skill");
-  if (skillFlags.error) {
-    io2.stderr(`${skillFlags.error}
-`);
-    return USAGE_ERR;
-  }
-  rest = skillFlags.remaining;
   const providerSkillFlags = collectRepeated(rest, "--provider-skill");
   if (providerSkillFlags.error) {
     io2.stderr(`${providerSkillFlags.error}
@@ -1716,8 +1809,8 @@ async function runRunCmd(io2, argv) {
   let blueprint;
   let mcpHeadersFromConfig = /* @__PURE__ */ new Map();
   if (config.value) {
-    if (modelFlag.value || systemFlag.value || promptFlags.values.length || skillFlags.values.length || providerSkillFlags.values.length || Object.keys(mcpFlags.entries).length || Object.keys(metadataFlags.entries).length) {
-      io2.stderr("--config cannot be combined with --model/--system/--prompt/--skill/--provider-skill/--mcp/--metadata\n");
+    if (modelFlag.value || systemFlag.value || promptFlags.values.length || providerSkillFlags.values.length || Object.keys(mcpFlags.entries).length || Object.keys(metadataFlags.entries).length) {
+      io2.stderr("--config cannot be combined with --model/--system/--prompt/--provider-skill/--mcp/--metadata\n");
       return USAGE_ERR;
     }
     try {
@@ -1759,10 +1852,8 @@ async function runRunCmd(io2, argv) {
         return USAGE_ERR;
       }
     }
-    let workspaceSkills;
     let providerSkills;
     try {
-      workspaceSkills = skillFlags.values.map((v, i) => parseWorkspaceSkillFlag(v, i));
       providerSkills = providerSkillFlags.values.map((v, i) => parseProviderSkillFlag(v, i));
     } catch (err2) {
       io2.stderr(`${err2.message}
@@ -1777,7 +1868,7 @@ async function runRunCmd(io2, argv) {
       model: modelFlag.value,
       ...resolvedSystem ? { system: resolvedSystem } : {},
       prompt: resolvedPrompt,
-      ...workspaceSkills.length + providerSkills.length > 0 ? { skills: [...workspaceSkills, ...providerSkills] } : {},
+      ...providerSkills.length > 0 ? { skills: providerSkills } : {},
       ...mcpRefs.length > 0 ? { mcpServers: mcpRefs } : {},
       ...Object.keys(metadataFlags.entries).length > 0 ? { metadata: { ...metadataFlags.entries } } : {}
     };
@@ -1863,13 +1954,18 @@ async function runRunCmd(io2, argv) {
     ...blueprint.environment ? { environment: blueprint.environment } : {},
     ...blueprint.metadata ? { metadata: blueprint.metadata } : {}
   };
+  const providerSecrets = {
+    [provider]: { apiKey: providerKeyValues[provider] }
+  };
   const secrets = {
-    anthropic: { apiKey: anthropicKey.value },
+    ...providerSecrets,
     ...mcpServerSecrets.length > 0 ? { mcpServers: mcpServerSecrets } : {},
     ...proxyAuth.length > 0 ? { proxyEndpointAuth: proxyAuth } : {}
   };
   const request = {
     idempotencyKey: idempotency.value ?? generateIdempotencyKey(),
+    provider,
+    ...runtime ? { runtime } : {},
     submission,
     secrets,
     ...cleanup.value ? { cleanup: { session: cleanup.value } } : {},
@@ -1879,7 +1975,7 @@ async function runRunCmd(io2, argv) {
   const http = makeHttpClient(io2, common.flags);
   let run;
   try {
-    run = await operations_exports.submitRunFlat(http, request);
+    run = await operations_exports.submitRun(http, request);
   } catch (err2) {
     return emitJsonError(io2, "submit_failed", err2.message ?? "submission failed");
   }
@@ -1959,12 +2055,6 @@ function parseJsonOrThrow(raw, label) {
     throw new Error(`${label} is not valid JSON: ${err2.message}`);
   }
 }
-function parseWorkspaceSkillFlag(raw, idx) {
-  if (!raw) {
-    throw new Error(`--skill[${idx}] must be a non-empty skill id`);
-  }
-  return { kind: "workspace", id: raw };
-}
 function parseProviderSkillFlag(raw, idx) {
   const parts = raw.split(":");
   if (parts.length < 2 || parts.length > 3) {
@@ -3403,7 +3493,7 @@ Protocol version: ${manifest.protocolVersion}
   io2.stdout("antpath \u2014 unified CLI for the antpath platform (mirrors the SDK 1:1)\n\n");
   io2.stdout("Usage:\n");
   io2.stdout("  antpath run --config <run.json> --anthropic-api-key K --api-token T [flags]\n");
-  io2.stdout("  antpath run --model M --prompt P [--system S] [--skill ID ...] [--mcp name=url ...] --anthropic-api-key K --api-token T [flags]\n");
+  io2.stdout("  antpath run --model M --prompt P [--system S] [--provider-skill v:s ...] [--mcp name=url ...] --anthropic-api-key K --api-token T [flags]\n");
   io2.stdout("  antpath skills upload --name N --from-path <dir> --api-token T\n");
   io2.stdout("  antpath skills upload --name N --file <path> [--file <path> ...] --api-token T\n");
   io2.stdout("  antpath skills list --api-token T\n");
@@ -3419,14 +3509,15 @@ Protocol version: ${manifest.protocolVersion}
   io2.stdout("  antpath --help\n\n");
   io2.stdout("Common flags on every host subcommand:\n");
   io2.stdout("  --api-token <token>         REQUIRED \u2014 antpath SDK API token (workspace is derived from it)\n");
-  io2.stdout("  --dashboard-url <url>       Optional; defaults to https://www.antpath.ai (set for self-hosted)\n\n");
+  io2.stdout("  --antpath-url <url>         Optional; defaults to https://api.antpath.ai (set for self-hosted)\n\n");
   io2.stdout("antpath run flags:\n");
-  io2.stdout("  --anthropic-api-key <key>   REQUIRED \u2014 provider key (never stored)\n");
+  io2.stdout("  --provider <name>           Optional; one of: anthropic (default), deepseek\n");
+  io2.stdout("  --anthropic-api-key <key>   REQUIRED when --provider anthropic (default); never stored\n");
+  io2.stdout("  --deepseek-api-key <key>    REQUIRED when --provider deepseek; never stored\n");
   io2.stdout("  --config <path>             JSON Blueprint (mutually exclusive with the flat --model/--prompt flags)\n");
   io2.stdout("  --model <model-id>          Anthropic model id (required in flat mode)\n");
   io2.stdout("  --system @file | <text>     System message; @-prefix reads from file\n");
   io2.stdout("  --prompt @file | <text>     User message; @-prefix reads from file (repeatable)\n");
-  io2.stdout("  --skill <skl_id>            Workspace skill (repeatable)\n");
   io2.stdout("  --provider-skill v:s[:ver]  Provider built-in skill (vendor:skillId[:version], repeatable)\n");
   io2.stdout("  --mcp name=url              MCP server entry (repeatable)\n");
   io2.stdout("  --mcp-auth name=Hdr:Val     Auth header on the matching --mcp; routed into vaulted secrets (repeatable)\n");

package/dist/cli.mjs.sha256

@@ -1 +1 @@
-80d5b8acd38d2604064106537102276eed37305fe2eedce375c0c8dee0d1b141  cli.mjs
+ba35805b91e9b19eeeead9f80278140797287bc4d14e6618b842354cb2cb3208  cli.mjs