antpath 0.10.15 → 0.11.0

package/dist/_shared/blueprint.js

@@ -83,63 +83,41 @@ export const SKILL_BUNDLE_LIMITS = {
     /** Stored directory mode. */
     defaultDirMode: 0o755
 };
-/**
- * Slot id format: `^[a-z][a-z0-9_-]{0,63}$`. The SDK generates these
- * positionally as `transient-0`, `transient-1`, … but any client may
- * supply an explicit slot as long as it matches the pattern and is
- * unique within the submission.
- */
-export const TRANSIENT_SLOT_PATTERN = /^[a-z][a-z0-9_-]{0,63}$/;
-/**
- * Content-hash format: `^sha256:[0-9a-f]{64}$` (lowercase hex). The
- * BFF accepts only this exact prefix; uppercase, base64, or any other
- * digest is rejected so the wire form has one stable representation.
- */
-export const TRANSIENT_CONTENT_HASH_PATTERN = /^sha256:[0-9a-f]{64}$/;
-export function isWorkspaceSkillRef(ref) {
-    return ref.kind === "workspace";
-}
+/** Content-hash format: `sha256:<64 lowercase hex>`. */
+export const INLINE_CONTENT_HASH_PATTERN = /^sha256:[0-9a-f]{64}$/;
 export function isProviderSkillRef(ref) {
     return ref.kind === "provider";
 }
-export function isTransientSkillRef(ref) {
-    return ref.kind === "transient";
-}
-export function isWorkspaceAgentsMdRef(ref) {
-    return ref.kind === "workspace_agentsmd";
-}
-export function isTransientAgentsMdRef(ref) {
-    return ref.kind === "transient_agentsmd";
+export function isR2SkillRef(ref) {
+    return ref.kind === "r2";
 }
-export function isWorkspaceFileRef(ref) {
-    return ref.kind === "workspace_file";
+/**
+ * R2 asset path pattern. The Worker validates inbound paths against
+ * this so a hostile body can't reach into a foreign workspace or
+ * outside the `assets/` prefix.
+ *   workspaceId is a UUID v4
+ *   hash is 64 lowercase hex chars (the sha256 digest)
+ */
+export const 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}$/;
+export function isR2AgentsMdRef(ref) {
+    return ref.kind === "r2";
 }
-export function isTransientFileRef(ref) {
-    return ref.kind === "transient_file";
+export function isR2FileRef(ref) {
+    return ref.kind === "r2";
 }
 /**
  * Parse a `SkillRef` from untrusted input. Used by the BFF run parser
- * and by the operations module when deserialising API responses. Throws
- * with a precise path so the caller can surface a usable error.
+ * and by the operations module when deserialising API responses. Only
+ * `kind: "r2"` and `kind: "provider"` are valid; all other historical
+ * wire shapes (workspace, inline, transient) were retired when R2
+ * became the canonical asset store (Phase D, references/platform-rebuild-2026.md).
  */
-export function parseSkillRef(input, path, options = {}) {
+export 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") {
@@ -165,31 +143,63 @@ export function parseSkillRef(input, path, options = {}) {
             ...(version !== undefined ? { version } : {})
         };
     }
-    if (kind === "transient") {
-        if (options.allowTransient === false) {
-            throw new Error(`${path} carries a transient SkillRef, which cannot round-trip through JSON — ` +
-                `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'`);
+}
+/**
+ * Common parser for any `kind: "r2"` ref (skill / agentsMd / file).
+ * Skills and agentsMd ignore the optional `mountPath` field; file refs
+ * use it for the Anthropic Files mount remap.
+ */
+export 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}`);
+    }
+    // Cross-field check: the trailing 64-hex segment of `path` MUST be
+    // the lowercase digest from `hash` so a hostile body cannot point
+    // `path` at another tenant's blob and claim a different hash.
+    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 !== undefined && (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 !== undefined ? { mountPath } : {})
+    };
 }
 export class SkillBundleValidationError extends Error {
     constructor(message) {
@@ -341,21 +351,48 @@ export function validateSkillBundleManifest(input) {
 export function hasSkillMdAtRoot(manifest) {
     return manifest.entries.some((entry) => entry.path === "SKILL.md");
 }
+// ---------------------------------------------------------------------------
+// McpServerRef (non-secret) + BlueprintMcpServer (with optional headers)
+// ---------------------------------------------------------------------------
+/**
+ * Remote MCP transports Antpath accepts. Both are over HTTP — `http`
+ * is the streamable-HTTP transport, `sse` is the event-stream
+ * transport. `stdio` is explicitly NOT a value here: local-process
+ * MCP is not implemented (see `references/deepseek-runtime-mcp-plan.md`).
+ */
+export const REMOTE_MCP_TRANSPORTS = ["http", "sse"];
+/**
+ * Canonical error string for any attempt to declare a stdio-shaped MCP
+ * server (`transport: "stdio"`, or a stdio-only field like `command` /
+ * `args` / `env`). Pinned in source so every surface — shared parser,
+ * SDK builder, CLI flag parser, dashboard form — surfaces the same
+ * message and a user can find it via grep.
+ */
+export const REMOTE_MCP_STDIO_REJECTED_MESSAGE = "stdio MCP servers are not supported by Antpath. Antpath supports remote MCP servers over HTTP/SSE only.";
+/**
+ * Stdio-only fields. Used by the parser to detect a stdio shape even
+ * when the caller omits `transport: "stdio"` (e.g. `{ url, command }`
+ * — the presence of `command` alone is enough to identify a stdio
+ * declaration and reject it).
+ */
+const STDIO_ONLY_FIELDS = ["command", "args", "env"];
 export const MCP_SERVER_NAME_PATTERN = /^[a-z][a-z0-9_-]{0,62}$/;
 export 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);
     // Headers belong on `BlueprintMcpServer`, not the non-secret wire ref;
     // and the wire `submission.mcpServers` must NEVER contain headers. So
-    // reject any field other than {name,url} explicitly to make a caller
-    // accidentally inlining `headers` into the non-secret half fail loudly
-    // instead of silently dropping the field. `parseBlueprintMcpServer`
-    // handles the headers case separately for Blueprint-level entries.
+    // reject any field other than {name,url,transport} explicitly to make a
+    // caller accidentally inlining `headers` into the non-secret half fail
+    // loudly instead of silently dropping the field.
+    // `parseBlueprintMcpServer` handles the headers case separately for
+    // Blueprint-level entries.
     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;
@@ -385,7 +422,33 @@ export 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 };
+}
+/**
+ * Throw the canonical stdio-rejected error if the record carries any
+ * stdio-only marker (`transport: "stdio"`, `command`, `args`, `env`).
+ * Used by both the shared parser and the SDK `McpServer.remote`
+ * builder so every entry point surfaces the same message.
+ */
+export 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] !== undefined) {
+            throw new Error(REMOTE_MCP_STDIO_REJECTED_MESSAGE);
+        }
+    }
+}
+function parseRemoteMcpTransport(input, field) {
+    if (input === undefined) {
+        return undefined;
+    }
+    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;
 }
 /**
  * Strict parser for Blueprint-level MCP server entries. Allows only the
@@ -398,13 +461,16 @@ function parseBlueprintMcpServerRef(input, path) {
         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`);
         }
     }
-    // Reuse the {name,url} validator by passing the stripped object.
+    // Reuse the {name,url,transport} validator by passing the stripped object.
     const stripped = { name: record.name, url: record.url };
+    if (record.transport !== undefined)
+        stripped.transport = record.transport;
     const ref = parseMcpServerRef(stripped, path);
     const rawHeaders = record.headers;
     if (rawHeaders === undefined) {
@@ -499,7 +565,7 @@ export function parseBlueprint(input) {
         ...(skills !== undefined ? { skills } : {}),
         ...(mcpServers !== undefined ? { 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 !== undefined
@@ -546,7 +612,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 === undefined) {

package/dist/_shared/cleanup-policy.d.ts

@@ -1,8 +1,8 @@
 /**
  * Provider-neutral cleanup-policy resolution.
  *
- * Reads `cleanup.session` (canonical) and falls back to legacy `cleanup.claudeSession`.
- * Returns the worker default for any malformed shape — never throws.
+ * Reads `cleanup.session`. Returns the worker default for any malformed
+ * shape — never throws.
  */
 export type SessionCleanupPolicy = "retain" | "delete";
 export declare function resolveCleanupPolicyFromSnapshot(snapshot: unknown, fallback: SessionCleanupPolicy): SessionCleanupPolicy;

package/dist/_shared/cleanup-policy.js

@@ -1,8 +1,8 @@
 /**
  * Provider-neutral cleanup-policy resolution.
  *
- * Reads `cleanup.session` (canonical) and falls back to legacy `cleanup.claudeSession`.
- * Returns the worker default for any malformed shape — never throws.
+ * Reads `cleanup.session`. Returns the worker default for any malformed
+ * shape — never throws.
  */
 export function resolveCleanupPolicyFromSnapshot(snapshot, fallback) {
     if (snapshot === null || snapshot === undefined || typeof snapshot !== "object" || Array.isArray(snapshot)) {
@@ -16,9 +16,6 @@ export function resolveCleanupPolicyFromSnapshot(snapshot, fallback) {
     if (policy.session === "retain" || policy.session === "delete") {
         return policy.session;
     }
-    if (policy.claudeSession === "retain" || policy.claudeSession === "delete") {
-        return policy.claudeSession;
-    }
     return fallback;
 }
 //# sourceMappingURL=cleanup-policy.js.map

package/dist/_shared/http.d.ts

@@ -1,8 +1,8 @@
 export type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
 export interface HttpClientOptions {
     /**
-     * Dashboard BFF root. Optional — defaults to `ANTPATH_DEFAULT_BASE_URL`
-     * (`https://www.antpath.ai`). Self-hosted deployments override with their
+     * API plane root. Optional — defaults to `ANTPATH_DEFAULT_BASE_URL`
+     * (`https://api.antpath.ai`). Self-hosted deployments override with their
      * own URL; no env var consults this value.
      */
     readonly baseUrl?: string;

package/dist/_shared/index.d.ts

@@ -3,10 +3,14 @@ export * from "./config.js";
 export * from "./dev-stack.js";
 export * from "./errors.js";
 export * from "./proxy-protocol.js";
-export * from "./secrets.js";
 export * from "./status.js";
 export * from "./submission.js";
+export * from "./mcp-proxy-url.js";
+export * from "./provider-proxy-url.js";
+export * from "./runner-job.js";
+export * from "./runner-event.js";
 export * from "./run-unit.js";
+export * from "./runtime-manifest.js";
 export * from "./stable.js";
 export * from "./sdk-secrets.js";
 export * from "./sdk-errors.js";

package/dist/_shared/index.js

@@ -3,10 +3,14 @@ export * from "./config.js";
 export * from "./dev-stack.js";
 export * from "./errors.js";
 export * from "./proxy-protocol.js";
-export * from "./secrets.js";
 export * from "./status.js";
 export * from "./submission.js";
+export * from "./mcp-proxy-url.js";
+export * from "./provider-proxy-url.js";
+export * from "./runner-job.js";
+export * from "./runner-event.js";
 export * from "./run-unit.js";
+export * from "./runtime-manifest.js";
 // SDK + CLI shared surface — moved here so the published `antpath` SDK
 // and the in-container `antpath` CLI consume the SAME implementation.
 export * from "./stable.js";

package/dist/_shared/mcp-proxy-url.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Per-run Antpath MCP proxy URL + bearer minting types.
+ *
+ * The Antpath MCP proxy is the provider-independent abstraction that
+ * sits between the runtime (Anthropic Managed Agents OR the self-hosted
+ * Claude Code runner) and the customer-supplied MCP server. The
+ * runtime only sees Antpath-issued URLs and a scoped bearer; the
+ * customer's real MCP URL + auth headers stay in the run Vault
+ * bundle and never enter the runtime container.
+ *
+ * See `references/deepseek-runtime-mcp-plan.md` (Remote MCP proxy).
+ */
+/**
+ * Platform-reserved key under which the per-run **MCP** proxy bearer is
+ * folded into the Vault bundle. Distinct from
+ * `__antpath_proxy_token` (which authorises the customer-declared
+ * `proxyEndpoints` route) so the two capabilities can be revoked
+ * independently — `references/deepseek-runtime-mcp-plan.md` (Security
+ * requirements: provider proxy and MCP proxy tokens are separate
+ * capabilities).
+ *
+ * The shared `parseInlineSecrets` rejects any inbound submission whose
+ * `secrets` carries a key with the `__antpath_` prefix, so this key
+ * can only be set by the BFF after the parser runs.
+ */
+export declare const MCP_PROXY_BEARER_BUNDLE_KEY = "__antpath_mcp_proxy_token";
+/**
+ * Output of the per-run MCP proxy bearer mint. Same shape as the
+ * customer-proxy mint — the value is folded into the Vault bundle
+ * under {@link MCP_PROXY_BEARER_BUNDLE_KEY}; the hash + expiry are
+ * persisted on the runs row in dedicated columns so the two
+ * capabilities have independent lifetimes.
+ */
+export interface MintedMcpProxyBearer {
+    readonly plaintext: string;
+    readonly hash: string;
+    readonly expiresAt: Date;
+}
+/**
+ * Canonical URL path of the per-run MCP proxy endpoint. The BFF route
+ * lives at `/api/runs/[runId]/mcp/[mcpName]`; runtimes / providers
+ * receive the absolute URL from {@link buildMcpProxyUrl}.
+ */
+export declare function mcpProxyPath(runId: string, mcpName: string): string;
+/**
+ * Build the absolute per-run, per-MCP proxy URL. `baseUrl` is the
+ * configured Antpath API plane root (e.g. `https://api.antpath.ai`);
+ * the function strips any trailing slash and appends
+ * `/api/runs/<runId>/mcp/<mcpName>`.
+ */
+export declare function buildMcpProxyUrl(args: {
+    readonly baseUrl: string;
+    readonly runId: string;
+    readonly mcpName: string;
+}): string;

package/dist/_shared/mcp-proxy-url.js

@@ -0,0 +1,65 @@
+/**
+ * Per-run Antpath MCP proxy URL + bearer minting types.
+ *
+ * The Antpath MCP proxy is the provider-independent abstraction that
+ * sits between the runtime (Anthropic Managed Agents OR the self-hosted
+ * Claude Code runner) and the customer-supplied MCP server. The
+ * runtime only sees Antpath-issued URLs and a scoped bearer; the
+ * customer's real MCP URL + auth headers stay in the run Vault
+ * bundle and never enter the runtime container.
+ *
+ * See `references/deepseek-runtime-mcp-plan.md` (Remote MCP proxy).
+ */
+import { MCP_SERVER_NAME_PATTERN } from "./blueprint.js";
+/**
+ * Platform-reserved key under which the per-run **MCP** proxy bearer is
+ * folded into the Vault bundle. Distinct from
+ * `__antpath_proxy_token` (which authorises the customer-declared
+ * `proxyEndpoints` route) so the two capabilities can be revoked
+ * independently — `references/deepseek-runtime-mcp-plan.md` (Security
+ * requirements: provider proxy and MCP proxy tokens are separate
+ * capabilities).
+ *
+ * The shared `parseInlineSecrets` rejects any inbound submission whose
+ * `secrets` carries a key with the `__antpath_` prefix, so this key
+ * can only be set by the BFF after the parser runs.
+ */
+export const MCP_PROXY_BEARER_BUNDLE_KEY = "__antpath_mcp_proxy_token";
+/**
+ * Canonical URL path of the per-run MCP proxy endpoint. The BFF route
+ * lives at `/api/runs/[runId]/mcp/[mcpName]`; runtimes / providers
+ * receive the absolute URL from {@link buildMcpProxyUrl}.
+ */
+export function mcpProxyPath(runId, mcpName) {
+    if (!runId || typeof runId !== "string") {
+        throw new Error("mcpProxyPath: runId must be a non-empty string");
+    }
+    if (!mcpName || typeof mcpName !== "string" || !MCP_SERVER_NAME_PATTERN.test(mcpName)) {
+        throw new Error(`mcpProxyPath: mcpName must match ${MCP_SERVER_NAME_PATTERN.source}`);
+    }
+    return `/api/runs/${encodeURIComponent(runId)}/mcp/${encodeURIComponent(mcpName)}`;
+}
+/**
+ * Build the absolute per-run, per-MCP proxy URL. `baseUrl` is the
+ * configured Antpath API plane root (e.g. `https://api.antpath.ai`);
+ * the function strips any trailing slash and appends
+ * `/api/runs/<runId>/mcp/<mcpName>`.
+ */
+export function buildMcpProxyUrl(args) {
+    if (!args.baseUrl || typeof args.baseUrl !== "string") {
+        throw new Error("buildMcpProxyUrl: baseUrl must be a non-empty string");
+    }
+    let parsedBase;
+    try {
+        parsedBase = new URL(args.baseUrl);
+    }
+    catch {
+        throw new Error(`buildMcpProxyUrl: baseUrl is not a valid URL: ${args.baseUrl}`);
+    }
+    if (parsedBase.protocol !== "https:" && parsedBase.protocol !== "http:") {
+        throw new Error(`buildMcpProxyUrl: baseUrl protocol must be http or https (got ${parsedBase.protocol})`);
+    }
+    const trimmedBase = `${parsedBase.origin}${parsedBase.pathname.replace(/\/+$/, "")}`;
+    return `${trimmedBase}${mcpProxyPath(args.runId, args.mcpName)}`;
+}
+//# sourceMappingURL=mcp-proxy-url.js.map

package/dist/_shared/operations.d.ts

@@ -2,7 +2,7 @@ import type { HttpClient } from "./http.js";
 import type { RunUnit } from "./run-unit.js";
 import type { AgentsMdRecord, FileRecord, Output, Run, RunEvent, SignedOutputLink, Skill, WhoAmI } from "./runtime-types.js";
 import { type SseFrame } from "./sse.js";
-import type { PlatformFlatRunSubmissionInput, PlatformRunSubmissionInput } from "./submission.js";
+import type { PlatformRunSubmissionInput } from "./submission.js";
 /**
  * The single source of truth for SDK<->BFF transport. The SDK class
  * AND the CLI subcommands both call these functions; neither
@@ -16,14 +16,13 @@ import type { PlatformFlatRunSubmissionInput, PlatformRunSubmissionInput } from
  * `references/development-principles.md` (Agent-first surface design,
  * Concrete rule 3).
  */
-export declare function submitRun(http: HttpClient, request: PlatformRunSubmissionInput): Promise<Run>;
 export declare function getRun(http: HttpClient, runId: string): Promise<Run>;
 /**
  * Strongly-typed accessor for the full self-contained run unit:
  * parsed submission inputs, attempts, indexed events (with
  * pagination cursor for large runs), raw-event Storage manifest,
  * outputs, capture failures, proxy-call audit, pinned skills,
- * provider skills, transient skills.
+ * provider skills, inline skills.
  *
  * Backed by the same `GET /api/runs/:runId` endpoint that
  * `getRun` calls; this variant just narrows the return type to
@@ -97,15 +96,15 @@ export declare function whoami(http: HttpClient): Promise<WhoAmI>;
  * + `partial` fields.
  */
 export declare function downloadRunArchive(http: HttpClient, runId: string): Promise<Response>;
-export declare function submitRunFlat(http: HttpClient, request: PlatformFlatRunSubmissionInput): Promise<Run>;
+export declare function submitRun(http: HttpClient, request: PlatformRunSubmissionInput): Promise<Run>;
 /**
- * Multipart variant of `submitRunFlat` for runs that carry transient
+ * Multipart variant of `submitRun` for runs that carry transient
  * (per-run) skill bundles and/or transient AgentsMd content.
  *
  * The JSON submission travels as the `submission` part; each
- * `TransientSkillRef.slot` in `request.submission.skills` MUST be
+ * `InlineSkillRef.slot` in `request.submission.skills` MUST be
  * mirrored by exactly one `skill:<slot>` part with the bundle bytes.
- * Each `TransientAgentsMdRef.slot` in `request.submission.agentsMd`
+ * Each `InlineAgentsMdRef.slot` in `request.submission.agentsMd`
  * MUST be mirrored by exactly one `agentsmd:<slot>` part with the
  * markdown text.
  *
@@ -114,7 +113,7 @@ export declare function submitRunFlat(http: HttpClient, request: PlatformFlatRun
  *
  * At least one of `bundles` or `agentsMdParts` must be non-empty.
  */
-export declare function submitRunFlatMultipart(http: HttpClient, request: PlatformFlatRunSubmissionInput, bundles: ReadonlyArray<{
+export declare function submitRunMultipart(http: HttpClient, request: PlatformRunSubmissionInput, bundles: ReadonlyArray<{
     readonly slot: string;
     readonly bytes: Uint8Array;
     readonly filename: string;