antpath 0.10.14 → 0.11.0

package/dist/cli.mjs.sha256

@@ -1 +1 @@
-e4711068466806825d0e897c6266a8cb2141e584de6ee4f0116be17a16a185b2  cli.mjs
+ba35805b91e9b19eeeead9f80278140797287bc4d14e6618b842354cb2cb3208  cli.mjs

package/dist/client.d.ts

@@ -1,17 +1,16 @@
-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 { HttpClient, type AgentsMdRecord, type FetchLike, type FileRecord, type Output, type PlatformRunSubmissionInput, type PlatformSubmission, type PlatformInlineSecrets, type PlatformProxyEndpoint, type PlatformProxyEndpointAuth, type Run, type RunEvent, type RunProvider, type RunUnit, type RuntimeKind, type RuntimeManifest, 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;
     /**
-     * Dashboard BFF root, e.g. `https://antpath.example.com`. Optional —
-     * defaults to the canonical hosted URL (`https://www.antpath.ai`).
+     * API plane root, e.g. `https://antpath.example.com`. Optional —
+     * defaults to the canonical hosted URL (`https://api.antpath.ai`).
      * Self-hosted deployments override; the default lives in source so
      * the agent reading the SDK call site can see exactly where the call
      * goes.
@@ -27,7 +26,7 @@ export interface AntpathClientOptions {
  *   - `model` / `system` / `prompt` — the agent's brief.
  *   - `skills` — array of `Skill` instances. Each instance is one of:
  *     workspace ref (`Skill.fromId` or the result of `.upload(client)`),
- *     provider ref (`Skill.provider`), or unstaged transient
+ *     provider ref (`Skill.provider`), or unstaged inline
  *     (`Skill.fromFiles` / `Skill.fromPath`). Unstaged transient
  *     skills cause `submitRun` to switch to multipart and upload the
  *     bytes for this one run only.
@@ -45,6 +44,23 @@ export interface AntpathClientOptions {
  * if you want client-driven retry safety across process restarts.
  */
 export interface SubmitRunOptions {
+    /**
+     * Provider selector. Optional — defaults to
+     * {@link DEFAULT_RUN_PROVIDER} (`"anthropic"`). The call site must
+     * supply the matching `secrets.<provider>.apiKey` and MUST NOT
+     * supply any other provider's secret block. See
+     * `references/platform-rebuild-2026.md` (Customer interface).
+     */
+    readonly provider?: RunProvider;
+    /**
+     * Optional runtime opt-out. `"managed"` forces the Goose Managed
+     * runtime (Fly Machine + LiteLLM); `"native"` is only valid when
+     * `provider === "anthropic"` and routes through Anthropic's Managed
+     * Agents API. Omit to let the platform auto-route based on provider.
+     * The platform rejects features the chosen runtime cannot serve —
+     * see {@link selectRuntime}.
+     */
+    readonly runtime?: RuntimeKind;
     readonly model: string;
     readonly system?: string;
     readonly prompt: string | readonly string[];
@@ -52,9 +68,9 @@ export interface SubmitRunOptions {
     readonly agentsMd?: readonly AgentsMd[];
     readonly files?: readonly File[];
     readonly mcpServers?: readonly McpServer[];
-    readonly environment?: PlatformFlatSubmission["environment"];
-    readonly metadata?: PlatformFlatSubmission["metadata"];
-    readonly cleanup?: PlatformFlatRunSubmissionInput["cleanup"];
+    readonly environment?: PlatformSubmission["environment"];
+    readonly metadata?: PlatformSubmission["metadata"];
+    readonly cleanup?: PlatformRunSubmissionInput["cleanup"];
     readonly proxyEndpoints?: readonly ProxyEndpoint[];
     /**
      * Container paths to capture as `output_objects` at session terminal.
@@ -76,8 +92,19 @@ export interface SubmitRunOptions {
     readonly signal?: AbortSignal;
 }
 export interface StreamEventsOptions {
+    /** Polling interval in ms — used by the `polling` transport and as
+     *  the fallback when SSE disconnects. Default 1000. */
     readonly intervalMs?: number;
     readonly signal?: AbortSignal;
+    /**
+     * Transport selector. `"auto"` (default) opens an SSE connection;
+     * on disconnect (server-side error, network blip, missing endpoint
+     * on older deployments) it falls back to polling for the remaining
+     * lifetime of the run. `"sse"` forces SSE and surfaces disconnects
+     * as iterator completion. `"polling"` keeps the historical poll
+     * loop — useful for environments without streaming support.
+     */
+    readonly transport?: "auto" | "sse" | "polling";
 }
 export interface WaitForRunOptions {
     readonly intervalMs?: number;
@@ -88,11 +115,18 @@ export interface WaitForRunOptions {
  * Lightweight reference to a submitted run. All read-back operations
  * delegate to the same `AntpathClient` and the same operations module
  * the CLI uses, so SDK and CLI never drift.
+ *
+ * `runtimeManifest` is the per-run, per-provider description of where
+ * antpath placed things inside the agent container, plus the merged
+ * env-var bag delivered via `RUNTIME.env` / `RUNTIME.json`. Populated
+ * on instances returned by `submitRun`; instances constructed by `id`
+ * elsewhere call `.get()` to populate the field via the GET response.
  */
 export declare class RunRef {
     #private;
     readonly runId: string;
-    constructor(client: AntpathClient, runId: string);
+    readonly runtimeManifest?: RuntimeManifest;
+    constructor(client: AntpathClient, runId: string, runtimeManifest?: RuntimeManifest);
     get(): Promise<Run>;
     /** Convenience wrapper for `AntpathClient.getRunUnit`. */
     getUnit(): Promise<RunUnit>;
@@ -277,14 +311,6 @@ export declare class AntpathClient {
         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` +
@@ -300,7 +326,7 @@ export declare class AntpathClient {
      * before sending so credentials never enter the hashed submission or
      * the run snapshot.
      *
-     * Unstaged transient skills (`Skill.fromFiles` / `Skill.fromPath`
+     * Unstaged inline skills (`Skill.fromFiles` / `Skill.fromPath`
      * 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
@@ -317,16 +343,21 @@ export declare class AntpathClient {
      * attempts, indexed events (inline + cursor for the tail), raw
      * provider-event Storage manifest, outputs, capture failures,
      * proxy-call audit, pinned workspace skills, provider skills,
-     * transient skills. Backed by the same endpoint as `getRun` but
+     * inline skills. Backed by the same endpoint as `getRun` but
      * typed against the full wire shape — use this when you need
      * fields beyond `{id, status, timestamps, usage}`.
      */
     getRunUnit(runId: string): Promise<RunUnit>;
     listEvents(runId: string): Promise<readonly RunEvent[]>;
     /**
-     * Poll the events endpoint and yield new events as they arrive. Stops
-     * when the run reaches a terminal state, when the signal is aborted,
-     * or when the caller breaks out of the iterator.
+     * Yield run events as they arrive. The default transport is SSE
+     * (`/api/runs/:id/events/stream`); on disconnect it falls back to
+     * polling for the remaining lifetime of the run, so older
+     * deployments without the SSE endpoint and transient network blips
+     * both keep working.
+     *
+     * Stops when the run reaches a terminal state, when the signal is
+     * aborted, or when the caller breaks out of the iterator.
      */
     streamEvents(runId: string, options?: StreamEventsOptions): AsyncIterable<RunEvent>;
     /**

package/dist/client.js

@@ -1,4 +1,5 @@
-import { HttpClient, operations, reportTelemetryError } from "./_shared/index.js";
+import { DEFAULT_RUN_PROVIDER, HttpClient, operations, reportTelemetryError } from "./_shared/index.js";
+import { uploadAssetToR2 } from "./asset-upload.js";
 import { SDK_VERSION } from "./version.js";
 import { AgentsMd } from "./agents-md.js";
 import { File } from "./file.js";
@@ -9,13 +10,23 @@ import { Skill } from "./skill.js";
  * Lightweight reference to a submitted run. All read-back operations
  * delegate to the same `AntpathClient` and the same operations module
  * the CLI uses, so SDK and CLI never drift.
+ *
+ * `runtimeManifest` is the per-run, per-provider description of where
+ * antpath placed things inside the agent container, plus the merged
+ * env-var bag delivered via `RUNTIME.env` / `RUNTIME.json`. Populated
+ * on instances returned by `submitRun`; instances constructed by `id`
+ * elsewhere call `.get()` to populate the field via the GET response.
  */
 export class RunRef {
     runId;
+    runtimeManifest;
     #client;
-    constructor(client, runId) {
+    constructor(client, runId, runtimeManifest) {
         this.#client = client;
         this.runId = runId;
+        if (runtimeManifest) {
+            this.runtimeManifest = runtimeManifest;
+        }
     }
     get() {
         return this.#client.getRun(this.runId);
@@ -259,17 +270,6 @@ export class AntpathClient {
     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` +
@@ -288,7 +288,7 @@ export class AntpathClient {
      * before sending so credentials never enter the hashed submission or
      * the run snapshot.
      *
-     * Unstaged transient skills (`Skill.fromFiles` / `Skill.fromPath`
+     * Unstaged inline skills (`Skill.fromFiles` / `Skill.fromPath`
      * 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
@@ -302,8 +302,24 @@ export class AntpathClient {
         if (!options || typeof options !== "object") {
             throw new Error("AntpathClient.submitRun: options is required");
         }
-        if (!options.secrets || !options.secrets.anthropic?.apiKey) {
-            throw new Error("AntpathClient.submitRun: secrets.anthropic.apiKey is required");
+        const provider = options.provider ?? DEFAULT_RUN_PROVIDER;
+        if (!options.secrets) {
+            throw new Error("AntpathClient.submitRun: secrets is required");
+        }
+        // The matching provider's apiKey is required; every OTHER provider's
+        // secret block must be absent. The shared parser re-runs this check
+        // on the server; failing early here gives the caller a synchronous
+        // error before any network call.
+        const providerSecret = options.secrets[provider];
+        if (!providerSecret?.apiKey) {
+            throw new Error(`AntpathClient.submitRun: secrets.${provider}.apiKey is required`);
+        }
+        for (const other of ["anthropic", "deepseek", "openai", "gemini", "mistral"]) {
+            if (other === provider)
+                continue;
+            if (options.secrets[other] !== undefined) {
+                throw new Error(`AntpathClient.submitRun: secrets.${other} is not allowed when provider is ${provider}`);
+            }
         }
         if (typeof options.model !== "string" || !options.model) {
             throw new Error("AntpathClient.submitRun: model is required");
@@ -311,22 +327,25 @@ export class AntpathClient {
         const prompt = normalisePrompt(options.prompt);
         const { endpoints: proxyEndpointDeclarations, auth: proxyEndpointAuthFromInstances } = splitProxyEndpoints(options.proxyEndpoints ?? []);
         const mergedProxyAuth = mergeProxyEndpointAuth(proxyEndpointAuthFromInstances, options.secrets.proxyEndpointAuth ?? []);
-        const { skillRefs, transientBundles } = prepareSkills(options.skills ?? []);
-        const { agentsMdRefs, transientAgentsMdParts } = prepareAgentsMd(options.agentsMd ?? []);
-        const { fileRefs, transientFileParts } = prepareFiles(options.files ?? []);
+        // Phase B + D: walk Skill / AgentsMd / File instances, materialize
+        // every draft (local bytes) to R2 BEFORE the submit round-trip.
+        // The wire shape carries only kind:"r2" / kind:"provider" refs.
+        const r2Skills = await materializeSkills(this.#http, options.skills ?? []);
+        const r2AgentsMd = await materializeAgentsMd(this.#http, options.agentsMd ?? []);
+        const r2Files = await materializeFiles(this.#http, 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,
+            skills: r2Skills,
+            agentsMd: r2AgentsMd,
+            files: r2Files,
             // submissionMcpServers may contain workspace refs of the shape
             // {kind:"workspace", id:"mcp_..."}. The BFF runs
             // `resolveWorkspaceMcpRefsInSubmission` BEFORE the shared parser
             // and replaces them with the resolved {name, url}, so by the
-            // time anything reads PlatformFlatSubmission post-parse the
+            // time anything reads PlatformSubmission post-parse the
             // shape matches McpServerRef. The cast acknowledges that the
             // SDK is producing pre-resolution wire input here.
             mcpServers: submissionMcpServers,
@@ -343,6 +362,15 @@ export class AntpathClient {
         };
         const request = {
             idempotencyKey: options.idempotencyKey ?? generateIdempotencyKey(),
+            // Always include `provider` on the wire so dashboard / proxy
+            // tooling never has to second-guess what the runtime saw. The
+            // shared parser still defaults to `anthropic` when callers omit
+            // the field entirely, but the SDK has resolved it by here.
+            provider,
+            // `runtime` is optional on the wire — absent means let the
+            // dispatcher auto-route. Only emit it when the caller asked for
+            // a specific runtime so the wire shape stays minimal.
+            ...(options.runtime ? { runtime: options.runtime } : {}),
             submission,
             ...(options.cleanup ? { cleanup: options.cleanup } : {}),
             secrets,
@@ -350,12 +378,11 @@ export class AntpathClient {
                 ? { proxyEndpoints: proxyEndpointDeclarations }
                 : {})
         };
-        const isMultipart = transientBundles.length > 0 || transientAgentsMdParts.length > 0 || transientFileParts.length > 0;
+        // All inline refs were materialized to R2 above, so submitRun is
+        // always a plain JSON post. The multipart code path is gone.
         let run;
         try {
-            run = isMultipart
-                ? await operations.submitRunFlatMultipart(this.#http, request, transientBundles, transientAgentsMdParts, transientFileParts)
-                : await operations.submitRunFlat(this.#http, request);
+            run = await operations.submitRun(this.#http, request);
         }
         catch (err) {
             // Fire-and-forget telemetry for unexpected submit failures so we
@@ -375,13 +402,12 @@ export class AntpathClient {
                     status: typeof err.status === "number"
                         ? err.status
                         : undefined,
-                    message: err?.message?.slice(0, 200) ?? null,
-                    multipart: isMultipart
+                    message: err?.message?.slice(0, 200) ?? null
                 }
             });
             throw err;
         }
-        return new RunRef(this, run.id);
+        return new RunRef(this, run.id, extractRuntimeManifest(run));
     }
     getRun(runId) {
         return operations.getRun(this.#http, runId);
@@ -391,7 +417,7 @@ export class AntpathClient {
      * attempts, indexed events (inline + cursor for the tail), raw
      * provider-event Storage manifest, outputs, capture failures,
      * proxy-call audit, pinned workspace skills, provider skills,
-     * transient skills. Backed by the same endpoint as `getRun` but
+     * inline skills. Backed by the same endpoint as `getRun` but
      * typed against the full wire shape — use this when you need
      * fields beyond `{id, status, timestamps, usage}`.
      */
@@ -402,19 +428,67 @@ export class AntpathClient {
         return operations.listRunEvents(this.#http, runId);
     }
     /**
-     * Poll the events endpoint and yield new events as they arrive. Stops
-     * when the run reaches a terminal state, when the signal is aborted,
-     * or when the caller breaks out of the iterator.
+     * Yield run events as they arrive. The default transport is SSE
+     * (`/api/runs/:id/events/stream`); on disconnect it falls back to
+     * polling for the remaining lifetime of the run, so older
+     * deployments without the SSE endpoint and transient network blips
+     * both keep working.
+     *
+     * Stops when the run reaches a terminal state, when the signal is
+     * aborted, or when the caller breaks out of the iterator.
      */
     async *streamEvents(runId, options = {}) {
-        const intervalMs = options.intervalMs ?? 1_000;
+        const transport = options.transport ?? "auto";
         const signal = options.signal;
         const seenIds = new Set();
+        let cursor;
+        if (transport !== "polling") {
+            while (!signal?.aborted) {
+                const outcome = yield* this.#streamEventsSseRound(runId, {
+                    cursor: cursor,
+                    signal: signal,
+                    seenIds
+                });
+                cursor = outcome.nextCursor;
+                if (outcome.kind === "terminal" || outcome.kind === "aborted")
+                    return;
+                if (transport === "sse")
+                    return; // disconnects surface as completion
+                // "auto" — fall through to polling for the rest of the run.
+                break;
+            }
+        }
+        if (signal?.aborted)
+            return;
+        yield* this.#streamEventsPolling(runId, { ...options, seenIds });
+    }
+    async *#streamEventsSseRound(runId, opts) {
+        const streamOpts = {};
+        if (opts.cursor !== undefined)
+            streamOpts.cursor = opts.cursor;
+        if (opts.signal !== undefined)
+            streamOpts.signal = opts.signal;
+        const iter = operations.streamRunEventsSse(this.#http, runId, streamOpts);
+        while (true) {
+            const next = await iter.next();
+            if (next.done) {
+                return next.value;
+            }
+            const event = next.value;
+            if (!opts.seenIds.has(event.id)) {
+                opts.seenIds.add(event.id);
+                yield event;
+            }
+        }
+    }
+    async *#streamEventsPolling(runId, options) {
+        const intervalMs = options.intervalMs ?? 1_000;
+        const signal = options.signal;
         while (!signal?.aborted) {
             const events = await this.listEvents(runId);
             for (const event of events) {
-                if (!seenIds.has(event.id)) {
-                    seenIds.add(event.id);
+                if (!options.seenIds.has(event.id)) {
+                    options.seenIds.add(event.id);
                     yield event;
                 }
             }
@@ -477,6 +551,20 @@ const TERMINAL_STATUSES = new Set([
     "canceled",
     "cleaned_up"
 ]);
+/**
+ * Pull the runtime manifest off a submitRun / getRun response. The
+ * field is optional on the wire shape (older BFFs predate it); we
+ * return `undefined` when absent rather than fabricating a default,
+ * so callers can detect deployment skew explicitly.
+ */
+function extractRuntimeManifest(run) {
+    if (!run || typeof run !== "object")
+        return undefined;
+    const value = run.runtimeManifest;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    return value;
+}
 function isTerminal(status) {
     return typeof status === "string" && TERMINAL_STATUSES.has(status);
 }
@@ -524,145 +612,123 @@ function normalisePrompt(input) {
  * Walk the user-provided `Skill[]`, validating each instance and
  * producing:
  *   - `skillRefs[]` — the wire entries for `submission.skills[]`, with
- *     transient refs assigned positional slot ids (`transient-0`, …).
- *   - `transientBundles[]` — the bytes for each transient skill,
+ *     inline refs assigned positional slot ids (`transient-0`, …).
+ *   - `inlineBundles[]` — the bytes for each inline skill,
  *     parallel-indexed by slot.
  *
  * Throws on consumed Skills (the user kept a stale reference past an
  * `.upload(client)` call) with the same error message documented in
  * `Skill.upload` — that mistake is loud, not silent.
  */
-function prepareSkills(skills) {
-    const skillRefs = [];
-    const transientBundles = [];
-    let transientIndex = 0;
+/**
+ * Walk the user-provided Skill[], materialize every draft to R2,
+ * return the wire-shape refs. Provider skills pass through.
+ */
+async function materializeSkills(http, skills) {
+    const out = [];
     for (let i = 0; i < skills.length; i++) {
         const entry = skills[i];
         if (!(entry instanceof Skill)) {
             throw new Error(`AntpathClient.submitRun: skills[${i}] must be a Skill instance`);
         }
         if (entry.isConsumed) {
-            throw new Error(`AntpathClient.submitRun: skills[${i}] was already uploaded via skill.upload(client); ` +
-                `use the returned Skill or Skill.fromId(record.id) for subsequent runs`);
+            throw new Error(`AntpathClient.submitRun: skills[${i}] was already consumed by a prior submitRun`);
         }
-        if (entry.isUnstaged) {
-            const bundle = entry._takeUnstagedBundle();
+        const ref = entry.ref;
+        if (ref.kind === "draft") {
+            const bundle = entry._takeDraftBundle();
             if (!bundle) {
-                // Defence-in-depth: `isUnstaged` guarantees bytes exist.
-                throw new Error(`AntpathClient.submitRun: skills[${i}] is unstaged but has no bytes (internal invariant violated)`);
+                throw new Error(`AntpathClient.submitRun: skills[${i}] is draft but has no bytes`);
             }
-            const slot = `transient-${transientIndex++}`;
-            skillRefs.push({
-                kind: "transient",
-                slot,
-                name: bundle.name,
-                contentHash: bundle.contentHash
-            });
-            // Anthropic filenames forbid `<>:"|?*\/` and control chars 0-31,
-            // so the multipart filename uses hyphen separators. The 12-char
-            // hash prefix is enough for janitor / orphan reconciliation;
-            // the BFF stamps the full run-scoped filename once it knows the
-            // run id.
-            const shortHash = bundle.contentHash.replace(/^sha256:/, "").slice(0, 12);
-            transientBundles.push({
-                slot,
+            const uploaded = await uploadAssetToR2({
+                http,
                 bytes: bundle.bytes,
-                filename: `antpath-${slot}-${shortHash}.zip`
+                hash: bundle.contentHash
+            });
+            out.push({
+                kind: "r2",
+                path: uploaded.path,
+                hash: uploaded.hash,
+                sizeBytes: uploaded.sizeBytes,
+                name: bundle.name
             });
             continue;
         }
-        skillRefs.push(entry.ref);
+        // Provider or r2 (re-used from a previous materialization).
+        out.push(ref);
     }
-    return { skillRefs, transientBundles };
+    return out;
 }
-/**
- * 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;
+/** Materialize draft AgentsMd[] to R2; pass-through any already-r2. */
+async function materializeAgentsMd(http, agentsMds) {
+    const out = [];
     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`);
+            throw new Error(`AntpathClient.submitRun: agentsMd[${i}] was already consumed by a prior submitRun`);
         }
-        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 ref = entry.ref;
+        if (ref.kind === "draft") {
+            const bundle = entry._takeDraftBundle();
+            if (!bundle) {
+                throw new Error(`AntpathClient.submitRun: agentsMd[${i}] is draft but has no bytes`);
             }
-            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`
+            const uploaded = await uploadAssetToR2({ http, bytes: bundle.bytes, hash: bundle.contentHash });
+            out.push({
+                kind: "r2",
+                path: uploaded.path,
+                hash: uploaded.hash,
+                sizeBytes: uploaded.sizeBytes,
+                name: bundle.name
             });
             continue;
         }
-        agentsMdRefs.push(entry.ref);
+        out.push(ref);
     }
-    return { agentsMdRefs, transientAgentsMdParts };
+    return out;
 }
-/**
- * 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;
+/** Materialize draft File[] to R2; pass-through any already-r2. */
+async function materializeFiles(http, files) {
+    const out = [];
     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`);
+            throw new Error(`AntpathClient.submitRun: files[${i}] was already consumed by a prior submitRun`);
         }
-        if (entry.isUnstaged) {
-            const bundle = entry._takeUnstagedBundle();
+        const ref = entry.ref;
+        if (ref.kind === "draft") {
+            const bundle = entry._takeDraftBundle();
             if (!bundle) {
-                throw new Error(`AntpathClient.submitRun: files[${i}] is unstaged but has no bytes (internal invariant violated)`);
+                throw new Error(`AntpathClient.submitRun: files[${i}] is draft but has no bytes`);
             }
-            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`
-            });
+            const uploaded = await uploadAssetToR2({ http, bytes: bundle.bytes, hash: bundle.contentHash });
+            out.push(bundle.mountPath !== undefined
+                ? {
+                    kind: "r2",
+                    path: uploaded.path,
+                    hash: uploaded.hash,
+                    sizeBytes: uploaded.sizeBytes,
+                    name: bundle.name,
+                    mountPath: bundle.mountPath
+                }
+                : {
+                    kind: "r2",
+                    path: uploaded.path,
+                    hash: uploaded.hash,
+                    sizeBytes: uploaded.sizeBytes,
+                    name: bundle.name
+                });
             continue;
         }
-        fileRefs.push(entry.ref);
+        out.push(ref);
     }
-    return { fileRefs, transientFileParts };
+    return out;
 }
 function mergeMcpServers(inputs, explicitSecrets) {
     const submissionMcpServers = [];