antpath 0.9.2 → 0.10.7

package/dist/cli.mjs

@@ -528,16 +528,26 @@ function extractErrorMessage(body) {
 var operations_exports = {};
 __export(operations_exports, {
   cancelRun: () => cancelRun,
+  createAgentsMd: () => createAgentsMd,
+  createFile: () => createFile,
   createOutputLink: () => createOutputLink,
   createSkillBundle: () => createSkillBundle,
+  deleteAgentsMd: () => deleteAgentsMd,
+  deleteFile: () => deleteFile,
   deleteRun: () => deleteRun,
   deleteSkill: () => deleteSkill,
   downloadRunArchive: () => downloadRunArchive,
+  finalizeAssetUpload: () => finalizeAssetUpload,
   findSkillByHash: () => findSkillByHash,
   findSkillByName: () => findSkillByName,
+  getAgentsMd: () => getAgentsMd,
+  getFile: () => getFile,
   getRun: () => getRun,
   getRunUnit: () => getRunUnit,
   getSkill: () => getSkill,
+  initAssetUpload: () => initAssetUpload,
+  listAgentsMd: () => listAgentsMd,
+  listFiles: () => listFiles,
   listOutputs: () => listOutputs,
   listRunEvents: () => listRunEvents,
   listSkills: () => listSkills,
@@ -589,9 +599,12 @@ async function submitRunFlat(http, request) {
     body: JSON.stringify(request)
   });
 }
-async function submitRunFlatMultipart(http, request, bundles) {
-  if (!Array.isArray(bundles) || bundles.length === 0) {
-    throw new Error("submitRunFlatMultipart: bundles must be a non-empty array");
+async function submitRunFlatMultipart(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");
   }
   const form = new FormData();
   form.append("submission", new Blob([JSON.stringify(request)], { type: "application/json" }), "submission.json");
@@ -607,6 +620,30 @@ async function submitRunFlatMultipart(http, request, bundles) {
     const blob = toBlob(bundle.bytes, "application/zip");
     form.append(`skill:${bundle.slot}`, blob, bundle.filename);
   }
+  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");
+    }
+    const partKey = `agentsmd:${part.slot}`;
+    if (seen.has(partKey)) {
+      throw new Error(`submitRunFlatMultipart: duplicate agentsMd slot "${part.slot}"`);
+    }
+    seen.add(partKey);
+    const blob = new Blob([part.content], { type: "text/plain" });
+    form.append(partKey, blob, part.filename);
+  }
+  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");
+    }
+    const partKey = `file:${part.slot}`;
+    if (seen.has(partKey)) {
+      throw new Error(`submitRunFlatMultipart: duplicate file slot "${part.slot}"`);
+    }
+    seen.add(partKey);
+    const blob = toBlob(part.bytes, "application/zip");
+    form.append(partKey, blob, part.filename);
+  }
   return http.request("/api/runs", {
     method: "POST",
     body: form
@@ -651,6 +688,65 @@ async function findSkillByName(http, name) {
   const skills = await listSkills(http);
   return skills.find((skill) => skill.name === name) ?? null;
 }
+async function createAgentsMd(http, args) {
+  const form = new FormData();
+  form.append("name", args.name);
+  form.append("content", new Blob([args.content], { type: "text/plain" }), "AGENTS.md");
+  const result = await http.request("/api/agentsmd", { method: "POST", body: form });
+  return unwrapAgentsMd(result);
+}
+async function listAgentsMd(http) {
+  const result = await http.request("/api/agentsmd");
+  if (Array.isArray(result)) {
+    return result;
+  }
+  return result.agentsMd;
+}
+async function getAgentsMd(http, agentsMdId) {
+  const result = await http.request(`/api/agentsmd/${encodeURIComponent(agentsMdId)}`);
+  return unwrapAgentsMd(result);
+}
+async function deleteAgentsMd(http, agentsMdId) {
+  await http.request(`/api/agentsmd/${encodeURIComponent(agentsMdId)}`, {
+    method: "DELETE"
+  });
+}
+function unwrapAgentsMd(result) {
+  if (result && typeof result === "object" && "agentsMd" in result) {
+    return result.agentsMd;
+  }
+  return result;
+}
+async function createFile(http, args) {
+  const form = new FormData();
+  form.append("name", args.name);
+  const blob = toBlob(args.bytes, "application/zip");
+  form.append("bundle", blob, `${args.name}.zip`);
+  const result = await http.request("/api/files", { method: "POST", body: form });
+  return unwrapFile(result);
+}
+async function listFiles(http) {
+  const result = await http.request("/api/files");
+  if (Array.isArray(result)) {
+    return result;
+  }
+  return result.files;
+}
+async function getFile(http, fileId) {
+  const result = await http.request(`/api/files/${encodeURIComponent(fileId)}`);
+  return unwrapFile(result);
+}
+async function deleteFile(http, fileId) {
+  await http.request(`/api/files/${encodeURIComponent(fileId)}`, {
+    method: "DELETE"
+  });
+}
+function unwrapFile(result) {
+  if (result && typeof result === "object" && "file" in result) {
+    return result.file;
+  }
+  return result;
+}
 function unwrapSkill(result) {
   if (result && typeof result === "object" && "skill" in result) {
     return result.skill;
@@ -671,6 +767,18 @@ function toBlob(input, contentType) {
 function hasRun(value) {
   return Boolean(value && typeof value === "object" && "run" in value);
 }
+async function initAssetUpload(http, input) {
+  return http.request("/api/assets/upload-init", {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+}
+async function finalizeAssetUpload(http, input) {
+  await http.request("/api/assets/finalize", {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+}
 
 // ../shared/dist/proxy-validation.js
 function validateProxyAuth(endpoints, auth) {
@@ -1424,6 +1532,8 @@ async function runRunCmd(io2, argv) {
     ...blueprint.system ? { system: blueprint.system } : {},
     prompt: promptArray,
     skills,
+    agentsMd: [],
+    files: [],
     mcpServers: mcpServersForSubmission,
     ...blueprint.environment ? { environment: blueprint.environment } : {},
     ...blueprint.metadata ? { metadata: blueprint.metadata } : {}
@@ -2524,7 +2634,7 @@ async function zipDirectory(rootDir) {
     throw new Error(`${rootDir} contains no regular files`);
   }
   if (!hasSkillMd) {
-    throw new Error('skill bundle must contain a "SKILL.md" file at the root');
+    throw new Error('skill bundle must contain a "SKILL.md" file at the root. For AGENTS.md / generic files use the corresponding `antpath agentsmd` / `antpath files` commands instead.');
   }
   const sorted = [...collected.entries()].sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
   const zippable = {};

package/dist/cli.mjs.sha256

@@ -1 +1 @@
-f176fe0055e6734c13959869bba99513459b1caf7f982a7088e638a69bbdd528  cli.mjs
+be4a58f5a53548888b5e515cbb87dec475e869b6b1a43122c0b74ef19b9922cb  cli.mjs

package/dist/client.d.ts

@@ -1,8 +1,11 @@
-import { HttpClient, type FetchLike, type Output, type PlatformFlatRunSubmissionInput, type PlatformFlatSubmission, type PlatformInlineSecrets, type PlatformProxyEndpoint, type PlatformProxyEndpointAuth, type Run, type RunEvent, type RunUnit, type SignedOutputLink, type Skill as SkillRecord, type WhoAmI } from "./_shared/index.js";
+import { HttpClient, type AgentsMdRecord, type FetchLike, type FileRecord, type Output, type PlatformFlatRunSubmissionInput, type PlatformFlatSubmission, type PlatformInlineSecrets, type PlatformProxyEndpoint, type PlatformProxyEndpointAuth, type Run, type RunEvent, type RunUnit, type SignedOutputLink, type Skill as SkillRecord, type WhoAmI } from "./_shared/index.js";
 import type { Blueprint } from "./blueprint.js";
+import { AgentsMd } from "./agents-md.js";
+import { File } from "./file.js";
 import { McpServer } from "./mcp-server.js";
 import { ProxyEndpoint } from "./proxy-endpoint.js";
 import { Skill } from "./skill.js";
+import type { ChunkedUploadClient } from "./skill.js";
 export interface AntpathClientOptions {
     /** Workspace-scoped SDK API token. */
     readonly apiToken: string;
@@ -46,6 +49,8 @@ export interface SubmitRunOptions {
     readonly system?: string;
     readonly prompt: string | readonly string[];
     readonly skills?: readonly Skill[];
+    readonly agentsMd?: readonly AgentsMd[];
+    readonly files?: readonly File[];
     readonly mcpServers?: readonly McpServer[];
     readonly environment?: PlatformFlatSubmission["environment"];
     readonly metadata?: PlatformFlatSubmission["metadata"];
@@ -172,6 +177,62 @@ export declare class SkillsClient {
         readonly body: Uint8Array;
     }): Promise<SkillRecord>;
 }
+/**
+ * Workspace AgentsMd admin operations exposed under `client.agentsMd`.
+ *
+ * Persisting a new AgentsMd goes through
+ * `AgentsMd.fromContent("…", { name }).upload(client)` or
+ * `AgentsMd.fromPath('./AGENTS.md').upload(client)` — there is no
+ * `client.agentsMd.upload` or `client.agentsMd.fromPath` verb. The class
+ * is the single creation surface; the client is the transport.
+ *
+ * The internal `_uploadAgentsMd(args)` entry point is consumed by
+ * `AgentsMd.upload(client)` and is not part of the public API — the
+ * leading underscore is a "do not call from user code" marker.
+ */
+export declare class AgentsMdClient {
+    #private;
+    constructor(http: HttpClient);
+    list(): Promise<readonly AgentsMdRecord[]>;
+    get(agentsMdId: string): Promise<AgentsMdRecord>;
+    delete(agentsMdId: string): Promise<void>;
+    /**
+     * Internal: post an AgentsMd markdown string to the BFF. Only
+     * `AgentsMd.upload` calls this. NOT part of the public API.
+     */
+    _uploadAgentsMd(args: {
+        readonly name: string;
+        readonly content: string;
+    }): Promise<AgentsMdRecord>;
+}
+/**
+ * Workspace File admin operations exposed under `client.files`.
+ *
+ * Persisting a new File goes through
+ * `File.fromPath('./data/').upload(client)` or
+ * `File.fromBytes({ name, bytes }).upload(client)` — there is no
+ * `client.files.upload` verb. The class is the single creation surface;
+ * the client is the transport.
+ *
+ * The internal `_uploadFile(args)` entry point is consumed by
+ * `File.upload(client)` and is not part of the public API — the
+ * leading underscore is a "do not call from user code" marker.
+ */
+export declare class FilesClient {
+    #private;
+    constructor(http: HttpClient);
+    list(): Promise<readonly FileRecord[]>;
+    get(fileId: string): Promise<FileRecord>;
+    delete(fileId: string): Promise<void>;
+    /**
+     * Internal: post a pre-bundled file zip to the BFF. Only
+     * `File.upload` calls this. NOT part of the public API.
+     */
+    _uploadFile(args: {
+        readonly name: string;
+        readonly bytes: Uint8Array;
+    }): Promise<FileRecord>;
+}
 /**
  * Unified user-facing client for the antpath platform. The same class
  * powers the published `antpath` SDK and (under the hood) every host-side
@@ -186,6 +247,8 @@ export declare class SkillsClient {
 export declare class AntpathClient {
     #private;
     readonly skills: SkillsClient;
+    readonly agentsMd: AgentsMdClient;
+    readonly files: FilesClient;
     constructor(options: AntpathClientOptions);
     /**
      * Internal: a `Skill.upload(this)` shortcut that bypasses
@@ -196,6 +259,32 @@ export declare class AntpathClient {
         readonly name: string;
         readonly body: Uint8Array;
     }): Promise<SkillRecord>;
+    /**
+     * Internal: an `AgentsMd.upload(this)` shortcut that bypasses
+     * `client.agentsMd` indirection. Forwarded to
+     * `AgentsMdClient._uploadAgentsMd`. NOT part of the public API.
+     */
+    _uploadAgentsMd(args: {
+        readonly name: string;
+        readonly content: string;
+    }): Promise<AgentsMdRecord>;
+    /**
+     * Internal: a `File.upload(this)` shortcut that bypasses
+     * `client.files` indirection. Forwarded to
+     * `FilesClient._uploadFile`. NOT part of the public API.
+     */
+    _uploadFile(args: {
+        readonly name: string;
+        readonly bytes: Uint8Array;
+    }): Promise<FileRecord>;
+    /**
+     * Internal: chunked-upload entry point for `Skill.upload` and
+     * `File.upload` when the bundle exceeds the 6 MiB threshold.
+     * Drives the three-step TUS flow: init → uploadChunked → finalize.
+     * NOT part of the public API — the underscore is a "do not call
+     * from user code" marker.
+     */
+    readonly _chunkedUpload: ChunkedUploadClient;
     /**
      * Submit a run and wait for it to reach a terminal state. Returns the
      * final `Run` record. For long-running flows, prefer `submitRun` +
@@ -212,10 +301,14 @@ export declare class AntpathClient {
      * the run snapshot.
      *
      * Unstaged transient skills (`Skill.fromFiles` / `Skill.fromPath`
-     * without a prior `.upload`) are not yet accepted by the dashboard
-     * BFF — passing one to `submitRun` throws with a directive error
-     * pointing to `await skill.upload(client)`. The workspace-skill path
-     * works end-to-end today and is the canonical Phase 0 surface.
+     * without a prior `.upload`) are accepted: the SDK switches to a
+     * multipart body that carries the canonical zip bytes alongside the
+     * JSON submission. The dashboard BFF ingests each one through the
+     * standard workspace-skill upload pipeline (dedup by content hash;
+     * upload via the existing two-phase pending → ready flow) and
+     * rewrites the run's `skills[]` to reference the resulting `skl_*`
+     * ids. The bytes persist on antpath; the user can browse and
+     * download the resulting workspace skill from the dashboard.
      */
     submitRun(options: SubmitRunOptions): Promise<RunRef>;
     getRun(runId: string): Promise<Run>;

package/dist/client.js

@@ -1,4 +1,6 @@
 import { HttpClient, operations } from "./_shared/index.js";
+import { AgentsMd } from "./agents-md.js";
+import { File } from "./file.js";
 import { McpServer } from "./mcp-server.js";
 import { splitProxyEndpoints } from "./proxy-endpoint.js";
 import { Skill } from "./skill.js";
@@ -133,6 +135,76 @@ export class SkillsClient {
         });
     }
 }
+/**
+ * Workspace AgentsMd admin operations exposed under `client.agentsMd`.
+ *
+ * Persisting a new AgentsMd goes through
+ * `AgentsMd.fromContent("…", { name }).upload(client)` or
+ * `AgentsMd.fromPath('./AGENTS.md').upload(client)` — there is no
+ * `client.agentsMd.upload` or `client.agentsMd.fromPath` verb. The class
+ * is the single creation surface; the client is the transport.
+ *
+ * The internal `_uploadAgentsMd(args)` entry point is consumed by
+ * `AgentsMd.upload(client)` and is not part of the public API — the
+ * leading underscore is a "do not call from user code" marker.
+ */
+export class AgentsMdClient {
+    #http;
+    constructor(http) {
+        this.#http = http;
+    }
+    list() {
+        return operations.listAgentsMd(this.#http);
+    }
+    get(agentsMdId) {
+        return operations.getAgentsMd(this.#http, agentsMdId);
+    }
+    delete(agentsMdId) {
+        return operations.deleteAgentsMd(this.#http, agentsMdId);
+    }
+    /**
+     * Internal: post an AgentsMd markdown string to the BFF. Only
+     * `AgentsMd.upload` calls this. NOT part of the public API.
+     */
+    async _uploadAgentsMd(args) {
+        return operations.createAgentsMd(this.#http, args);
+    }
+}
+/**
+ * Workspace File admin operations exposed under `client.files`.
+ *
+ * Persisting a new File goes through
+ * `File.fromPath('./data/').upload(client)` or
+ * `File.fromBytes({ name, bytes }).upload(client)` — there is no
+ * `client.files.upload` verb. The class is the single creation surface;
+ * the client is the transport.
+ *
+ * The internal `_uploadFile(args)` entry point is consumed by
+ * `File.upload(client)` and is not part of the public API — the
+ * leading underscore is a "do not call from user code" marker.
+ */
+export class FilesClient {
+    #http;
+    constructor(http) {
+        this.#http = http;
+    }
+    list() {
+        return operations.listFiles(this.#http);
+    }
+    get(fileId) {
+        return operations.getFile(this.#http, fileId);
+    }
+    delete(fileId) {
+        return operations.deleteFile(this.#http, fileId);
+    }
+    /**
+     * Internal: post a pre-bundled file zip to the BFF. Only
+     * `File.upload` calls this. NOT part of the public API.
+     */
+    async _uploadFile(args) {
+        return operations.createFile(this.#http, args);
+    }
+}
 /**
  * Unified user-facing client for the antpath platform. The same class
  * powers the published `antpath` SDK and (under the hood) every host-side
@@ -147,6 +219,8 @@ export class SkillsClient {
 export class AntpathClient {
     #http;
     skills;
+    agentsMd;
+    files;
     constructor(options) {
         if (!options.apiToken) {
             throw new Error("AntpathClient: apiToken is required");
@@ -157,6 +231,8 @@ export class AntpathClient {
             ...(options.fetch ? { fetch: options.fetch } : {})
         });
         this.skills = new SkillsClient(this.#http);
+        this.agentsMd = new AgentsMdClient(this.#http);
+        this.files = new FilesClient(this.#http);
     }
     /**
      * Internal: a `Skill.upload(this)` shortcut that bypasses
@@ -166,6 +242,33 @@ export class AntpathClient {
     async _uploadSkillBundle(args) {
         return this.skills._uploadSkillBundle(args);
     }
+    /**
+     * Internal: an `AgentsMd.upload(this)` shortcut that bypasses
+     * `client.agentsMd` indirection. Forwarded to
+     * `AgentsMdClient._uploadAgentsMd`. NOT part of the public API.
+     */
+    async _uploadAgentsMd(args) {
+        return this.agentsMd._uploadAgentsMd(args);
+    }
+    /**
+     * Internal: a `File.upload(this)` shortcut that bypasses
+     * `client.files` indirection. Forwarded to
+     * `FilesClient._uploadFile`. NOT part of the public API.
+     */
+    async _uploadFile(args) {
+        return this.files._uploadFile(args);
+    }
+    /**
+     * Internal: chunked-upload entry point for `Skill.upload` and
+     * `File.upload` when the bundle exceeds the 6 MiB threshold.
+     * Drives the three-step TUS flow: init → uploadChunked → finalize.
+     * NOT part of the public API — the underscore is a "do not call
+     * from user code" marker.
+     */
+    _chunkedUpload = {
+        init: (args) => operations.initAssetUpload(this.#http, args),
+        finalize: (args) => operations.finalizeAssetUpload(this.#http, args)
+    };
     /**
      * Submit a run and wait for it to reach a terminal state. Returns the
      * final `Run` record. For long-running flows, prefer `submitRun` +
@@ -185,10 +288,14 @@ export class AntpathClient {
      * the run snapshot.
      *
      * Unstaged transient skills (`Skill.fromFiles` / `Skill.fromPath`
-     * without a prior `.upload`) are not yet accepted by the dashboard
-     * BFF — passing one to `submitRun` throws with a directive error
-     * pointing to `await skill.upload(client)`. The workspace-skill path
-     * works end-to-end today and is the canonical Phase 0 surface.
+     * without a prior `.upload`) are accepted: the SDK switches to a
+     * multipart body that carries the canonical zip bytes alongside the
+     * JSON submission. The dashboard BFF ingests each one through the
+     * standard workspace-skill upload pipeline (dedup by content hash;
+     * upload via the existing two-phase pending → ready flow) and
+     * rewrites the run's `skills[]` to reference the resulting `skl_*`
+     * ids. The bytes persist on antpath; the user can browse and
+     * download the resulting workspace skill from the dashboard.
      */
     async submitRun(options) {
         if (!options || typeof options !== "object") {
@@ -204,25 +311,16 @@ export class AntpathClient {
         const { endpoints: proxyEndpointDeclarations, auth: proxyEndpointAuthFromInstances } = splitProxyEndpoints(options.proxyEndpoints ?? []);
         const mergedProxyAuth = mergeProxyEndpointAuth(proxyEndpointAuthFromInstances, options.secrets.proxyEndpointAuth ?? []);
         const { skillRefs, transientBundles } = prepareSkills(options.skills ?? []);
-        if (transientBundles.length > 0) {
-            // The dashboard BFF's multipart submitRun path is not yet wired up
-            // (it returns HTTP 501). Short-circuit here with a directive
-            // message so users do not pay a doomed network round-trip and
-            // mistake an unimplemented feature for a regression. The
-            // workaround — persist the skill once, reference it on the run —
-            // works today and is the canonical Phase 0 path.
-            const names = transientBundles.map((b) => `\`${b.slot}\``).join(", ");
-            throw new Error(`AntpathClient.submitRun: unstaged transient skills (${names}) are not yet accepted ` +
-                `by the dashboard BFF (HTTP 501 multipart submitRun). Persist the skill first with ` +
-                `\`const persisted = await skill.upload(client)\` and pass \`persisted\` (or ` +
-                `\`Skill.fromId(persisted.record.id)\`) on the run instead.`);
-        }
+        const { agentsMdRefs, transientAgentsMdParts } = prepareAgentsMd(options.agentsMd ?? []);
+        const { fileRefs, transientFileParts } = prepareFiles(options.files ?? []);
         const { submissionMcpServers, mergedMcpSecrets } = mergeMcpServers(options.mcpServers ?? [], options.secrets.mcpServers ?? []);
         const submission = {
             model: options.model,
             ...(options.system ? { system: options.system } : {}),
             prompt,
             skills: skillRefs,
+            agentsMd: agentsMdRefs,
+            files: fileRefs,
             mcpServers: submissionMcpServers,
             ...(options.environment ? { environment: options.environment } : {}),
             ...(options.metadata ? { metadata: options.metadata } : {}),
@@ -244,8 +342,9 @@ export class AntpathClient {
                 ? { proxyEndpoints: proxyEndpointDeclarations }
                 : {})
         };
-        const run = transientBundles.length > 0
-            ? await operations.submitRunFlatMultipart(this.#http, request, transientBundles)
+        const isMultipart = transientBundles.length > 0 || transientAgentsMdParts.length > 0 || transientFileParts.length > 0;
+        const run = isMultipart
+            ? await operations.submitRunFlatMultipart(this.#http, request, transientBundles, transientAgentsMdParts, transientFileParts)
             : await operations.submitRunFlat(this.#http, request);
         return new RunRef(this, run.id);
     }
@@ -441,6 +540,95 @@ function prepareSkills(skills) {
     }
     return { skillRefs, transientBundles };
 }
+/**
+ * Walk the user-provided `AgentsMd[]`, validating each instance and
+ * producing:
+ *   - `agentsMdRefs[]` — the wire entries for `submission.agentsMd[]`,
+ *     with transient refs assigned positional slot ids
+ *     (`agentsmd-0`, `agentsmd-1`, …).
+ *   - `transientAgentsMdParts[]` — the content for each transient
+ *     AgentsMd, parallel-indexed by slot.
+ */
+function prepareAgentsMd(agentsMds) {
+    const agentsMdRefs = [];
+    const transientAgentsMdParts = [];
+    let transientIndex = 0;
+    for (let i = 0; i < agentsMds.length; i++) {
+        const entry = agentsMds[i];
+        if (!(entry instanceof AgentsMd)) {
+            throw new Error(`AntpathClient.submitRun: agentsMd[${i}] must be an AgentsMd instance`);
+        }
+        if (entry.isConsumed) {
+            throw new Error(`AntpathClient.submitRun: agentsMd[${i}] was already uploaded via agentsMd.upload(client); ` +
+                `use the returned AgentsMd or AgentsMd.fromId(record.id) for subsequent runs`);
+        }
+        if (entry.isUnstaged) {
+            const unstaged = entry._takeUnstagedContent();
+            if (!unstaged) {
+                throw new Error(`AntpathClient.submitRun: agentsMd[${i}] is unstaged but has no content (internal invariant violated)`);
+            }
+            const slot = `agentsmd-${transientIndex++}`;
+            agentsMdRefs.push({
+                kind: "transient_agentsmd",
+                slot,
+                name: unstaged.name,
+                contentHash: unstaged.contentHash
+            });
+            transientAgentsMdParts.push({
+                slot,
+                content: unstaged.content,
+                filename: `${unstaged.name}.md`
+            });
+            continue;
+        }
+        agentsMdRefs.push(entry.ref);
+    }
+    return { agentsMdRefs, transientAgentsMdParts };
+}
+/**
+ * Walk the user-provided `File[]`, validating each instance and producing:
+ *   - `fileRefs[]` — the wire entries for `submission.files[]`, with
+ *     transient refs assigned positional slot ids (`file-0`, `file-1`, …).
+ *   - `transientFileParts[]` — the bytes for each transient file, parallel-indexed.
+ */
+function prepareFiles(files) {
+    const fileRefs = [];
+    const transientFileParts = [];
+    let transientIndex = 0;
+    for (let i = 0; i < files.length; i++) {
+        const entry = files[i];
+        if (!(entry instanceof File)) {
+            throw new Error(`AntpathClient.submitRun: files[${i}] must be a File instance`);
+        }
+        if (entry.isConsumed) {
+            throw new Error(`AntpathClient.submitRun: files[${i}] was already uploaded via file.upload(client); ` +
+                `use the returned File or File.fromId(record.id) for subsequent runs`);
+        }
+        if (entry.isUnstaged) {
+            const bundle = entry._takeUnstagedBundle();
+            if (!bundle) {
+                throw new Error(`AntpathClient.submitRun: files[${i}] is unstaged but has no bytes (internal invariant violated)`);
+            }
+            const slot = `file-${transientIndex++}`;
+            fileRefs.push({
+                kind: "transient_file",
+                slot,
+                name: bundle.name,
+                contentHash: bundle.contentHash,
+                ...(bundle.mountPath ? { mountPath: bundle.mountPath } : {})
+            });
+            const shortHash = bundle.contentHash.replace(/^sha256:/, "").slice(0, 12);
+            transientFileParts.push({
+                slot,
+                bytes: bundle.bytes,
+                filename: `antpath-${slot}-${shortHash}.zip`
+            });
+            continue;
+        }
+        fileRefs.push(entry.ref);
+    }
+    return { fileRefs, transientFileParts };
+}
 function mergeMcpServers(inputs, explicitSecrets) {
     const submissionMcpServers = [];
     const secretByName = new Map();