@aexhq/sdk 0.46.4-canary → 0.50.0

package/dist/_contracts/submission.js

@@ -1,812 +0,0 @@
-import { SKILL_NAME_PATTERN, SKILL_RESERVED_NAMES, TOOL_NAME_PATTERN, assertValidMountPath, normaliseSkillBundlePath, parseMcpServerRef } from "./session-config.js";
-import { parseSessionTimeout } from "./runtime-sizes.js";
-import { assertPinnedWorkspaceResource, assertWorkspaceFileResourceName, assertWorkspaceInstructionResourceName } from "./workspace-resources.js";
-import { withContractParseError } from "./contract-parse-error.js";
-import { parseWire } from "./schemas/wire.js";
-import { SessionSubmissionRequestSchema } from "./schemas/submission-request.js";
-import { ApprovalGateSchema, ResponseFormatSchema, SubmissionSchema } from "./schemas/submission-body.js";
-import { SessionWebhookSchema } from "./schemas/session-webhook.js";
-import { SessionLimitsSchema, normalizeSessionLimits } from "./schemas/session-limits.js";
-import { SessionMachineSchema, normalizeSessionMachine } from "./schemas/session-machine.js";
-import { normalizeAllowedHosts, normalizePlatformPackage } from "./schemas/submission-environment.js";
-import { InlineSecretsSchema, normalizeEnvSecrets } from "./schemas/submission-secrets.js";
-import { isRecord, isStringLiteral } from "./value-guards.js";
-// Bounds, patterns and the ecosystem list live in a leaf module so the schemas
-// can read them without importing this file back. Re-exported here so the
-// published surface is unchanged.
-export { AEX_RESERVED_ENV_PREFIX, ENV_VARS_MAX_ENTRIES, ENV_VARS_MAX_VALUE_BYTES, ENV_VARS_MAX_TOTAL_BYTES, PLATFORM_PACKAGE_ECOSYSTEMS } from "./submission-limits.js";
-// Also imported locally: a re-export does not bind the names in this module.
-import { PLATFORM_PACKAGE_ECOSYSTEMS } from "./submission-limits.js";
-const APT_PACKAGE_NAME_PATTERN = /^[a-z0-9][a-z0-9+.-]+(?::[a-z0-9][a-z0-9-]*)?$/;
-const APT_EXACT_VERSION_PATTERN = /^[0-9][0-9A-Za-z.+:~-]*$/;
-const NPM_PACKAGE_NAME_PATTERN = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/;
-const NPM_EXACT_VERSION_PATTERN = /^(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
-const PIP_PACKAGE_NAME_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/;
-const PIP_EXACT_VERSION_PATTERN = /^[0-9](?:[0-9A-Za-z.!+_-]*[0-9A-Za-z])?$/;
-function assertPlatformPackage(pkg, path) {
-    const invalidName = () => new Error(`${path}.name must be a valid ${pkg.ecosystem} registry package name`);
-    const invalidVersion = () => new Error(`${path}.version must be an exact ${pkg.ecosystem} version`);
-    switch (pkg.ecosystem) {
-        case "apt":
-            if (!APT_PACKAGE_NAME_PATTERN.test(pkg.name))
-                throw invalidName();
-            if (pkg.version !== undefined && !APT_EXACT_VERSION_PATTERN.test(pkg.version))
-                throw invalidVersion();
-            return;
-        case "npm":
-            if (!NPM_PACKAGE_NAME_PATTERN.test(pkg.name))
-                throw invalidName();
-            if (pkg.version !== undefined && !NPM_EXACT_VERSION_PATTERN.test(pkg.version))
-                throw invalidVersion();
-            return;
-        case "pip":
-            if (!PIP_PACKAGE_NAME_PATTERN.test(pkg.name))
-                throw invalidName();
-            if (pkg.version !== undefined && !PIP_EXACT_VERSION_PATTERN.test(pkg.version))
-                throw invalidVersion();
-            return;
-        default:
-            throw new Error(`${path}.ecosystem must be one of: ${PLATFORM_PACKAGE_ECOSYSTEMS.join(", ")}`);
-    }
-}
-/**
- * Render a parsed {@link PlatformPackage} as the version-embedded install
- * string used by runtime materialization. The join differs per manager:
- *   - pip  → `name==version`
- *   - npm  → `name@version`
- *   - apt  → `name=version`
- * With no `version`, just the bare `name`. Pure; used by the managed runner
- * package installer.
- */
-export function packageInstallString(pkg) {
-    assertPlatformPackage(pkg, "package");
-    if (pkg.version === undefined) {
-        return pkg.name;
-    }
-    switch (pkg.ecosystem) {
-        case "pip":
-            return `${pkg.name}==${pkg.version}`;
-        case "npm":
-            return `${pkg.name}@${pkg.version}`;
-        case "apt":
-            return `${pkg.name}=${pkg.version}`;
-    }
-}
-export const SECRETS_KEY = "secrets";
-/**
- * The `secretEnv` grammars, declared in the leaf bounds module so
- * `schemas/submission-body.ts` can enforce them without importing this file
- * back, and re-exported here so the published surface is unchanged.
- */
-export { SECRET_ENV_NAME_PATTERN, SECRET_HANDLE_PATTERN } from "./submission-limits.js";
-export const deniedSecretFields = new Set([
-    "providerApiKey",
-    "anthropicApiKey",
-    "apiKey",
-    "apiKeys",
-    "accessToken",
-    "refreshToken",
-    "password",
-    "mcpCredentials",
-    "credentials"
-]);
-/**
- * Resolve a validated `submission.environment` into the runtime snapshot.
- *
- * The schema owns shape, the allow-list and the bounds; the normalisers own the
- * transforms (ecosystem-prefix splitting, host case folding) and the
- * collapse-to-`undefined` rules. Keeping those apart is what lets the same
- * schema generate the OpenAPI document — see D4/L1.
- */
-function normalizeEnvironment(parsed) {
-    if (parsed === undefined) {
-        return undefined;
-    }
-    const networking = normalizeNetworking(parsed.networking);
-    const packages = normalizePackages(parsed.packages);
-    const envVars = normalizeEnvVars(parsed.envVars);
-    if (!networking && !packages && !envVars) {
-        return undefined;
-    }
-    return {
-        ...(networking ? { networking } : {}),
-        ...(packages ? { packages } : {}),
-        ...(envVars ? { envVars } : {})
-    };
-}
-/** An empty map is treated as not supplied, so it never lands on the snapshot. */
-function normalizeEnvVars(envVars) {
-    if (envVars === undefined || Object.keys(envVars).length === 0) {
-        return undefined;
-    }
-    return Object.freeze({ ...envVars });
-}
-function normalizeNetworking(networking) {
-    if (networking?.mode === undefined) {
-        return undefined;
-    }
-    const allowedHosts = networking.allowedHosts;
-    return allowedHosts
-        ? { mode: networking.mode, allowedHosts: normalizeAllowedHosts(allowedHosts) }
-        : { mode: networking.mode };
-}
-function normalizePackages(packages) {
-    if (packages === undefined) {
-        return undefined;
-    }
-    return packages.map((entry, index) => {
-        const path = `submission.environment.packages[${index}]`;
-        const normalized = normalizePlatformPackage(entry, path);
-        assertPlatformPackage(normalized, path);
-        return normalized;
-    });
-}
-/**
- * Cross-check `submission.secretEnv` declarations against `secrets.envSecrets`
- * values:
- *
- *  - `{ ephemeral: true }` MUST have a matching `secrets.envSecrets` value.
- *  - `{ ref }` MUST NOT supply a value (the value lives in the workspace store).
- *  - every `secrets.envSecrets` value MUST have a matching `{ ephemeral: true }`
- *    declaration (no orphan values that would never be injected).
- */
-export function crossValidateSecretEnvAndValues(secretEnv, envSecrets) {
-    const declarations = secretEnv ?? {};
-    const values = envSecrets ?? {};
-    for (const [envName, entry] of Object.entries(declarations)) {
-        const hasValue = Object.prototype.hasOwnProperty.call(values, envName);
-        if ("ref" in entry) {
-            if (hasValue) {
-                throw new Error(`submission.secretEnv[${envName}] is a workspace ref and must not supply a value in secrets.envSecrets[${envName}]; the value resolves server-side`);
-            }
-            continue;
-        }
-        if (!hasValue) {
-            throw new Error(`submission.secretEnv[${envName}] is ephemeral but has no matching secrets.envSecrets[${envName}] value`);
-        }
-    }
-    for (const envName of Object.keys(values)) {
-        const entry = declarations[envName];
-        if (!entry || !("ephemeral" in entry)) {
-            throw new Error(`secrets.envSecrets[${envName}] has no matching submission.secretEnv[${envName}] ephemeral declaration`);
-        }
-    }
-}
-export function parseInlineSecrets(input) {
-    return withContractParseError("parseInlineSecrets", () => {
-        // Absent/null secrets collapse to an empty bundle. Under managed gateway keys
-        // a run needs no provider key, so an empty bundle is always admissible.
-        if (input === undefined || input === null)
-            return {};
-        return normalizeInlineSecrets(parseWire(InlineSecretsSchema, input));
-    });
-}
-/**
- * Collapse a validated secrets bundle onto {@link PlatformInlineSecrets}.
- *
- * Split from {@link parseInlineSecrets} so the request envelope — which
- * validates the bundle as part of its own single parse — resolves it without
- * parsing it a second time.
- */
-function normalizeInlineSecrets(parsed) {
-    if (parsed === undefined || parsed === null) {
-        return {};
-    }
-    const mcpServers = parsed.mcpServers;
-    const envSecrets = normalizeEnvSecrets(parsed.envSecrets);
-    // Spread only the present halves: `PlatformInlineSecrets` promises each key
-    // is absent or a value, never present-and-undefined.
-    return {
-        ...(mcpServers ? { mcpServers } : {}),
-        ...(envSecrets ? { envSecrets } : {})
-    };
-}
-export function assertNoSecretBearingFields(input, path) {
-    if (Array.isArray(input)) {
-        input.forEach((item, index) => assertNoSecretBearingFields(item, [...path, String(index)]));
-        return;
-    }
-    if (!isRecord(input)) {
-        return;
-    }
-    for (const [key, value] of Object.entries(input)) {
-        if (deniedSecretFields.has(key)) {
-            throw new Error(`Secret-bearing field is not allowed in platform submission: ${[...path, key].join(".")}`);
-        }
-        assertNoSecretBearingFields(value, [...path, key]);
-    }
-}
-export function requireRecord(input, field) {
-    if (!isRecord(input)) {
-        throw new Error(`${field} must be an object`);
-    }
-    return input;
-}
-export function requireString(input, field) {
-    if (typeof input !== "string" || input.length === 0) {
-        throw new Error(`${field} must be a non-empty string`);
-    }
-    return input;
-}
-export function optionalString(input, field) {
-    if (input === undefined) {
-        return undefined;
-    }
-    return requireString(input, field);
-}
-export function optionalEnum(input, field, allowed) {
-    if (input === undefined) {
-        return undefined;
-    }
-    if (!isStringLiteral(input, allowed)) {
-        throw new Error(`${field} must be one of: ${allowed.join(", ")}`);
-    }
-    return input;
-}
-export function optionalPositiveInt(input, field) {
-    if (input === undefined) {
-        return undefined;
-    }
-    if (typeof input !== "number" || !Number.isSafeInteger(input) || input <= 0) {
-        throw new Error(`${field} must be a positive safe integer`);
-    }
-    return input;
-}
-/**
- * A finite positive NUMBER (fractional allowed — e.g. a USD amount like `2.5`), or
- * undefined when absent. Rejects non-numbers, NaN/Infinity, and `<= 0`.
- */
-export function optionalPositiveNumber(input, field) {
-    if (input === undefined) {
-        return undefined;
-    }
-    if (typeof input !== "number" || !Number.isFinite(input) || input <= 0) {
-        throw new Error(`${field} must be a positive finite number`);
-    }
-    return input;
-}
-export function parseSessionSubmissionRequest(input) {
-    return withContractParseError("parseSessionSubmissionRequest", () => {
-        const value = parseWire(SessionSubmissionRequestSchema, input);
-        // Defence in depth: scan every non-secrets field for credential-named
-        // keys. The `secrets` key is
-        // the only allow-listed home for credential material.
-        for (const [key, fieldValue] of Object.entries(value)) {
-            if (key === SECRETS_KEY) {
-                continue;
-            }
-            if (deniedSecretFields.has(key)) {
-                throw new Error(`Secret-bearing field is not allowed in platform submission: ${key}`);
-            }
-            assertNoSecretBearingFields(fieldValue, [key]);
-        }
-        // The envelope schema has already validated every dial; what is left is the
-        // decode (`timeout` -> ms) and the collapse-to-`undefined` rules.
-        const runtimeSize = value.runtimeSize;
-        const runtimeKind = value.runtimeKind;
-        const timeoutMs = parseSessionTimeout(value.timeout);
-        const webhook = value.webhook;
-        const limits = value.limits === undefined ? undefined : normalizeSessionLimits(value.limits);
-        const machine = value.machine === undefined ? undefined : normalizeSessionMachine(value.machine);
-        const secrets = normalizeInlineSecrets(value.secrets);
-        // Branded as `parseSubmission` because that is the parser a caller would
-        // recognise as having rejected the brief, even though the shape was validated
-        // one level up as part of the envelope.
-        const submission = withContractParseError("parseSubmission", () => normalizeSubmission(value.submission));
-        crossValidateSecretEnvAndValues(submission.secretEnv, secrets.envSecrets);
-        // mcpServers names must agree across the submission half and the
-        // secrets half — every secrets.mcpServers[i].name MUST resolve to a
-        // submission.mcpServers entry (no orphan secrets) AND the URL must
-        // match exactly. The reverse is allowed (an MCP server with no auth
-        // headers is a valid public-MCP mode).
-        if (secrets.mcpServers !== undefined) {
-            const declared = new Map(submission.mcpServers.map((m) => [m.name, m.url]));
-            for (const secret of secrets.mcpServers) {
-                const declaredUrl = declared.get(secret.name);
-                if (declaredUrl === undefined) {
-                    throw new Error(`secrets.mcpServers[name=${secret.name}] has no matching submission.mcpServers entry`);
-                }
-                if (declaredUrl !== secret.url) {
-                    throw new Error(`secrets.mcpServers[name=${secret.name}].url must equal submission.mcpServers[name=${secret.name}].url ` +
-                        `(got submission=${declaredUrl}, secrets=${secret.url})`);
-                }
-            }
-        }
-        return {
-            workspaceId: value.workspaceId,
-            idempotencyKey: value.idempotencyKey,
-            submission,
-            ...(runtimeSize ? { runtimeSize } : {}),
-            ...(runtimeKind ? { runtimeKind } : {}),
-            ...(timeoutMs !== undefined ? { timeoutMs } : {}),
-            ...(webhook !== undefined ? { webhook } : {}),
-            ...(limits !== undefined ? { limits } : {}),
-            ...(machine !== undefined ? { machine } : {}),
-            secrets
-        };
-    });
-}
-/**
- * Parse + SSRF-shape-validate the optional per-session `webhook`. The URL must be
- * https with no userinfo (a `user:pass@host` URL is rejected — credentials must
- * not ride in a callback URL). Unknown subfields are rejected so the strict
- * top-level allow-list extends to the nested object. Returns `undefined` when
- * absent. Delivery-time re-resolution + IP-deny checks live server-side; this
- * is the submit-time shape gate.
- */
-export function parseSessionWebhook(input) {
-    return withContractParseError("parseSessionWebhook", () => {
-        if (input === undefined) {
-            return undefined;
-        }
-        return parseWire(SessionWebhookSchema, input);
-    });
-}
-/**
- * Parse the optional per-session `limits` override. Mirrors {@link parseSessionWebhook}:
- * absent ⇒ `undefined`; a non-object or any unknown subfield is rejected so the
- * strict top-level allow-list extends to the nested object. Each present field
- * is validated as a positive safe integer via {@link optionalPositiveInt}.
- *
- * This is a SHAPE/positivity gate only — it does NOT clamp to the workspace or
- * platform ceilings (that precedence lives in the resolver, `resolveSessionLimits`).
- * Only the present fields are returned; an all-absent override (e.g. `{}`)
- * collapses to `undefined` so it carries no signal onto the request.
- */
-export function parseSessionLimits(input) {
-    return withContractParseError("parseSessionLimits", () => {
-        if (input === undefined) {
-            return undefined;
-        }
-        return normalizeSessionLimits(parseWire(SessionLimitsSchema, input));
-    });
-}
-/**
- * Boot-session budget fragment. The public submit surface names a session's spend
- * cap `limits.maxSpendUsd`; the frozen boot session config the managed runtime
- * folds the loop against names the SAME USD value `budgetUsd` — the field the
- * session planner reads to enforce/terminate a session that would out-spend its cap.
- * This is the single source of truth for that wire→boot name mapping so the two
- * layers can never drift.
- *
- * Returns a fragment safe to spread into `sessionConfig.limits`: `{ budgetUsd }`
- * when a cap is set, `{}` when none is (an absent cap stays absent — the session is
- * unbounded per-session, subject only to the session timeout + the per-workspace cap).
- * Pure: same input ⇒ same output.
- */
-export function sessionBudgetLimits(limits) {
-    if (limits?.maxSpendUsd === undefined) {
-        return {};
-    }
-    return { budgetUsd: limits.maxSpendUsd };
-}
-/**
- * Parse the optional per-session `machine` capacity intent. Mirrors
- * {@link parseSessionWebhook}: absent ⇒ `undefined`; a non-object or any unknown
- * subfield is rejected so the strict top-level allow-list extends to the nested
- * object. `spot` must be a boolean when present. A no-signal object (e.g.
- * `machine: {}`) collapses to `undefined` so it never lands an empty object on
- * the request. An explicit `spot` (true or false) is preserved verbatim. Only
- * shape is validated here — capacity selection is a runtime concern.
- */
-export function parseSessionMachine(input) {
-    return withContractParseError("parseSessionMachine", () => {
-        if (input === undefined) {
-            return undefined;
-        }
-        return normalizeSessionMachine(parseWire(SessionMachineSchema, input));
-    });
-}
-export function parseSubmission(input) {
-    return withContractParseError("parseSubmission", () => normalizeSubmission(parseWire(SubmissionSchema, input)));
-}
-/**
- * Resolve a validated brief onto {@link PlatformSubmission}.
- *
- * Everything here is a transform or a lookup the schema deliberately does not
- * own: the prompt's single-string form widened to a list, ecosystem prefixes
- * split, resource name grammars asserted, no-signal objects collapsed to
- * `undefined`, builtin tool names resolved into canonical order. Key order in
- * the returned object is pinned by
- * `test/allowed-keys-parser-golden.test.ts`.
- */
-function normalizeSubmission(value) {
-    const system = value.system;
-    const prompt = normalizePrompt(value.prompt);
-    const assets = normalizeSubmissionAssets(value.assets);
-    const mcpServers = parseMcpServers(value.mcpServers);
-    const secretEnv = normalizeSecretEnv(value.secretEnv);
-    const environment = normalizeEnvironment(value.environment);
-    const securityProfile = value.securityProfile ?? undefined;
-    const metadata = value.metadata;
-    const fileCapture = normalizeFileCapture(value.fileCapture);
-    const builtinTools = resolveBuiltinToolsSelection(value.builtinTools);
-    const outputMode = value.outputMode ?? undefined;
-    const responseFormat = normalizeResponseFormat(value.responseFormat);
-    const approvalGate = normalizeApprovalGate(value.approvalGate);
-    const platform = normalizePlatformInjection(value.platform);
-    return {
-        model: value.model,
-        ...(system ? { system } : {}),
-        prompt,
-        assets,
-        mcpServers,
-        ...(secretEnv ? { secretEnv } : {}),
-        ...(environment ? { environment } : {}),
-        ...(securityProfile ? { securityProfile } : {}),
-        ...(metadata ? { metadata } : {}),
-        ...(fileCapture ? { fileCapture } : {}),
-        builtinTools,
-        ...(outputMode !== undefined ? { outputMode } : {}),
-        ...(responseFormat !== undefined ? { responseFormat } : {}),
-        ...(approvalGate !== undefined ? { approvalGate } : {}),
-        ...(platform ? { platform } : {})
-    };
-}
-function normalizeSubmissionAssets(value) {
-    return {
-        files: projectWorkspaceResources(value.files, "files", (raw, base, path) => {
-            assertWorkspaceFileResourceName(raw.name, `${path}.name`);
-            assertValidMountPath(raw.mountPath, `${path}.mountPath`);
-            return { ...base, kind: "file", name: raw.name, mountPath: raw.mountPath };
-        }),
-        skills: projectWorkspaceResources(value.skills, "skills", (raw, base, path) => {
-            assertValidSkillName(raw.name, `${path}.name`);
-            return { ...base, kind: "skill", name: raw.name, description: raw.description };
-        }),
-        tools: projectWorkspaceResources(value.tools, "tools", (raw, base, path) => {
-            if (!TOOL_NAME_PATTERN.test(raw.name) || raw.name.includes("__")) {
-                throw new Error(`${path}.name must be a non-reserved tool name matching ${TOOL_NAME_PATTERN.source}`);
-            }
-            return {
-                ...base,
-                kind: "tool",
-                name: raw.name,
-                description: raw.description,
-                input_schema: raw.input_schema,
-                entry: normaliseSkillBundlePath(raw.entry)
-            };
-        }),
-        instructions: projectWorkspaceResources(value.instructions, "instructions", (raw, base, path) => {
-            assertWorkspaceInstructionResourceName(raw.name, `${path}.name`);
-            return { ...base, kind: "instruction", name: raw.name };
-        })
-    };
-}
-/**
- * Project one validated list onto its parsed refs.
- *
- * What survives here rather than moving into the element schema is what a
- * schema cannot state: the name grammars (asserts the SDK builders call
- * directly, two of them declared in `session-config.ts`, which imports this
- * file), the `entry` bundle-path normalisation, the `assetId`/`contentHash`
- * agreement, and per-list duplicate detection — which needs every element at
- * once and reports the LATER element, not the list.
- */
-function projectWorkspaceResources(entries, field, project) {
-    if (entries === undefined)
-        return [];
-    const seen = new Set();
-    return entries.map((raw, index) => {
-        const path = `submission.assets.${field}[${index}]`;
-        const base = {
-            resourceId: raw.resourceId,
-            version: raw.version,
-            assetId: raw.assetId,
-            contentHash: raw.contentHash
-        };
-        const result = project(raw, base, path);
-        assertPinnedWorkspaceResource(result, path);
-        const identity = `${result.resourceId}:${result.version}`;
-        if (seen.has(identity))
-            throw new Error(`${path} duplicates resource version ${identity}`);
-        seen.add(identity);
-        return result;
-    });
-}
-/** An empty declaration set carries no signal, so it is dropped rather than landed empty. */
-function normalizeSecretEnv(secretEnv) {
-    if (secretEnv === undefined || secretEnv === null)
-        return undefined;
-    const entries = Object.entries(secretEnv);
-    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
-}
-function normalizePlatformInjection(value) {
-    if (value === undefined || value === null || value.systemPrompt === undefined)
-        return undefined;
-    return { systemPrompt: value.systemPrompt };
-}
-/**
- * Assistant-output granularity values and the structured-output kinds, declared
- * with the schemas that enforce them and re-exported here so the published
- * surface is unchanged — see the sibling note on the `secretEnv` grammars.
- */
-export { OUTPUT_MODES, RESPONSE_FORMAT_KINDS } from "./schemas/submission-body.js";
-export const DEFAULT_OUTPUT_MODE = "buffered";
-/**
- * Parse the optional `submission.responseFormat`. Absent ⇒ undefined; a bad
- * `kind` or unknown subfield is rejected (fail-fast). `json_schema` requires a
- * JSON-object `schema`.
- */
-export function parseResponseFormat(input) {
-    return withContractParseError("parseResponseFormat", () => {
-        if (input === undefined || input === null)
-            return undefined;
-        return normalizeResponseFormat(parseWire(ResponseFormatSchema, input));
-    });
-}
-/** Drop absent optional members so an omitted field never lands as `undefined`. */
-function normalizeResponseFormat(value) {
-    if (value === undefined || value === null)
-        return undefined;
-    if (value.kind === "text") {
-        return { kind: "text" };
-    }
-    return {
-        kind: "json_schema",
-        schema: value.schema,
-        ...(value.strict !== undefined ? { strict: value.strict } : {}),
-        ...(value.name !== undefined ? { name: value.name } : {})
-    };
-}
-/**
- * Parse the optional `submission.approvalGate`. Absent / empty tool list ⇒
- * undefined (no gate). Tool names are deduped; the strict allow-list mirrors the
- * sibling parsers.
- */
-export function parseApprovalGate(input) {
-    return withContractParseError("parseApprovalGate", () => {
-        if (input === undefined || input === null)
-            return undefined;
-        return normalizeApprovalGate(parseWire(ApprovalGateSchema, input));
-    });
-}
-/** Dedupe in first-seen order; an empty gate carries no signal and is dropped. */
-function normalizeApprovalGate(value) {
-    if (value === undefined || value === null)
-        return undefined;
-    const seen = new Set();
-    const tools = [];
-    for (const entry of value.tools) {
-        if (!seen.has(entry)) {
-            seen.add(entry);
-            tools.push(entry);
-        }
-    }
-    return tools.length === 0 ? undefined : { tools };
-}
-/**
- * The CLOSED set of builtin tool NAMES the managed runtime can inject — one per
- * machine tool the hands implement. This list is the single source of truth for
- * validating builtin tool references; the platform's `HANDS_TOOLS` (the execute
- * vocabulary) is pinned EQUAL to it at module load (`platform-runtime-agent`
- * `assertNamesMatch`), so a rename on either side fails loudly rather than
- * silently shipping a name the executors do not speak.
- *
- * Order mirrors `HANDS_TOOLS`. A builtin tool reference (a bare string in
- * `submission.tools`) must be a member of this set.
- */
-export const BUILTIN_TOOL_NAMES = [
-    "bash",
-    "read_file",
-    "write_file",
-    "edit_file",
-    "grep",
-    "glob",
-    "head",
-    "tail",
-    "todo_write",
-    "subagent",
-    "subagent_result",
-    "web_fetch",
-    "web_search",
-    "bash_output",
-    "bash_kill",
-    "code_execution",
-    "wait",
-    "git",
-    "ls",
-    "stat",
-    "wc"
-];
-/**
- * Typo-safe accessors for the closed builtin tool set: each key maps to the
- * real tool NAME string. Reference a builtin in `submission.tools` via
- * `BuiltinTools.web_search` rather than the bare string so a rename is a
- * compile error, not a runtime 400.
- *
- * Keys are the real tool names; a unit test asserts `Object.values(BuiltinTools)`
- * deep-equals `BUILTIN_TOOL_NAMES` so the two can never drift.
- */
-export const BuiltinTools = {
-    bash: "bash",
-    read_file: "read_file",
-    write_file: "write_file",
-    edit_file: "edit_file",
-    grep: "grep",
-    glob: "glob",
-    head: "head",
-    tail: "tail",
-    todo_write: "todo_write",
-    subagent: "subagent",
-    subagent_result: "subagent_result",
-    web_fetch: "web_fetch",
-    web_search: "web_search",
-    bash_output: "bash_output",
-    bash_kill: "bash_kill",
-    code_execution: "code_execution",
-    wait: "wait",
-    git: "git",
-    ls: "ls",
-    stat: "stat",
-    wc: "wc"
-};
-/**
- * The complete builtin set selected by `builtinTools: "default"`.
- */
-export const DEFAULT_BUILTIN_TOOLS = BUILTIN_TOOL_NAMES;
-// ---------------------------------------------------------------------------
-// The default `skills` meta-tool
-// ---------------------------------------------------------------------------
-/**
- * Fixed name of the single skills meta-tool. Deliberately NOT a member of
- * {@link BUILTIN_TOOL_NAMES} (that closed set is the customer-cherry-pickable
- * toggle surface, pinned equal to `HANDS_TOOLS`) — the skills tool is IMPLIED by
- * a session having ≥1 skill, not chosen, and is injected platform-side. Kept in
- * lockstep with {@link SKILL_RESERVED_NAMES} so it can never be shadowed by a
- * custom tool or skill of the same name.
- */
-export const SKILLS_TOOL_NAME = "skills";
-/**
- * The single default `skills` meta-tool (list/load) the platform injects when a
- * session references ≥1 workspace skill. Shared by the platform tool composer and
- * kept adjacent to the reserved-name guard so the model-visible contract and the
- * name reservation stay in one place. It replaces the former N per-skill no-arg
- * load-tools with one arg-taking dispatcher.
- */
-export const SKILLS_TOOL_DEFINITION = {
-    name: "skills",
-    description: "List and load the workspace SKILLS available to this session. Call with {action:'list'} to see each skill's " +
-        "name + description (cheap; do this first). Call with {action:'load', name:'<skill>'} to read that skill's " +
-        "full SKILL.md instructions into context before doing work the skill governs. A skill's supporting files are " +
-        "already on disk under /workspace/skills/<name>/ — load pulls the instructions; read_file/bash read the rest.",
-    input_schema: {
-        type: "object",
-        properties: {
-            action: { type: "string", enum: ["list", "load"], description: "'list' all skills, or 'load' one by name." },
-            name: { type: "string", description: "Skill name to load (required when action='load')." }
-        },
-        required: ["action"],
-        additionalProperties: false
-    }
-};
-export function resolveBuiltinToolNames(selection = "default") {
-    if (selection === "default")
-        return DEFAULT_BUILTIN_TOOLS;
-    if (selection === "none")
-        return [];
-    const enabled = new Set();
-    for (const ref of selection) {
-        if (!BUILTIN_TOOL_NAMES.includes(ref)) {
-            throw new Error(`${JSON.stringify(ref)} is not a builtin tool; expected one of: ${BUILTIN_TOOL_NAMES.join(", ")}`);
-        }
-        enabled.add(ref);
-    }
-    return BUILTIN_TOOL_NAMES.filter((name) => enabled.has(name));
-}
-/**
- * Resolve a validated selection into canonical order.
- *
- * Membership in {@link BUILTIN_TOOL_NAMES} and the resulting order are
- * `resolveBuiltinToolNames`' — a lookup plus a re-order, which is a transform,
- * and against a list the schema cannot import without a cycle.
- */
-function resolveBuiltinToolsSelection(input) {
-    if (input === undefined || input === null || input === "default")
-        return "default";
-    if (input === "none")
-        return "none";
-    return resolveBuiltinToolNames(input.map((value, index) => {
-        if (typeof value !== "string") {
-            throw new Error(`submission.builtinTools[${index}] must be a builtin tool name`);
-        }
-        return value;
-    }));
-}
-/**
- * Ceiling the platform will spend capturing files. A CLAMP, not a rejection —
- * an over-large request is honoured at the maximum rather than refused — so it
- * belongs here and not on the schema, which describes what is accepted.
- */
-const MAX_FILE_CAPTURE_TIMEOUT_MS = 6 * 60 * 60 * 1000;
-function normalizeFileCapture(value) {
-    if (value === undefined || value === null) {
-        return undefined;
-    }
-    const allowedDirs = normalizeCaptureDirs(value.allowedDirs);
-    const deniedDirs = normalizeCaptureDirs(value.deniedDirs);
-    const captureTimeoutMs = value.captureTimeoutMs === undefined
-        ? undefined
-        : Math.min(value.captureTimeoutMs, MAX_FILE_CAPTURE_TIMEOUT_MS);
-    const { maxFileBytes, maxTotalBytes, maxFiles } = value;
-    if (!allowedDirs && !deniedDirs && captureTimeoutMs === undefined && maxFileBytes === undefined && maxTotalBytes === undefined && maxFiles === undefined) {
-        return undefined;
-    }
-    return {
-        ...(allowedDirs ? { allowedDirs } : {}),
-        ...(deniedDirs ? { deniedDirs } : {}),
-        ...(captureTimeoutMs !== undefined ? { captureTimeoutMs } : {}),
-        ...(maxFileBytes !== undefined ? { maxFileBytes } : {}),
-        ...(maxTotalBytes !== undefined ? { maxTotalBytes } : {}),
-        ...(maxFiles !== undefined ? { maxFiles } : {})
-    };
-}
-/**
- * Canonicalise a capture list and drop repeats.
- *
- * An empty array is treated as omission so the idempotency hash matches the
- * "no list supplied" case. Only absolute entries are canonicalised: a denied
- * pattern like `node_modules` or `*.tmp` is not a path and is kept verbatim.
- */
-function normalizeCaptureDirs(entries) {
-    if (entries === undefined || entries.length === 0) {
-        return undefined;
-    }
-    const seen = new Set();
-    const normalised = [];
-    for (const entry of entries) {
-        const canonical = entry.startsWith("/") ? canonicalCapturePath(entry) : entry;
-        if (seen.has(canonical)) {
-            continue;
-        }
-        seen.add(canonical);
-        normalised.push(canonical);
-    }
-    return normalised;
-}
-/** Collapse repeated separators and drop a trailing slash; `/` stays `/`. */
-function canonicalCapturePath(entry) {
-    const collapsed = entry
-        .split("/")
-        .filter((segment, index) => segment.length > 0 || index === 0)
-        .join("/");
-    const stripped = collapsed.length > 1 && collapsed.endsWith("/") ? collapsed.slice(0, -1) : collapsed;
-    return stripped.length === 0 ? "/" : stripped;
-}
-/**
- * Widen the single-string form to the one-element list the platform carries
- * everywhere downstream. The emptiness and whitespace rules are the schema's.
- */
-function normalizePrompt(input) {
-    return typeof input === "string" ? [input] : input;
-}
-/**
- * Shared skill-name gate for {@link parseSkills}
- * (and mirrored SDK-side in `Skill`): pattern + `__` MCP separator + reserved
- * names (`skills`, `skill`).
- */
-function assertValidSkillName(name, field) {
-    if (!SKILL_NAME_PATTERN.test(name)) {
-        throw new Error(`${field} must match ${SKILL_NAME_PATTERN.source}`);
-    }
-    if (name.includes("__")) {
-        throw new Error(`${field} must not contain "__"; that separator is reserved for MCP tools`);
-    }
-    if (SKILL_RESERVED_NAMES.has(name)) {
-        throw new Error(`${field} must not be a reserved skills name (${[...SKILL_RESERVED_NAMES].join(", ")})`);
-    }
-}
-function parseMcpServers(input) {
-    if (input === undefined) {
-        return [];
-    }
-    const seen = new Set();
-    return input.map((item, index) => {
-        const ref = parseMcpServerRef(item, `submission.mcpServers[${index}]`);
-        if (seen.has(ref.name)) {
-            throw new Error(`submission.mcpServers duplicate name: ${ref.name}`);
-        }
-        seen.add(ref.name);
-        return ref;
-    });
-}