antpath 0.10.14 → 0.11.0

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 = [
@@ -551,17 +606,181 @@ __export(operations_exports, {
   listOutputs: () => listOutputs,
   listRunEvents: () => listRunEvents,
   listSkills: () => listSkills,
+  streamRunEventsSse: () => streamRunEventsSse,
   submitRun: () => submitRun,
-  submitRunFlat: () => submitRunFlat,
-  submitRunFlatMultipart: () => submitRunFlatMultipart,
+  submitRunMultipart: () => submitRunMultipart,
   whoami: () => whoami
 });
-async function submitRun(http, request) {
-  return http.request("/api/runs", {
-    method: "POST",
-    body: JSON.stringify(request)
-  });
+
+// ../shared/dist/sse.js
+var SseParser = class {
+  #buffer = "";
+  #decoder = new TextDecoder("utf-8");
+  #eventType = "";
+  #dataLines = [];
+  #lastEventId;
+  #retry;
+  /**
+   * Push a chunk of raw bytes through the parser. Returns any frames
+   * that completed during this chunk. Chunks may contain zero, one,
+   * or many frame boundaries — the parser handles partial trailing
+   * data internally.
+   */
+  pushBytes(chunk) {
+    return this.pushText(this.#decoder.decode(chunk, { stream: true }));
+  }
+  /**
+   * Push a text chunk directly. Used by the parser tests so they can
+   * exercise byte-boundary edge cases without manufacturing a
+   * `TextDecoder` round-trip.
+   */
+  pushText(text) {
+    this.#buffer += text;
+    const frames = [];
+    let idx;
+    while ((idx = findLineBreak(this.#buffer)) !== -1) {
+      const line = this.#buffer.slice(0, idx);
+      const skip = this.#buffer[idx] === "\r" && this.#buffer[idx + 1] === "\n" ? 2 : 1;
+      this.#buffer = this.#buffer.slice(idx + skip);
+      const frame = this.#consumeLine(line);
+      if (frame)
+        frames.push(frame);
+    }
+    return frames;
+  }
+  /**
+   * Indicate end-of-stream. Returns any final frame that the dispatcher
+   * was holding when the stream closed mid-frame (no trailing blank
+   * line). The dispatcher pattern is: blank line dispatches; if the
+   * remote closes after a partial frame, that frame is dropped per the
+   * spec.
+   */
+  flush() {
+  }
+  #consumeLine(line) {
+    if (line.length === 0) {
+      return this.#dispatch();
+    }
+    if (line.startsWith(":")) {
+      return null;
+    }
+    const colonIdx = line.indexOf(":");
+    let field;
+    let value;
+    if (colonIdx === -1) {
+      field = line;
+      value = "";
+    } else {
+      field = line.slice(0, colonIdx);
+      value = line.slice(colonIdx + 1);
+      if (value.startsWith(" "))
+        value = value.slice(1);
+    }
+    switch (field) {
+      case "event":
+        this.#eventType = value;
+        break;
+      case "data":
+        this.#dataLines.push(value);
+        break;
+      case "id":
+        if (!value.includes("\0")) {
+          this.#lastEventId = value;
+        }
+        break;
+      case "retry": {
+        const parsed = Number.parseInt(value, 10);
+        if (Number.isFinite(parsed) && parsed >= 0)
+          this.#retry = parsed;
+        break;
+      }
+      default:
+        break;
+    }
+    return null;
+  }
+  #dispatch() {
+    if (this.#dataLines.length === 0 && this.#eventType === "") {
+      return null;
+    }
+    const data = this.#dataLines.join("\n");
+    const event = this.#eventType === "" ? "message" : this.#eventType;
+    const frame = {
+      event,
+      data,
+      ...this.#lastEventId !== void 0 ? { id: this.#lastEventId } : {},
+      ...this.#retry !== void 0 ? { retry: this.#retry } : {}
+    };
+    this.#eventType = "";
+    this.#dataLines = [];
+    this.#retry = void 0;
+    return frame;
+  }
+  /**
+   * Current "last event id" — the cursor the SSE spec instructs the
+   * client to replay on automatic reconnection. Callers use this to
+   * resume after a disconnect.
+   */
+  get lastEventId() {
+    return this.#lastEventId;
+  }
+};
+async function* iterateSse(body, signal) {
+  const reader = body.getReader();
+  const parser = new SseParser();
+  const ABORT_SENTINEL = /* @__PURE__ */ Symbol("aborted");
+  try {
+    while (true) {
+      if (signal?.aborted)
+        return;
+      const readPromise = reader.read();
+      let result;
+      if (signal) {
+        result = await Promise.race([
+          readPromise,
+          new Promise((resolve) => {
+            const onAbort = () => resolve(ABORT_SENTINEL);
+            if (signal.aborted) {
+              resolve(ABORT_SENTINEL);
+              return;
+            }
+            signal.addEventListener("abort", onAbort, { once: true });
+          })
+        ]);
+      } else {
+        result = await readPromise;
+      }
+      if (result === ABORT_SENTINEL)
+        return;
+      if (result.done) {
+        parser.flush();
+        return;
+      }
+      const value = result.value;
+      if (!value)
+        continue;
+      const frames = parser.pushBytes(value);
+      for (const frame of frames) {
+        yield frame;
+      }
+    }
+  } finally {
+    try {
+      await reader.cancel();
+    } catch {
+    }
+  }
+}
+function findLineBreak(buffer) {
+  for (let i = 0; i < buffer.length; i++) {
+    const code = buffer.charCodeAt(i);
+    if (code === 10 || code === 13)
+      return i;
+  }
+  return -1;
 }
+
+// ../shared/dist/operations.js
 async function getRun(http, runId) {
   const result = await http.request(`/api/runs/${encodeURIComponent(runId)}`);
   return hasRun(result) ? result.run : result;
@@ -573,6 +792,125 @@ async function listRunEvents(http, runId) {
   const result = await http.request(`/api/runs/${encodeURIComponent(runId)}/events`);
   return result.events;
 }
+async function* streamRunEventsSse(http, runId, options = {}) {
+  const headers = {
+    accept: "text/event-stream"
+  };
+  if (options.cursor) {
+    headers["last-event-id"] = options.cursor;
+  }
+  const query = {};
+  if (options.cursor)
+    query.cursor = options.cursor;
+  let outcome = {
+    kind: "disconnected",
+    nextCursor: options.cursor
+  };
+  let download;
+  try {
+    const init = { method: "GET", headers };
+    if (options.signal)
+      init.signal = options.signal;
+    download = await http.download(`/api/runs/${encodeURIComponent(runId)}/events/stream`, init, query);
+  } catch (err2) {
+    return {
+      kind: options.signal?.aborted ? "aborted" : "disconnected",
+      nextCursor: options.cursor,
+      error: err2 instanceof Error ? err2.message : String(err2)
+    };
+  }
+  const body = download.response.body;
+  if (!body) {
+    return {
+      kind: "disconnected",
+      nextCursor: options.cursor,
+      error: "SSE response body was empty"
+    };
+  }
+  let cursor = options.cursor;
+  try {
+    for await (const frame of iterateSse(body, options.signal)) {
+      options.onFrame?.(frame);
+      if (frame.id)
+        cursor = frame.id;
+      switch (frame.event) {
+        case "run_event": {
+          const event = parseRunEventFrame(frame.data);
+          if (event) {
+            const payloadCursor = readStringField(event, "cursor");
+            if (payloadCursor)
+              cursor = payloadCursor;
+            yield event;
+          }
+          break;
+        }
+        case "terminal": {
+          const status = readStringField(parseJsonObject(frame.data) ?? {}, "status");
+          outcome = {
+            kind: "terminal",
+            nextCursor: cursor,
+            ...status ? { terminalStatus: status } : {}
+          };
+          return outcome;
+        }
+        case "gone": {
+          outcome = {
+            kind: "disconnected",
+            nextCursor: cursor,
+            error: "run no longer exists"
+          };
+          return outcome;
+        }
+        case "error": {
+          const message = readStringField(parseJsonObject(frame.data) ?? {}, "message") ?? "SSE stream reported an error";
+          outcome = {
+            kind: "disconnected",
+            nextCursor: cursor,
+            error: message
+          };
+          return outcome;
+        }
+      }
+    }
+  } catch (err2) {
+    return {
+      kind: options.signal?.aborted ? "aborted" : "disconnected",
+      nextCursor: cursor,
+      error: err2 instanceof Error ? err2.message : String(err2)
+    };
+  }
+  return {
+    kind: options.signal?.aborted ? "aborted" : "disconnected",
+    nextCursor: cursor
+  };
+}
+function parseRunEventFrame(data) {
+  const parsed = parseJsonObject(data);
+  if (!parsed)
+    return null;
+  const id = readStringField(parsed, "id");
+  const type = readStringField(parsed, "type");
+  if (!id || !type)
+    return null;
+  return parsed;
+}
+function parseJsonObject(data) {
+  if (data.length === 0)
+    return null;
+  try {
+    const value = JSON.parse(data);
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      return value;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function readStringField(obj, field) {
+  const value = obj[field];
+  return typeof value === "string" ? value : void 0;
+}
 async function listOutputs(http, runId) {
   const result = await http.request(`/api/runs/${encodeURIComponent(runId)}/outputs`);
   return result.outputs;
@@ -593,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");
@@ -622,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" });
@@ -634,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");
@@ -814,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];
@@ -825,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") {
@@ -844,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
   });
@@ -964,6 +1302,26 @@ function takeBooleanFlag(rest, flag) {
   }
   return { present, remaining };
 }
+function takeOptionFlag(rest, flag) {
+  const remaining = [];
+  let value;
+  const prefix = `${flag}=`;
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === flag) {
+      const next = rest[++i];
+      if (next !== void 0)
+        value = next;
+      continue;
+    }
+    if (arg.startsWith(prefix)) {
+      value = arg.slice(prefix.length);
+      continue;
+    }
+    remaining.push(arg);
+  }
+  return { value, remaining };
+}
 
 // dist/outputs-sync.js
 async function runOutputsSyncCmd(io2, dirs) {
@@ -1283,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 = anthropicKey.remaining;
-  if (!anthropicKey.value) {
-    io2.stderr("--anthropic-api-key is required (the platform does not store provider keys on your behalf)\n");
+  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;
   }
+  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}
@@ -1342,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}
@@ -1406,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 {
@@ -1449,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}
@@ -1467,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 } } : {}
     };
@@ -1553,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 } } : {},
@@ -1569,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");
   }
@@ -1649,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) {
@@ -2751,6 +3151,13 @@ var TERMINAL_STATUSES2 = /* @__PURE__ */ new Set([
   "canceled",
   "cleaned_up"
 ]);
+function parseTransport(raw) {
+  if (raw === void 0 || raw === "")
+    return "auto";
+  if (raw === "auto" || raw === "sse" || raw === "polling")
+    return raw;
+  return null;
+}
 async function runEventsCmd(io2, argv) {
   if (await refuseInsideManagedRun(io2, "events"))
     return USAGE_ERR;
@@ -2761,9 +3168,16 @@ async function runEventsCmd(io2, argv) {
     return USAGE_ERR;
   }
   const followResult = takeBooleanFlag(common.rest, "--follow");
-  const positional = followResult.remaining.filter((arg) => !arg.startsWith("--"));
+  const transportResult = takeOptionFlag(followResult.remaining, "--transport");
+  const transport = parseTransport(transportResult.value);
+  if (transport === null) {
+    io2.stderr(`invalid --transport value '${transportResult.value}'; expected auto|sse|polling
+`);
+    return USAGE_ERR;
+  }
+  const positional = transportResult.remaining.filter((arg) => !arg.startsWith("--"));
   if (positional.length !== 1) {
-    io2.stderr("usage: antpath events <run-id> [--follow] [common flags]\n");
+    io2.stderr("usage: antpath events <run-id> [--follow] [--transport=auto|sse|polling] [common flags]\n");
     return USAGE_ERR;
   }
   const runId = positional[0];
@@ -2779,7 +3193,44 @@ async function runEventsCmd(io2, argv) {
       return emitJsonError(io2, "events_failed", err2.message ?? "event fetch failed", { runId });
     }
   }
-  let emittedCount = 0;
+  const seen = /* @__PURE__ */ new Set();
+  if (transport !== "polling") {
+    let cursor;
+    while (true) {
+      const sseOpts = {};
+      if (cursor !== void 0)
+        sseOpts.cursor = cursor;
+      const iter = operations_exports.streamRunEventsSse(http, runId, sseOpts);
+      let outcome;
+      try {
+        while (true) {
+          outcome = await iter.next();
+          if (outcome.done)
+            break;
+          const event = outcome.value;
+          if (!seen.has(event.id)) {
+            seen.add(event.id);
+            io2.stdout(JSON.stringify(event) + "\n");
+          }
+        }
+      } catch (err2) {
+        io2.stderr(`(transient) SSE stream errored: ${err2.message}
+`);
+        if (transport === "sse")
+          return SUCCESS;
+        break;
+      }
+      const finalOutcome = outcome.value;
+      cursor = finalOutcome.nextCursor;
+      if (finalOutcome.kind === "terminal" || finalOutcome.kind === "aborted")
+        return SUCCESS;
+      if (transport === "sse")
+        return SUCCESS;
+      io2.stderr(`(transient) SSE disconnect (${finalOutcome.error ?? "stream closed"}) \u2014 falling back to polling
+`);
+      break;
+    }
+  }
   while (true) {
     let events;
     try {
@@ -2790,10 +3241,12 @@ async function runEventsCmd(io2, argv) {
       await sleep2(2e3);
       continue;
     }
-    for (let i = emittedCount; i < events.length; i++) {
-      io2.stdout(JSON.stringify(events[i]) + "\n");
+    for (const event of events) {
+      if (!seen.has(event.id)) {
+        seen.add(event.id);
+        io2.stdout(JSON.stringify(event) + "\n");
+      }
     }
-    emittedCount = events.length;
     try {
       const run = await operations_exports.getRun(http, runId);
       if (TERMINAL_STATUSES2.has(run.status)) {
@@ -3040,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");
@@ -3056,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");