antpath 0.9.2 → 0.10.7

package/dist/_shared/blueprint.d.ts

@@ -135,6 +135,55 @@ export declare const TRANSIENT_CONTENT_HASH_PATTERN: RegExp;
 export declare function isWorkspaceSkillRef(ref: SkillRef): ref is WorkspaceSkillRef;
 export declare function isProviderSkillRef(ref: SkillRef): ref is ProviderSkillRef;
 export declare function isTransientSkillRef(ref: SkillRef): ref is TransientSkillRef;
+export type AgentsMdRef = WorkspaceAgentsMdRef | TransientAgentsMdRef;
+export interface WorkspaceAgentsMdRef {
+    readonly kind: "workspace_agentsmd";
+    readonly id: string;
+}
+/**
+ * Inline-supplied AgentsMd content that arrives as the
+ * `agentsmd:<slot>` part of a multipart `submitRun` body. The BFF
+ * ingests the bytes into `workspace_files` (kind='agentsmd') at
+ * submission time and rewrites the ref to `WorkspaceAgentsMdRef`
+ * before the rest of the run-submission pipeline runs.
+ *
+ * `name` becomes the prefix of the auto-suffixed workspace name,
+ * mirroring the `Skill` per-run-artifact model. `contentHash` is
+ * the SDK's advisory `sha256:<hex>` for tamper detection.
+ */
+export interface TransientAgentsMdRef {
+    readonly kind: "transient_agentsmd";
+    readonly slot: string;
+    readonly name: string;
+    readonly contentHash: string;
+}
+export declare function isWorkspaceAgentsMdRef(ref: AgentsMdRef): ref is WorkspaceAgentsMdRef;
+export declare function isTransientAgentsMdRef(ref: AgentsMdRef): ref is TransientAgentsMdRef;
+export type FileRef = WorkspaceFileRef | TransientFileRef;
+export interface WorkspaceFileRef {
+    readonly kind: "workspace_file";
+    readonly id: string;
+}
+/**
+ * Inline-supplied File content that arrives as the `file:<slot>`
+ * part of a multipart `submitRun` body. Single file or a zipped
+ * folder. The BFF ingests and rewrites the ref to
+ * `WorkspaceFileRef` before run submission proceeds.
+ *
+ * `name` is the workspace-visible name prefix. `contentHash` is the
+ * SDK's advisory `sha256:<hex>`. `mountPath` is optional — when
+ * present it overrides the default `/antpath/files/<id>/<rel>` mount
+ * layout (e.g. user-chosen `/workspace/data`).
+ */
+export interface TransientFileRef {
+    readonly kind: "transient_file";
+    readonly slot: string;
+    readonly name: string;
+    readonly contentHash: string;
+    readonly mountPath?: string;
+}
+export declare function isWorkspaceFileRef(ref: FileRef): ref is WorkspaceFileRef;
+export declare function isTransientFileRef(ref: FileRef): ref is TransientFileRef;
 /**
  * Options accepted by `parseSkillRef`. The default (`allowTransient: true`)
  * is the BFF submission parser path. The Blueprint parser passes
@@ -201,14 +250,20 @@ export declare function validateSkillBundleEntry(input: {
     readonly mode?: number;
 }): SkillBundleEntry;
 /**
- * Validate a full manifest. Enforces:
+ * Validate a full **skill bundle** manifest. Enforces:
  *   - entries is a non-empty array
- *   - `SKILL.md` exists at the bundle root (Claude's auto-discovery key)
+ *   - `SKILL.md` exists at the bundle root (this is what makes a
+ *     bundle a skill rather than a plain workspace file)
  *   - file count <= maxFiles
  *   - total uncompressed size <= maxDecompressedBytes
  *   - per-entry validation (see `validateSkillBundleEntry`)
  *   - no duplicate paths
  *
+ * Per the May-2026 decision log in
+ * `references/agent-context-uploads.md`, **skill** means "Claude
+ * Skill" — bundles without `SKILL.md` are not skills and must go
+ * through the `AgentsMd` or `File` upload concepts instead.
+ *
  * Returns a canonical manifest with totals computed.
  */
 export declare function validateSkillBundleManifest(input: ReadonlyArray<{
@@ -216,6 +271,19 @@ export declare function validateSkillBundleManifest(input: ReadonlyArray<{
     readonly size: number;
     readonly mode?: number;
 }>): SkillBundleManifest;
+/**
+ * Returns true when the manifest carries a `SKILL.md` entry at the
+ * bundle root. The presence of this file is Anthropic's
+ * skill-auto-discovery signal — bundles that have it are treated as
+ * Claude skills and mounted accordingly; bundles that don't are still
+ * usable agent context (AGENTS.md, settings files, folders of helper
+ * data) but the agent won't pick them up via the skills mechanism.
+ *
+ * The check is intentionally a separate, callable predicate (rather
+ * than baked into `validateSkillBundleManifest`) so the storage and
+ * the attach layers can remain independent.
+ */
+export declare function hasSkillMdAtRoot(manifest: SkillBundleManifest): boolean;
 /**
  * The non-secret half of an MCP server declaration. This is what enters
  * the hashed submission, the run snapshot, and any audit log. `name`

package/dist/_shared/blueprint.js

@@ -105,6 +105,18 @@ export function isProviderSkillRef(ref) {
 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 isWorkspaceFileRef(ref) {
+    return ref.kind === "workspace_file";
+}
+export function isTransientFileRef(ref) {
+    return ref.kind === "transient_file";
+}
 /**
  * Parse a `SkillRef` from untrusted input. Used by the BFF run parser
  * and by the operations module when deserialising API responses. Throws
@@ -265,14 +277,20 @@ export function validateSkillBundleEntry(input) {
     return { path, size: input.size, mode };
 }
 /**
- * Validate a full manifest. Enforces:
+ * Validate a full **skill bundle** manifest. Enforces:
  *   - entries is a non-empty array
- *   - `SKILL.md` exists at the bundle root (Claude's auto-discovery key)
+ *   - `SKILL.md` exists at the bundle root (this is what makes a
+ *     bundle a skill rather than a plain workspace file)
  *   - file count <= maxFiles
  *   - total uncompressed size <= maxDecompressedBytes
  *   - per-entry validation (see `validateSkillBundleEntry`)
  *   - no duplicate paths
  *
+ * Per the May-2026 decision log in
+ * `references/agent-context-uploads.md`, **skill** means "Claude
+ * Skill" — bundles without `SKILL.md` are not skills and must go
+ * through the `AgentsMd` or `File` upload concepts instead.
+ *
  * Returns a canonical manifest with totals computed.
  */
 export function validateSkillBundleManifest(input) {
@@ -302,10 +320,27 @@ export function validateSkillBundleManifest(input) {
         entries.push(entry);
     }
     if (!hasSkillMd) {
-        throw new SkillBundleValidationError("bundle manifest must contain a 'SKILL.md' entry at the bundle root");
+        throw new SkillBundleValidationError("skill bundle manifest must contain a 'SKILL.md' entry at the bundle root. " +
+            "If you want to upload an instructions file or generic agent context, use " +
+            "AgentsMd or File instead — see references/agent-context-uploads.md");
     }
     return { entries, totalSize, fileCount: entries.length };
 }
+/**
+ * Returns true when the manifest carries a `SKILL.md` entry at the
+ * bundle root. The presence of this file is Anthropic's
+ * skill-auto-discovery signal — bundles that have it are treated as
+ * Claude skills and mounted accordingly; bundles that don't are still
+ * usable agent context (AGENTS.md, settings files, folders of helper
+ * data) but the agent won't pick them up via the skills mechanism.
+ *
+ * The check is intentionally a separate, callable predicate (rather
+ * than baked into `validateSkillBundleManifest`) so the storage and
+ * the attach layers can remain independent.
+ */
+export function hasSkillMdAtRoot(manifest) {
+    return manifest.entries.some((entry) => entry.path === "SKILL.md");
+}
 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)) {

package/dist/_shared/operations.d.ts

@@ -1,6 +1,6 @@
 import type { HttpClient } from "./http.js";
 import type { RunUnit } from "./run-unit.js";
-import type { Output, Run, RunEvent, SignedOutputLink, Skill, WhoAmI } from "./runtime-types.js";
+import type { AgentsMdRecord, FileRecord, Output, Run, RunEvent, SignedOutputLink, Skill, WhoAmI } from "./runtime-types.js";
 import type { PlatformFlatRunSubmissionInput, PlatformRunSubmissionInput } from "./submission.js";
 /**
  * The single source of truth for SDK<->BFF transport. The SDK class
@@ -52,22 +52,32 @@ export declare function downloadRunArchive(http: HttpClient, runId: string): Pro
 export declare function submitRunFlat(http: HttpClient, request: PlatformFlatRunSubmissionInput): Promise<Run>;
 /**
  * Multipart variant of `submitRunFlat` for runs that carry transient
- * (per-run) skill bundles. The JSON submission travels as the
- * `submission` part; each `TransientSkillRef.slot` in
- * `request.submission.skills` MUST be mirrored by exactly one
- * `skill:<slot>` part with the bundle bytes.
+ * (per-run) skill bundles and/or transient AgentsMd content.
  *
- * The BFF re-canonicalises and re-hashes each bundle; a `contentHash`
- * mismatch between the JSON ref and the recomputed hash of the bytes
- * is rejected with a deterministic error.
+ * The JSON submission travels as the `submission` part; each
+ * `TransientSkillRef.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`
+ * MUST be mirrored by exactly one `agentsmd:<slot>` part with the
+ * markdown text.
  *
- * Bytes never persist on antpath storage; the dashboard BFF uploads
- * them straight to Anthropic Files for the lifetime of the run.
+ * The BFF re-canonicalises and re-hashes each bundle/file; a
+ * `contentHash` mismatch is rejected with a deterministic error.
+ *
+ * At least one of `bundles` or `agentsMdParts` must be non-empty.
  */
 export declare function submitRunFlatMultipart(http: HttpClient, request: PlatformFlatRunSubmissionInput, bundles: ReadonlyArray<{
     readonly slot: string;
     readonly bytes: Uint8Array;
     readonly filename: string;
+}>, agentsMdParts?: ReadonlyArray<{
+    readonly slot: string;
+    readonly content: string;
+    readonly filename: string;
+}>, fileParts?: ReadonlyArray<{
+    readonly slot: string;
+    readonly bytes: Uint8Array;
+    readonly filename: string;
 }>): Promise<Run>;
 /**
  * Upload a workspace skill bundle as a zip blob. The dashboard BFF runs
@@ -106,3 +116,68 @@ export declare function findSkillByHash(http: HttpClient, args: {
  * indexed by-hash route is reserved for `uploadIfChanged`.
  */
 export declare function findSkillByName(http: HttpClient, name: string): Promise<Skill | null>;
+/**
+ * Upload a workspace AgentsMd file as a markdown string. The BFF
+ * canonicalises the content into a deterministic zip with AGENTS.md at
+ * root and runs the two-phase pending → ready upload.
+ */
+export declare function createAgentsMd(http: HttpClient, args: {
+    readonly name: string;
+    readonly content: string;
+}): Promise<AgentsMdRecord>;
+export declare function listAgentsMd(http: HttpClient): Promise<readonly AgentsMdRecord[]>;
+export declare function getAgentsMd(http: HttpClient, agentsMdId: string): Promise<AgentsMdRecord>;
+export declare function deleteAgentsMd(http: HttpClient, agentsMdId: string): Promise<void>;
+/**
+ * Upload a workspace File as a zip bundle. The BFF canonicalises the
+ * content and runs the two-phase pending → ready upload.
+ */
+export declare function createFile(http: HttpClient, args: {
+    readonly name: string;
+    readonly bytes: Uint8Array;
+}): Promise<FileRecord>;
+export declare function listFiles(http: HttpClient): Promise<readonly FileRecord[]>;
+export declare function getFile(http: HttpClient, fileId: string): Promise<FileRecord>;
+export declare function deleteFile(http: HttpClient, fileId: string): Promise<void>;
+/** Payload returned by the BFF's upload-init endpoint. */
+export interface AssetUploadInitResult {
+    readonly assetId: string;
+    readonly storagePath: string;
+    readonly tusUrl: string;
+    readonly tusToken: string;
+    readonly expiresAt: string;
+    readonly uploadHeaders: Readonly<Record<string, string>>;
+}
+/**
+ * Initialise a chunked asset upload session. Calls the BFF's
+ * `POST /api/assets/upload-init` endpoint, which:
+ *
+ *   1. Inserts a `state='pending'` row in the appropriate table.
+ *   2. Returns a TUS URL + short-lived token the SDK will use to drive
+ *      `tus-js-client` directly against Supabase Storage.
+ *
+ * The caller holds the `assetId` and `storagePath` for the subsequent
+ * finalize call.
+ */
+export declare function initAssetUpload(http: HttpClient, input: {
+    readonly kind: "skill" | "file";
+    readonly name: string;
+    readonly sizeBytes: number;
+    readonly hash: string;
+}): Promise<AssetUploadInitResult>;
+/**
+ * Finalise a chunked asset upload session. Calls the BFF's
+ * `POST /api/assets/finalize` endpoint, which:
+ *
+ *   1. Downloads the assembled bytes from Supabase Storage.
+ *   2. Verifies `sha256(bytes) === hash`.
+ *   3. Transitions the row `pending → ready`.
+ *
+ * Throws if the server returns a non-OK response (e.g. `hash_mismatch`).
+ */
+export declare function finalizeAssetUpload(http: HttpClient, input: {
+    readonly assetId: string;
+    readonly kind: "skill" | "file";
+    readonly hash: string;
+    readonly storagePath: string;
+}): Promise<void>;

package/dist/_shared/operations.js

@@ -83,21 +83,26 @@ export async function submitRunFlat(http, request) {
 }
 /**
  * Multipart variant of `submitRunFlat` for runs that carry transient
- * (per-run) skill bundles. The JSON submission travels as the
- * `submission` part; each `TransientSkillRef.slot` in
- * `request.submission.skills` MUST be mirrored by exactly one
- * `skill:<slot>` part with the bundle bytes.
+ * (per-run) skill bundles and/or transient AgentsMd content.
  *
- * The BFF re-canonicalises and re-hashes each bundle; a `contentHash`
- * mismatch between the JSON ref and the recomputed hash of the bytes
- * is rejected with a deterministic error.
+ * The JSON submission travels as the `submission` part; each
+ * `TransientSkillRef.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`
+ * MUST be mirrored by exactly one `agentsmd:<slot>` part with the
+ * markdown text.
  *
- * Bytes never persist on antpath storage; the dashboard BFF uploads
- * them straight to Anthropic Files for the lifetime of the run.
+ * The BFF re-canonicalises and re-hashes each bundle/file; a
+ * `contentHash` mismatch is rejected with a deterministic error.
+ *
+ * At least one of `bundles` or `agentsMdParts` must be non-empty.
  */
-export async function submitRunFlatMultipart(http, request, bundles) {
-    if (!Array.isArray(bundles) || bundles.length === 0) {
-        throw new Error("submitRunFlatMultipart: bundles must be a non-empty array");
+export 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();
     // Submission rides as a typed JSON Blob so the BFF reads
@@ -116,6 +121,30 @@ export 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
@@ -183,6 +212,80 @@ export async function findSkillByName(http, name) {
     const skills = await listSkills(http);
     return skills.find((skill) => skill.name === name) ?? null;
 }
+// ===========================================================================
+// AgentsMd (workspace_files kind='agentsmd') operations
+// ===========================================================================
+/**
+ * Upload a workspace AgentsMd file as a markdown string. The BFF
+ * canonicalises the content into a deterministic zip with AGENTS.md at
+ * root and runs the two-phase pending → ready upload.
+ */
+export 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);
+}
+export async function listAgentsMd(http) {
+    const result = await http.request("/api/agentsmd");
+    if (Array.isArray(result)) {
+        return result;
+    }
+    return result.agentsMd;
+}
+export async function getAgentsMd(http, agentsMdId) {
+    const result = await http.request(`/api/agentsmd/${encodeURIComponent(agentsMdId)}`);
+    return unwrapAgentsMd(result);
+}
+export 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;
+}
+// ===========================================================================
+// File (workspace_files kind='file') operations
+// ===========================================================================
+/**
+ * Upload a workspace File as a zip bundle. The BFF canonicalises the
+ * content and runs the two-phase pending → ready upload.
+ */
+export 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);
+}
+export async function listFiles(http) {
+    const result = await http.request("/api/files");
+    if (Array.isArray(result)) {
+        return result;
+    }
+    return result.files;
+}
+export async function getFile(http, fileId) {
+    const result = await http.request(`/api/files/${encodeURIComponent(fileId)}`);
+    return unwrapFile(result);
+}
+export 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;
@@ -206,4 +309,37 @@ function toBlob(input, contentType) {
 function hasRun(value) {
     return Boolean(value && typeof value === "object" && "run" in value);
 }
+/**
+ * Initialise a chunked asset upload session. Calls the BFF's
+ * `POST /api/assets/upload-init` endpoint, which:
+ *
+ *   1. Inserts a `state='pending'` row in the appropriate table.
+ *   2. Returns a TUS URL + short-lived token the SDK will use to drive
+ *      `tus-js-client` directly against Supabase Storage.
+ *
+ * The caller holds the `assetId` and `storagePath` for the subsequent
+ * finalize call.
+ */
+export async function initAssetUpload(http, input) {
+    return http.request("/api/assets/upload-init", {
+        method: "POST",
+        body: JSON.stringify(input)
+    });
+}
+/**
+ * Finalise a chunked asset upload session. Calls the BFF's
+ * `POST /api/assets/finalize` endpoint, which:
+ *
+ *   1. Downloads the assembled bytes from Supabase Storage.
+ *   2. Verifies `sha256(bytes) === hash`.
+ *   3. Transitions the row `pending → ready`.
+ *
+ * Throws if the server returns a non-OK response (e.g. `hash_mismatch`).
+ */
+export async function finalizeAssetUpload(http, input) {
+    await http.request("/api/assets/finalize", {
+        method: "POST",
+        body: JSON.stringify(input)
+    });
+}
 //# sourceMappingURL=operations.js.map

package/dist/_shared/run-unit.js

@@ -57,6 +57,8 @@ function parseFlatProjection(value) {
         ...(typeof submissionRaw.system === "string" ? { system: submissionRaw.system } : {}),
         prompt: toStringArray(submissionRaw.prompt),
         skills: toSkillRefArray(submissionRaw.skills),
+        agentsMd: [],
+        files: [],
         mcpServers: toMcpServerRefArray(submissionRaw.mcpServers),
         ...(parseEnvironment(submissionRaw.environment)
             ? { environment: parseEnvironment(submissionRaw.environment) }
@@ -101,6 +103,8 @@ function fallbackFlat() {
             model: "",
             prompt: [],
             skills: [],
+            agentsMd: [],
+            files: [],
             mcpServers: []
         }
     };

package/dist/_shared/runtime-types.d.ts

@@ -122,6 +122,53 @@ export interface Skill {
     readonly deletedAt?: string | null;
     readonly [key: string]: unknown;
 }
+/**
+ * Wire-level record for a workspace AgentsMd file as returned by the BFF.
+ * Mirrors `PublicWorkspaceFile` from the dashboard service layer.
+ */
+export interface AgentsMdRecord {
+    readonly id: string;
+    readonly kind?: "agentsmd";
+    readonly name: string;
+    readonly state: "pending" | "ready";
+    readonly hash?: string | null;
+    readonly sizeBytes?: number | null;
+    readonly fileCount?: number | null;
+    readonly manifest?: ReadonlyArray<{
+        readonly path: string;
+        readonly size: number;
+        readonly mode: number;
+    }>;
+    readonly createdAt?: string;
+    readonly updatedAt?: string;
+    readonly finalizedAt?: string | null;
+    readonly deletedAt?: string | null;
+    readonly [key: string]: unknown;
+}
+/**
+ * Wire-level record for a workspace File as returned by the BFF.
+ * Mirrors `PublicWorkspaceFile` from the dashboard service layer
+ * with kind='file' and `f_*` ids.
+ */
+export interface FileRecord {
+    readonly id: string;
+    readonly kind?: "file";
+    readonly name: string;
+    readonly state: "pending" | "ready";
+    readonly hash?: string | null;
+    readonly sizeBytes?: number | null;
+    readonly fileCount?: number | null;
+    readonly manifest?: ReadonlyArray<{
+        readonly path: string;
+        readonly size: number;
+        readonly mode: number;
+    }>;
+    readonly createdAt?: string;
+    readonly updatedAt?: string;
+    readonly finalizedAt?: string | null;
+    readonly deletedAt?: string | null;
+    readonly [key: string]: unknown;
+}
 /**
  * Full submission as the SDK and CLI assemble it before posting. The
  * `template` is the SDK-level ResolvedTemplate (or a JSON-encoded one);

package/dist/_shared/submission.d.ts

@@ -1,5 +1,5 @@
 import { type ProxyAuthShape, type ProxyMethod, type ProxyResponseMode } from "./proxy-protocol.js";
-import type { McpServerRef, SkillRef } from "./blueprint.js";
+import type { AgentsMdRef, FileRef, McpServerRef, SkillRef } from "./blueprint.js";
 export type JsonPrimitive = string | number | boolean | null;
 export type JsonValue = JsonPrimitive | JsonValue[] | {
     readonly [key: string]: JsonValue;
@@ -172,6 +172,8 @@ export interface PlatformFlatSubmission {
     readonly system?: string;
     readonly prompt: readonly string[];
     readonly skills: readonly SkillRef[];
+    readonly agentsMd: readonly AgentsMdRef[];
+    readonly files: readonly FileRef[];
     readonly mcpServers: readonly McpServerRef[];
     readonly environment?: PlatformTemplateEnvironment;
     readonly metadata?: Record<string, JsonValue>;