@aexhq/sdk 0.13.6

package/dist/_contracts/operations.js

@@ -0,0 +1,632 @@
+import { strToU8, zipSync } from "fflate";
+import { RunStateError } from "./sdk-errors.js";
+import { assertRunRecordArchivePublicSafeV1, buildRunRecordDownloadManifestV1 } from "./run-record.js";
+import { runArtifactRel } from "./run-artifacts.js";
+/**
+ * The single source of truth for SDK<->BFF transport. The SDK class
+ * AND the CLI subcommands both call these functions; neither
+ * surface re-implements HTTP requests against the dashboard.
+ *
+ * Every function takes an HttpClient (so callers control auth + fetch
+ * injection) and returns parsed responses.
+ *
+ * Workspace identity is derived server-side from the API token on
+ * every request; callers do not pass `workspaceId`.
+ */
+export async function getRun(http, runId) {
+    const result = await http.request(`/api/runs/${encodeURIComponent(runId)}`);
+    return hasRun(result) ? result.run : result;
+}
+/**
+ * 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, inline skills.
+ *
+ * Backed by the same `GET /api/runs/:runId` endpoint that
+ * `getRun` calls; this variant just narrows the return type to
+ * the documented wire shape. Prefer this for new code; `getRun`
+ * stays for callers that only need the loose record.
+ */
+export async function getRunUnit(http, runId) {
+    return http.request(`/api/runs/${encodeURIComponent(runId)}`);
+}
+export async function listRunEvents(http, runId, options = {}) {
+    const query = options.channel && options.channel !== "event"
+        ? { channel: options.channel }
+        : {};
+    const result = await http.request(`/api/runs/${encodeURIComponent(runId)}/events`, {}, query);
+    return result.events;
+}
+/**
+ * Mint a short-lived coordinator WS ticket via the workspace-token-gated
+ * broker (`/api/runs/:id/events/ticket`). The returned `wsUrl` + `ticket`
+ * open the live event stream directly against the coordinator. Throws if no
+ * coordinator is configured for the deployment (HTTP 503).
+ */
+export async function getCoordinatorTicket(http, runId) {
+    return http.request(`/api/runs/${encodeURIComponent(runId)}/events/ticket`, { method: "POST" });
+}
+export async function listOutputs(http, runId) {
+    const result = await http.request(`/api/runs/${encodeURIComponent(runId)}/outputs`);
+    return result.outputs;
+}
+/**
+ * List the run's platform diagnostics (the `logs` namespace). Legacy stored
+ * filenames are normalized to canonical public namespaces.
+ */
+export async function listLogs(http, runId) {
+    const result = await http.request(`/api/runs/${encodeURIComponent(runId)}/logs`);
+    return result.logs.map((log) => typeof log.filename === "string" ? { ...log, filename: runArtifactRel(log.filename) } : log);
+}
+export async function createOutputLink(http, runId, outputId) {
+    return http.request(`/api/runs/${encodeURIComponent(runId)}/outputs/${encodeURIComponent(outputId)}/link`, { method: "POST" });
+}
+export function resolveOutputFileSelector(outputs, selector, runId) {
+    if (isPathSelector(selector)) {
+        const target = normalizeOutputLookupPath(selector.path);
+        if (!target) {
+            throw new RunStateError("downloadOutput: output path must be non-empty", { runId, path: selector.path });
+        }
+        const matches = outputs.filter((output) => {
+            if (typeof output.filename !== "string")
+                return false;
+            const filename = normalizeOutputLookupPath(output.filename);
+            if (selector.match === "suffix") {
+                return filename === target || filename.endsWith(`/${target}`);
+            }
+            return filename === target;
+        });
+        if (matches.length === 1)
+            return matches[0];
+        if (matches.length > 1) {
+            throw new RunStateError(`downloadOutput: output path "${selector.path}" matched multiple files`, { runId, path: selector.path, matches: matches.map((output) => output.filename ?? output.id) });
+        }
+        throw new RunStateError(`downloadOutput: output path "${selector.path}" was not found`, {
+            runId,
+            path: selector.path
+        });
+    }
+    if (typeof selector?.id !== "string" || selector.id.length === 0) {
+        throw new RunStateError("downloadOutput: selector must include an output id or path", { runId });
+    }
+    return { ...selector, id: selector.id };
+}
+export async function downloadOutput(http, runId, selector) {
+    const output = isPathSelector(selector)
+        ? resolveOutputFileSelector(await listOutputs(http, runId), selector, runId)
+        : resolveOutputFileSelector([], selector, runId);
+    const { response } = await http.download(`/api/runs/${encodeURIComponent(runId)}/outputs/${encodeURIComponent(output.id)}/download`);
+    return { output, bytes: new Uint8Array(await response.arrayBuffer()) };
+}
+export async function cancelRun(http, runId) {
+    await http.request(`/api/runs/${encodeURIComponent(runId)}/cancel`, { method: "POST" });
+}
+export async function deleteRun(http, runId) {
+    await http.request(`/api/runs/${encodeURIComponent(runId)}`, { method: "DELETE" });
+}
+/**
+ * Delete a workspace asset cache entry. Accepts an `asset_<id>` value,
+ * `sha256:<hex>`, or a bare 64-hex digest. Workspace is derived server-side
+ * from the token; idempotent.
+ * Does NOT affect runs that already snapshotted the asset.
+ */
+export async function deleteWorkspaceAsset(http, hash) {
+    const assetId = hash.startsWith("asset_")
+        ? hash
+        : `asset_${hash.startsWith("sha256:") ? hash.slice("sha256:".length) : hash}`;
+    await http.request(`/assets/${encodeURIComponent(assetId)}`, { method: "DELETE" });
+}
+export async function whoami(http) {
+    return http.request("/api/whoami");
+}
+/**
+ * Download each artifact's bytes into a zip-file map keyed by
+ * `<zipPrefix><relative-path>`, fetched from the `outputs` or `logs`
+ * download route. Best-effort: a per-artifact fetch failure records an
+ * `errors[]` entry rather than aborting the rest, so the failure is
+ * surfaced (never silent) while a partially-available run still yields a
+ * usable zip.
+ */
+async function collectArtifactBytes(http, runId, items, zipPrefix, namespace) {
+    const entries = [];
+    const captured = [];
+    const errors = [];
+    for (const item of items) {
+        const rel = item.filename ?? item.id;
+        try {
+            const { response } = await http.download(`/api/runs/${encodeURIComponent(runId)}/${namespace}/${encodeURIComponent(item.id)}/download`);
+            entries.push({
+                path: `${zipPrefix}${rel}`,
+                bytes: new Uint8Array(await response.arrayBuffer()),
+                ...(item.contentType !== undefined ? { contentType: item.contentType } : {}),
+                ...(namespace === "outputs" ? { customerContent: true } : {})
+            });
+            captured.push({
+                id: item.id,
+                filename: item.filename ?? null,
+                ...(item.sizeBytes !== undefined ? { sizeBytes: item.sizeBytes } : {}),
+                ...(item.contentType !== undefined ? { contentType: item.contentType } : {})
+            });
+        }
+        catch (err) {
+            errors.push({ namespace, id: item.id, filename: item.filename ?? null, message: err.message });
+        }
+    }
+    return { entries: Object.freeze(entries), captured, errors };
+}
+function eventsJsonl(events) {
+    return strToU8(events.map((event) => JSON.stringify(event)).join("\n"));
+}
+async function tryListOptionalRunEvents(http, runId, channel) {
+    try {
+        const events = await listRunEvents(http, runId, { channel });
+        if (channel === "log") {
+            return events.length > 0 && events.every(isLogChannelEvent)
+                ? { status: "present", events }
+                : { status: "unavailable", events: [] };
+        }
+        return hasUnifiedStreamEvidence(events)
+            ? { status: "present", events }
+            : { status: "unavailable", events: [] };
+    }
+    catch {
+        return { status: "unavailable", events: [] };
+    }
+}
+function isLogChannelEvent(event) {
+    return event.channel === "log";
+}
+function hasUnifiedStreamEvidence(events) {
+    return events.some((event) => event.channel === "log" || event.channel === "event");
+}
+function isPathSelector(selector) {
+    return Boolean(selector && typeof selector === "object" && "path" in selector);
+}
+function normalizeOutputLookupPath(path) {
+    return path.replace(/\\/g, "/").replace(/^\/+/, "");
+}
+/**
+ * Download EVERYTHING about a run as one zip, organised into the four
+ * namespace folders:
+ *
+ *   metadata/run.json     — the run record.
+ *   events/events.jsonl   — typed event-channel records.
+ *   events/logs.jsonl     — log-channel records, when the API serves them.
+ *   events/all.jsonl      — full unified stream, when the API serves it.
+ *   outputs/<rel>         — the run's deliverables.
+ *   logs/<rel>            — platform diagnostics.
+ *   manifest.json         — `RunRecordManifestV1`.
+ */
+export async function download(http, runId) {
+    const [run, events, logEvents, allEvents, outputs, logItems] = await Promise.all([
+        getRun(http, runId),
+        listRunEvents(http, runId),
+        tryListOptionalRunEvents(http, runId, "log"),
+        tryListOptionalRunEvents(http, runId, "all"),
+        listOutputs(http, runId),
+        listLogs(http, runId)
+    ]);
+    const out = await collectArtifactBytes(http, runId, outputs, "outputs/", "outputs");
+    const logs = await collectArtifactBytes(http, runId, logItems, "logs/", "logs");
+    const submissionSnapshot = extractSubmissionSnapshot(run);
+    const costTelemetry = extractCostTelemetry(run);
+    const manifest = buildRunRecordDownloadManifestV1({
+        runId,
+        outputs: out.captured,
+        logs: logs.captured,
+        errors: [...out.errors, ...logs.errors],
+        typedEventCount: events.length,
+        ...(submissionSnapshot ? { submission: { status: "present" } } : {}),
+        ...(costTelemetry ? { cost: { status: "present" } } : {}),
+        logEvents: { status: logEvents.status, recordCount: logEvents.events.length },
+        allEvents: { status: allEvents.status, recordCount: allEvents.events.length }
+    });
+    return zipEntries([
+        jsonEntry("metadata/run.json", run),
+        ...(submissionSnapshot ? [jsonEntry("metadata/submission.json", submissionSnapshot)] : []),
+        ...(costTelemetry ? [jsonEntry("metadata/cost.json", costTelemetry)] : []),
+        jsonlEntry("events/events.jsonl", events),
+        ...(logEvents.status === "present" ? [jsonlEntry("events/logs.jsonl", logEvents.events)] : []),
+        ...(allEvents.status === "present" ? [jsonlEntry("events/all.jsonl", allEvents.events)] : []),
+        ...out.entries,
+        ...logs.entries,
+        jsonEntry("manifest.json", manifest)
+    ]);
+}
+/**
+ * Download only the run's deliverables (the `outputs` namespace). Zip
+ * layout: `<rel>` per file plus a `manifest.json`
+ * (`{ runId, namespace: "outputs", outputs[], errors[] }`).
+ */
+export async function downloadOutputs(http, runId) {
+    const outputs = await listOutputs(http, runId);
+    const { entries, captured, errors } = await collectArtifactBytes(http, runId, outputs, "", "outputs");
+    return zipEntries([
+        ...entries,
+        jsonEntry("manifest.json", { runId, namespace: "outputs", outputs: captured, errors })
+    ]);
+}
+/**
+ * Download only the platform diagnostics (the `logs` namespace). Zip
+ * layout: `<rel>` per file plus a `manifest.json`
+ * (`{ runId, namespace: "logs", logs[], errors[] }`).
+ */
+export async function downloadLogs(http, runId) {
+    const logItems = await listLogs(http, runId);
+    const { entries, captured, errors } = await collectArtifactBytes(http, runId, logItems, "", "logs");
+    return zipEntries([
+        ...entries,
+        jsonEntry("manifest.json", { runId, namespace: "logs", logs: captured, errors })
+    ]);
+}
+/**
+ * Download only the event archive (the `events` namespace). Always includes
+ * typed `events.jsonl`; includes `logs.jsonl` / `all.jsonl` when the deployed
+ * event API proves those channel exports are available.
+ */
+export async function downloadEvents(http, runId) {
+    const [events, logEvents, allEvents] = await Promise.all([
+        listRunEvents(http, runId),
+        tryListOptionalRunEvents(http, runId, "log"),
+        tryListOptionalRunEvents(http, runId, "all")
+    ]);
+    return zipEntries([
+        jsonlEntry("events.jsonl", events),
+        ...(logEvents.status === "present" ? [jsonlEntry("logs.jsonl", logEvents.events)] : []),
+        ...(allEvents.status === "present" ? [jsonlEntry("all.jsonl", allEvents.events)] : [])
+    ]);
+}
+/**
+ * Download only the run record (the `metadata` namespace) as a zip
+ * containing `run.json`.
+ */
+export async function downloadMetadata(http, runId) {
+    const run = await getRun(http, runId);
+    return zipEntries([jsonEntry("run.json", run)]);
+}
+function zipEntries(entries) {
+    assertRunRecordArchivePublicSafeV1(entries);
+    const files = {};
+    for (const entry of entries) {
+        files[entry.path] = entry.bytes;
+    }
+    return zipSync(files);
+}
+function jsonEntry(path, value) {
+    return {
+        path,
+        bytes: strToU8(JSON.stringify(value, null, 2)),
+        contentType: "application/json; charset=utf-8"
+    };
+}
+function jsonlEntry(path, events) {
+    return {
+        path,
+        bytes: eventsJsonl(events),
+        contentType: "application/jsonl; charset=utf-8"
+    };
+}
+function extractSubmissionSnapshot(run) {
+    const raw = run.submission;
+    if (!isRecord(raw) || raw.kind !== "submission" || !isRecord(raw.submission)) {
+        return undefined;
+    }
+    return {
+        submission: raw.submission
+    };
+}
+function extractCostTelemetry(run) {
+    const raw = run.costTelemetry;
+    return isRecord(raw) ? raw : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// ===========================================================================
+// Run submission operations (Skill / McpServer / run config composition)
+// ===========================================================================
+export async function submitRun(http, request) {
+    return http.request("/api/runs", {
+        method: "POST",
+        body: JSON.stringify(request)
+    });
+}
+/**
+ * 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
+ * `InlineSkillRef.slot` in `request.submission.skills` MUST be
+ * mirrored by exactly one `skill:<slot>` part with the bundle bytes.
+ * Each `InlineAgentsMdRef.slot` in `request.submission.agentsMd`
+ * MUST be mirrored by exactly one `agentsmd:<slot>` part with the
+ * markdown text.
+ *
+ * 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 submitRunMultipart(http, request, bundles, agentsMdParts, fileParts) {
+    const hasBundles = Array.isArray(bundles) && bundles.length > 0;
+    const hasAgentsMd = Array.isArray(agentsMdParts) && agentsMdParts.length > 0;
+    const hasFiles = Array.isArray(fileParts) && fileParts.length > 0;
+    if (!hasBundles && !hasAgentsMd && !hasFiles) {
+        throw new Error("submitRunMultipart: bundles, agentsMdParts, or fileParts must be non-empty");
+    }
+    const form = new FormData();
+    // Submission rides as a typed JSON Blob so the BFF reads
+    // `multipart["submission"]` with the right content-type and never
+    // has to re-detect the body shape.
+    form.append("submission", new Blob([JSON.stringify(request)], { type: "application/json" }), "submission.json");
+    const seen = new Set();
+    for (const bundle of bundles) {
+        if (typeof bundle.slot !== "string" || !bundle.slot) {
+            throw new Error("submitRunMultipart: each bundle must have a non-empty slot id");
+        }
+        if (seen.has(bundle.slot)) {
+            throw new Error(`submitRunMultipart: duplicate inline skill slot "${bundle.slot}"`);
+        }
+        seen.add(bundle.slot);
+        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("submitRunMultipart: each agentsMd part must have a non-empty slot id");
+        }
+        const partKey = `agentsmd:${part.slot}`;
+        if (seen.has(partKey)) {
+            throw new Error(`submitRunMultipart: 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("submitRunMultipart: each file part must have a non-empty slot id");
+        }
+        const partKey = `file:${part.slot}`;
+        if (seen.has(partKey)) {
+            throw new Error(`submitRunMultipart: 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
+    });
+}
+/**
+ * Upload a workspace skill bundle as a zip blob. The hosted API runs
+ * the two-phase flow internally (insert pending row, stream bytes into
+ * object storage, validate manifest, transition to ready) and returns
+ * the finalized `Skill`. Use `Skill.fromPath` / `Skill.upload` in the
+ * SDK to build the body; this transport function only knows about
+ * bytes.
+ */
+export async function createSkillBundle(http, args) {
+    const form = new FormData();
+    form.append("name", args.name);
+    const blobBody = toBlob(args.body, args.contentType ?? "application/zip");
+    form.append("bundle", blobBody, args.filename ?? `${args.name}.zip`);
+    const result = await http.request("/api/skills", {
+        method: "POST",
+        body: form
+    });
+    return unwrapSkill(result);
+}
+/**
+ * Upload a workspace skill bundle DIRECTLY to object storage via the presign
+ * flow, so the bytes never transit the hosted API (bundle size bounded by the
+ * object store, not API memory). Falls back to the buffered multipart
+ * `createSkillBundle` when the hosted API has no object-store upload
+ * credentials (503 `presign_unconfigured`).
+ *
+ *   1. POST /api/skills/presign     { name, hash, sizeBytes } → { uploadUrl, requiredHeaders, skillId }
+ *   2. PUT bytes → uploadUrl        (signed checksum; the store rejects a mismatch)
+ *   3. POST /api/skills/:id/finalize { manifest } → finalized Skill
+ *
+ * `manifest` is the client-computed bundle manifest (the caller already
+ * validated the zip shape before hashing); the Worker records it on finalize
+ * without re-buffering the object.
+ */
+export async function createSkillBundleDirect(http, fetchImpl, args) {
+    let presign;
+    try {
+        presign = await http.request("/api/skills/presign", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ name: args.name, hash: args.contentHash, sizeBytes: args.body.byteLength })
+        });
+    }
+    catch (err) {
+        const status = err.status;
+        const code = (err.details ?? {}).code;
+        if (status === 503 && code === "presign_unconfigured") {
+            return createSkillBundle(http, {
+                name: args.name,
+                body: args.body,
+                ...(args.contentType ? { contentType: args.contentType } : {})
+            });
+        }
+        throw err;
+    }
+    const putRes = await fetchImpl(presign.uploadUrl, {
+        method: "PUT",
+        headers: { "content-type": args.contentType ?? "application/zip", ...(presign.requiredHeaders ?? {}) },
+        body: args.body
+    });
+    if (!putRes.ok) {
+        const detail = await putRes.text().catch(() => "");
+        throw new Error(`createSkillBundleDirect: direct upload PUT failed (status ${putRes.status})${detail ? `: ${detail.slice(0, 500)}` : ""}`);
+    }
+    const result = await http.request(`/api/skills/${encodeURIComponent(presign.skillId)}/finalize`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ manifest: args.manifest })
+    });
+    return unwrapSkill(result);
+}
+export async function listSkills(http) {
+    const result = await http.request("/api/skills");
+    if (Array.isArray(result)) {
+        return result;
+    }
+    return result.skills;
+}
+export async function getSkill(http, skillId) {
+    const result = await http.request(`/api/skills/${encodeURIComponent(skillId)}`);
+    return unwrapSkill(result);
+}
+export async function deleteSkill(http, skillId) {
+    await http.request(`/api/skills/${encodeURIComponent(skillId)}`, {
+        method: "DELETE"
+    });
+}
+/**
+ * Lookup a live workspace skill by `(name, contentHash)`. Returns the
+ * matching `Skill` record or null when no live row carries that hash.
+ *
+ * `contentHash` is the wire format `sha256:<hex>` as returned by
+ * `hashSkillBundle`. This powers `Skill.uploadIfChanged` — the SDK
+ * computes the hash locally and calls this function to skip the upload
+ * when the bytes already exist.
+ */
+export async function findSkillByHash(http, args) {
+    const params = new URLSearchParams({
+        name: args.name,
+        content_hash: args.contentHash
+    });
+    const result = await http.request(`/api/skills/by-hash?${params.toString()}`);
+    return result.skill ?? null;
+}
+/**
+ * Lookup a live workspace skill by `name`. Returns the matching `Skill`
+ * record or null when no live row carries that name. Implemented as a
+ * list-and-filter on the existing `/api/skills` endpoint — the
+ * indexed by-hash route is reserved for `uploadIfChanged`.
+ */
+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;
+    }
+    return result;
+}
+function toBlob(input, contentType) {
+    if (input instanceof Blob) {
+        return input;
+    }
+    if (input instanceof Uint8Array) {
+        // BlobPart accepts ArrayBufferView, but lib.dom's overload set
+        // narrows on the underlying buffer kind. Slice into a fresh
+        // ArrayBuffer so a SharedArrayBuffer-backed Uint8Array works.
+        const copy = new Uint8Array(input.byteLength);
+        copy.set(input);
+        return new Blob([copy.buffer], { type: contentType });
+    }
+    return new Blob([input], { type: contentType });
+}
+function hasRun(value) {
+    return Boolean(value && typeof value === "object" && "run" in value);
+}
+/**
+ * Upload bytes to the hosted API's content-addressable asset endpoint.
+ * Returns a storage-neutral asset id suitable for `kind:"asset"` refs in a
+ * later run submission.
+ */
+export async function uploadWorkspaceAsset(http, input) {
+    return http.request("/assets", {
+        method: "POST",
+        headers: {
+            "content-type": input.contentType ?? "application/octet-stream",
+            "content-length": String(input.bytes.byteLength),
+            ...(input.contentHash ? { "x-asset-hash": input.contentHash } : {})
+        },
+        body: input.bytes
+    });
+}
+//# sourceMappingURL=operations.js.map