vgxness 1.20.5 → 1.20.7

package/dist/interfaces/mcp/validation/providers.js

@@ -0,0 +1,94 @@
+import { inputRecord, payloadModes, providerChangePlanProviders, providerChangePlanTypes, providerInstallTargets, providerUserGlobalOnlyMigrationMessage, readNonEmptyString, readOptionalNonEmptyString, readOptionalOneOf, readRequiredOneOf, scopes, validationFailure, } from './common.js';
+export function validateProviderChangePlanInput(input, tool) {
+    const record = inputRecord(input, tool, ['project', 'scope', 'installTarget', 'provider', 'changeType', 'workspaceRoot', 'payloadMode']);
+    if (!record.ok)
+        return record;
+    const provider = readRequiredOneOf(record.value, 'provider', providerChangePlanProviders, tool);
+    if (!provider.ok)
+        return provider;
+    const changeType = readRequiredOneOf(record.value, 'changeType', providerChangePlanTypes, tool);
+    if (!changeType.ok)
+        return changeType;
+    const workspaceRoot = readNonEmptyString(record.value, 'workspaceRoot', tool);
+    if (!workspaceRoot.ok)
+        return workspaceRoot;
+    const payloadMode = readRequiredOneOf(record.value, 'payloadMode', payloadModes, tool);
+    if (!payloadMode.ok)
+        return payloadMode;
+    const result = {
+        provider: provider.value,
+        changeType: changeType.value,
+        workspaceRoot: workspaceRoot.value,
+        payloadMode: payloadMode.value,
+    };
+    const project = readOptionalNonEmptyString(record.value, 'project', tool);
+    if (!project.ok)
+        return project;
+    if (project.value !== undefined)
+        result.project = project.value;
+    const scope = readOptionalOneOf(record.value, 'scope', scopes, tool);
+    if (!scope.ok)
+        return scope;
+    if (scope.value !== undefined)
+        result.scope = scope.value;
+    if (typeof record.value.installTarget === 'string' && record.value.installTarget.trim() !== 'user-global') {
+        return validationFailure(providerUserGlobalOnlyMigrationMessage, tool);
+    }
+    const installTarget = readOptionalOneOf(record.value, 'installTarget', providerInstallTargets, tool);
+    if (!installTarget.ok)
+        return installTarget;
+    if (installTarget.value !== undefined)
+        result.installTarget = installTarget.value;
+    return { ok: true, value: result };
+}
+export function validateProviderHealthInput(input, tool) {
+    const record = inputRecord(input ?? {}, tool, [
+        'project',
+        'scope',
+        'providerAdapter',
+        'workspaceRoot',
+        'change',
+        'expectedPromptContractVersion',
+        'payloadMode',
+    ]);
+    if (!record.ok)
+        return record;
+    const result = {};
+    const project = readOptionalNonEmptyString(record.value, 'project', tool);
+    if (!project.ok)
+        return project;
+    if (project.value !== undefined)
+        result.project = project.value;
+    const scope = readOptionalOneOf(record.value, 'scope', scopes, tool);
+    if (!scope.ok)
+        return scope;
+    if (scope.value !== undefined)
+        result.scope = scope.value;
+    const providerAdapter = readOptionalOneOf(record.value, 'providerAdapter', ['opencode', 'claude'], tool);
+    if (!providerAdapter.ok)
+        return providerAdapter;
+    if (providerAdapter.value !== undefined)
+        result.providerAdapter = providerAdapter.value;
+    const workspaceRoot = readOptionalNonEmptyString(record.value, 'workspaceRoot', tool);
+    if (!workspaceRoot.ok)
+        return workspaceRoot;
+    if (workspaceRoot.value !== undefined)
+        result.workspaceRoot = workspaceRoot.value;
+    const change = readOptionalNonEmptyString(record.value, 'change', tool);
+    if (!change.ok)
+        return change;
+    if (change.value !== undefined)
+        result.change = change.value;
+    const expectedPromptContractVersion = record.value.expectedPromptContractVersion;
+    if (expectedPromptContractVersion !== undefined) {
+        if (typeof expectedPromptContractVersion !== 'number' || !Number.isSafeInteger(expectedPromptContractVersion) || expectedPromptContractVersion <= 0)
+            return validationFailure('expectedPromptContractVersion must be a positive safe integer', tool);
+        result.expectedPromptContractVersion = expectedPromptContractVersion;
+    }
+    const payloadMode = readOptionalOneOf(record.value, 'payloadMode', payloadModes, tool);
+    if (!payloadMode.ok)
+        return payloadMode;
+    if (payloadMode.value !== undefined)
+        result.payloadMode = payloadMode.value;
+    return { ok: true, value: result };
+}

package/dist/interfaces/mcp/validation/runs.js

@@ -0,0 +1,514 @@
+import { isRiskyPermissionCategory, permissionCategories } from '../../../permissions/schema.js';
+import { parseOperationRetryPolicy } from '../../../runs/operation-retry.js';
+import { workflowIds } from '../../../workflows/schema.js';
+import { asRecord, copyOptionalBooleans, copyOptionalStrings, copyRequiredStrings, finalRunStatuses, inputRecord, readBoundedLimit, readJsonValue, readNonEmptyString, readOptionalBoundedLimit, readOptionalOneOf, readOptionalStringArray, readPreflightAgent, readRequiredOneOf, readRequiredOneOfArray, readRequiredStringArray, readTaskGrantActor, readTaskGrantCommandPolicy, runOutcomes, runStatuses, taskGrantCategories, taskGrantStatuses, validationFailure, } from './common.js';
+export function validateRunListInput(input, tool) {
+    const record = inputRecord(input, tool, ['project', 'status', 'limit']);
+    if (!record.ok)
+        return record;
+    const result = {};
+    const project = copyOptionalStrings(result, record.value, tool, ['project']);
+    if (!project.ok)
+        return project;
+    const status = readOptionalOneOf(record.value, 'status', runStatuses, tool);
+    if (!status.ok)
+        return status;
+    if (status.value !== undefined)
+        result.status = status.value;
+    const limit = readBoundedLimit(record.value, tool);
+    if (!limit.ok)
+        return limit;
+    result.limit = limit.value;
+    return { ok: true, value: result };
+}
+export function validateRunGetInput(input, tool) {
+    const record = inputRecord(input, tool, ['id']);
+    if (!record.ok)
+        return record;
+    const id = readNonEmptyString(record.value, 'id', tool);
+    if (!id.ok)
+        return id;
+    return { ok: true, value: { id: id.value } };
+}
+export function validateRunPreflightInput(input, tool) {
+    const record = inputRecord(input, tool, [
+        'runId',
+        'category',
+        'operation',
+        'workflow',
+        'phase',
+        'agentId',
+        'workspaceRoot',
+        'targetPath',
+        'taskFingerprint',
+        'commandId',
+        'cwd',
+        'targetPaths',
+        'providerToolName',
+        'agent',
+        'sandboxStrategy',
+        'destructive',
+        'external',
+        'privileged',
+        'ambiguous',
+        'providerConfigMutation',
+        'globalConfigMutation',
+        'explicitRequest',
+    ]);
+    if (!record.ok)
+        return record;
+    const runId = readNonEmptyString(record.value, 'runId', tool);
+    if (!runId.ok)
+        return runId;
+    const category = readRequiredOneOf(record.value, 'category', permissionCategories, tool);
+    if (!category.ok)
+        return category;
+    const operation = readNonEmptyString(record.value, 'operation', tool);
+    if (!operation.ok)
+        return operation;
+    const result = { runId: runId.value, category: category.value, operation: operation.value };
+    const workflow = readOptionalOneOf(record.value, 'workflow', workflowIds, tool);
+    if (!workflow.ok)
+        return workflow;
+    if (workflow.value !== undefined)
+        result.workflow = workflow.value;
+    const copied = copyOptionalStrings(result, record.value, tool, [
+        'phase',
+        'agentId',
+        'workspaceRoot',
+        'targetPath',
+        'taskFingerprint',
+        'commandId',
+        'cwd',
+        'providerToolName',
+    ]);
+    if (!copied.ok)
+        return copied;
+    const targetPaths = readOptionalStringArray(record.value, 'targetPaths', tool);
+    if (!targetPaths.ok)
+        return targetPaths;
+    if (targetPaths.value !== undefined)
+        result.targetPaths = targetPaths.value;
+    const sandboxStrategy = readOptionalOneOf(record.value, 'sandboxStrategy', ['worktree'], tool);
+    if (!sandboxStrategy.ok)
+        return sandboxStrategy;
+    if (sandboxStrategy.value !== undefined)
+        result.sandboxStrategy = sandboxStrategy.value;
+    const booleans = copyOptionalBooleans(result, record.value, tool, [
+        'destructive',
+        'external',
+        'privileged',
+        'ambiguous',
+        'providerConfigMutation',
+        'globalConfigMutation',
+    ]);
+    if (!booleans.ok)
+        return booleans;
+    if (record.value.agent !== undefined) {
+        const agent = readPreflightAgent(record.value.agent, tool);
+        if (!agent.ok)
+            return agent;
+        result.agent = agent.value;
+    }
+    if (record.value.explicitRequest !== undefined) {
+        const explicitRequest = readExplicitRequest(record.value.explicitRequest, tool);
+        if (!explicitRequest.ok)
+            return explicitRequest;
+        result.explicitRequest = explicitRequest.value;
+    }
+    if (isRiskyPermissionCategory(result.category)) {
+        if (result.phase !== undefined && result.agentId === undefined && result.agent === undefined) {
+            return validationFailure(`VGX-managed preflight for risky category ${result.category} requires agentId when phase metadata is provided`, tool);
+        }
+        if (result.agentId !== undefined && result.phase === undefined) {
+            return validationFailure(`VGX-managed preflight for risky category ${result.category} requires phase when agentId metadata is provided`, tool);
+        }
+    }
+    return { ok: true, value: result };
+}
+export function readExplicitRequest(value, tool) {
+    const record = asRecord(value, tool, 'explicitRequest must be an object');
+    if (!record.ok)
+        return record;
+    const unexpected = Object.keys(record.value).find((key) => !['version', 'actor', 'request', 'requestedOperation', 'riskAttributes', 'parser'].includes(key));
+    if (unexpected !== undefined)
+        return validationFailure(`Unexpected explicitRequest field: ${unexpected}`, tool);
+    if (record.value.version !== 1)
+        return validationFailure('explicitRequest.version must be 1', tool);
+    const actor = readExplicitRequestActor(record.value.actor, tool);
+    if (!actor.ok)
+        return actor;
+    const request = readExplicitRequestRequest(record.value.request, tool);
+    if (!request.ok)
+        return request;
+    const requestedOperation = readExplicitRequestedOperation(record.value.requestedOperation, tool);
+    if (!requestedOperation.ok)
+        return requestedOperation;
+    const riskAttributes = readExplicitRiskAttributes(record.value.riskAttributes, tool);
+    if (!riskAttributes.ok)
+        return riskAttributes;
+    const parser = readExplicitParser(record.value.parser, tool);
+    if (!parser.ok)
+        return parser;
+    return {
+        ok: true,
+        value: {
+            version: 1,
+            actor: actor.value,
+            request: request.value,
+            requestedOperation: requestedOperation.value,
+            riskAttributes: riskAttributes.value,
+            parser: parser.value,
+        },
+    };
+}
+export function readExplicitRequestActor(value, tool) {
+    const record = asRecord(value, tool, 'explicitRequest.actor must be an object');
+    if (!record.ok)
+        return record;
+    const unexpected = Object.keys(record.value).find((key) => !['type', 'id', 'displayName'].includes(key));
+    if (unexpected !== undefined)
+        return validationFailure(`Unexpected explicitRequest.actor field: ${unexpected}`, tool);
+    const type = readRequiredOneOf(record.value, 'type', ['human'], tool);
+    if (!type.ok)
+        return type;
+    const actor = { type: type.value };
+    const copied = copyOptionalStrings(actor, record.value, tool, ['id', 'displayName']);
+    if (!copied.ok)
+        return copied;
+    return { ok: true, value: actor };
+}
+export function readExplicitRequestRequest(value, tool) {
+    const record = asRecord(value, tool, 'explicitRequest.request must be an object');
+    if (!record.ok)
+        return record;
+    const unexpected = Object.keys(record.value).find((key) => !['id', 'source', 'utteranceRef', 'excerpt', 'requestedAt', 'sessionId', 'runId'].includes(key));
+    if (unexpected !== undefined)
+        return validationFailure(`Unexpected explicitRequest.request field: ${unexpected}`, tool);
+    const source = readRequiredOneOf(record.value, 'source', ['chat', 'mcp', 'cli', 'provider', 'unknown'], tool);
+    if (!source.ok)
+        return source;
+    const requestedAt = readNonEmptyString(record.value, 'requestedAt', tool);
+    if (!requestedAt.ok)
+        return requestedAt;
+    if (!validIsoTimestamp(requestedAt.value))
+        return validationFailure('explicitRequest.request.requestedAt must be a valid ISO timestamp', tool);
+    const request = { source: source.value, requestedAt: requestedAt.value };
+    const copied = copyOptionalStrings(request, record.value, tool, ['id', 'utteranceRef', 'excerpt', 'sessionId', 'runId']);
+    if (!copied.ok)
+        return copied;
+    return { ok: true, value: request };
+}
+export function readExplicitRequestedOperation(value, tool) {
+    const record = asRecord(value, tool, 'explicitRequest.requestedOperation must be an object');
+    if (!record.ok)
+        return record;
+    const unexpected = Object.keys(record.value).find((key) => !['category', 'operation', 'commandId', 'providerToolName', 'targetPath', 'targetPaths', 'cwd', 'workspaceRoot', 'scopeSummary'].includes(key));
+    if (unexpected !== undefined)
+        return validationFailure(`Unexpected explicitRequest.requestedOperation field: ${unexpected}`, tool);
+    const category = readRequiredOneOf(record.value, 'category', permissionCategories, tool);
+    if (!category.ok)
+        return category;
+    const operation = readNonEmptyString(record.value, 'operation', tool);
+    if (!operation.ok)
+        return operation;
+    const scopeSummary = readNonEmptyString(record.value, 'scopeSummary', tool);
+    if (!scopeSummary.ok)
+        return scopeSummary;
+    const requestedOperation = {
+        category: category.value,
+        operation: operation.value,
+        scopeSummary: scopeSummary.value,
+    };
+    const copied = copyOptionalStrings(requestedOperation, record.value, tool, ['commandId', 'providerToolName', 'targetPath', 'cwd', 'workspaceRoot']);
+    if (!copied.ok)
+        return copied;
+    const targetPaths = readOptionalStringArray(record.value, 'targetPaths', tool);
+    if (!targetPaths.ok)
+        return targetPaths;
+    if (targetPaths.value !== undefined)
+        requestedOperation.targetPaths = targetPaths.value;
+    return { ok: true, value: requestedOperation };
+}
+export function readExplicitRiskAttributes(value, tool) {
+    const record = asRecord(value, tool, 'explicitRequest.riskAttributes must be an object');
+    if (!record.ok)
+        return record;
+    const fields = [
+        'destructive',
+        'privileged',
+        'external',
+        'ambiguous',
+        'secrets',
+        'providerConfigMutation',
+        'globalConfigMutation',
+        'network',
+        'install',
+    ];
+    const unexpected = Object.keys(record.value).find((key) => !fields.includes(key));
+    if (unexpected !== undefined)
+        return validationFailure(`Unexpected explicitRequest.riskAttributes field: ${unexpected}`, tool);
+    const riskAttributes = {};
+    const copied = copyOptionalBooleans(riskAttributes, record.value, tool, fields);
+    if (!copied.ok)
+        return copied;
+    return { ok: true, value: riskAttributes };
+}
+export function readExplicitParser(value, tool) {
+    const record = asRecord(value, tool, 'explicitRequest.parser must be an object');
+    if (!record.ok)
+        return record;
+    const unexpected = Object.keys(record.value).find((key) => !['exact', 'confidence', 'ambiguityReasons', 'expansionReasons'].includes(key));
+    if (unexpected !== undefined)
+        return validationFailure(`Unexpected explicitRequest.parser field: ${unexpected}`, tool);
+    if (typeof record.value.exact !== 'boolean')
+        return validationFailure('explicitRequest.parser.exact must be a boolean', tool);
+    const parser = { exact: record.value.exact };
+    const confidence = readOptionalOneOf(record.value, 'confidence', ['high', 'medium', 'low'], tool);
+    if (!confidence.ok)
+        return confidence;
+    if (confidence.value !== undefined)
+        parser.confidence = confidence.value;
+    const ambiguityReasons = readOptionalStringArray(record.value, 'ambiguityReasons', tool);
+    if (!ambiguityReasons.ok)
+        return ambiguityReasons;
+    if (ambiguityReasons.value !== undefined)
+        parser.ambiguityReasons = ambiguityReasons.value;
+    const expansionReasons = readOptionalStringArray(record.value, 'expansionReasons', tool);
+    if (!expansionReasons.ok)
+        return expansionReasons;
+    if (expansionReasons.value !== undefined)
+        parser.expansionReasons = expansionReasons.value;
+    return { ok: true, value: parser };
+}
+export function validIsoTimestamp(value) {
+    const timestamp = Date.parse(value);
+    return Number.isFinite(timestamp) && new Date(timestamp).toISOString() === value;
+}
+export function validateRunTaskGrantCreateInput(input, tool) {
+    const record = inputRecord(input, tool, [
+        'runId',
+        'agentId',
+        'taskFingerprint',
+        'categories',
+        'externalRoots',
+        'cwdPatterns',
+        'commandPolicy',
+        'expiresAt',
+        'maxUses',
+        'createdBy',
+        'creationReason',
+        'approvedScopeSummary',
+    ]);
+    if (!record.ok)
+        return record;
+    const result = {};
+    const copied = copyRequiredStrings(result, record.value, tool, [
+        'runId',
+        'agentId',
+        'taskFingerprint',
+        'expiresAt',
+        'creationReason',
+        'approvedScopeSummary',
+    ]);
+    if (!copied.ok)
+        return copied;
+    const categories = readRequiredOneOfArray(record.value, 'categories', taskGrantCategories, tool);
+    if (!categories.ok)
+        return categories;
+    result.categories = categories.value;
+    const externalRoots = readRequiredStringArray(record.value, 'externalRoots', tool);
+    if (!externalRoots.ok)
+        return externalRoots;
+    result.externalRoots = externalRoots.value;
+    const cwdPatterns = readOptionalStringArray(record.value, 'cwdPatterns', tool);
+    if (!cwdPatterns.ok)
+        return cwdPatterns;
+    if (cwdPatterns.value !== undefined)
+        result.cwdPatterns = cwdPatterns.value;
+    const commandPolicy = readTaskGrantCommandPolicy(record.value.commandPolicy, tool);
+    if (!commandPolicy.ok)
+        return commandPolicy;
+    result.commandPolicy = commandPolicy.value;
+    const createdBy = readTaskGrantActor(record.value.createdBy, tool, ['human']);
+    if (!createdBy.ok)
+        return createdBy;
+    result.createdBy = createdBy.value;
+    if (typeof record.value.maxUses !== 'number' || !Number.isSafeInteger(record.value.maxUses) || record.value.maxUses < 1)
+        return validationFailure('maxUses must be a positive safe integer', tool);
+    result.maxUses = record.value.maxUses;
+    const expiresAt = Date.parse(result.expiresAt ?? '');
+    if (!Number.isFinite(expiresAt) || new Date(expiresAt).toISOString() !== result.expiresAt)
+        return validationFailure('expiresAt must be a valid ISO date', tool);
+    const expiryDelta = expiresAt - Date.now();
+    if (expiryDelta <= 0)
+        return validationFailure('expiresAt must be in the future', tool);
+    if (expiryDelta > 24 * 60 * 60 * 1000)
+        return validationFailure('expiresAt must be within 24 hours', tool);
+    return { ok: true, value: result };
+}
+export function validateRunTaskGrantListInput(input, tool) {
+    const record = inputRecord(input, tool, ['runId', 'agentId', 'status', 'limit']);
+    if (!record.ok)
+        return record;
+    const result = {};
+    const copied = copyOptionalStrings(result, record.value, tool, ['runId', 'agentId']);
+    if (!copied.ok)
+        return copied;
+    const status = readOptionalOneOf(record.value, 'status', taskGrantStatuses, tool);
+    if (!status.ok)
+        return status;
+    if (status.value !== undefined)
+        result.status = status.value;
+    const limit = readOptionalBoundedLimit(record.value, tool);
+    if (!limit.ok)
+        return limit;
+    if (limit.value !== undefined)
+        result.limit = limit.value;
+    return { ok: true, value: result };
+}
+export function validateRunTaskGrantGetInput(input, tool) {
+    const record = inputRecord(input, tool, ['grantId']);
+    if (!record.ok)
+        return record;
+    const grantId = readNonEmptyString(record.value, 'grantId', tool);
+    if (!grantId.ok)
+        return grantId;
+    return { ok: true, value: { grantId: grantId.value } };
+}
+export function validateRunTaskGrantRevokeInput(input, tool) {
+    const record = inputRecord(input, tool, ['grantId', 'actor', 'reason']);
+    if (!record.ok)
+        return record;
+    const grantId = readNonEmptyString(record.value, 'grantId', tool);
+    if (!grantId.ok)
+        return grantId;
+    const reason = readNonEmptyString(record.value, 'reason', tool);
+    if (!reason.ok)
+        return reason;
+    const actor = readTaskGrantActor(record.value.actor, tool, ['human', 'system']);
+    if (!actor.ok)
+        return actor;
+    return { ok: true, value: { grantId: grantId.value, actor: actor.value, reason: reason.value } };
+}
+export function validateRunTaskGrantPreviewMatchInput(input, tool) {
+    const record = inputRecord(input, tool, ['runId', 'agentId', 'taskFingerprint', 'category', 'operation', 'workspaceRoot', 'cwd', 'targetPaths']);
+    if (!record.ok)
+        return record;
+    const runId = readNonEmptyString(record.value, 'runId', tool);
+    if (!runId.ok)
+        return runId;
+    const taskFingerprint = readNonEmptyString(record.value, 'taskFingerprint', tool);
+    if (!taskFingerprint.ok)
+        return taskFingerprint;
+    const category = readRequiredOneOf(record.value, 'category', permissionCategories, tool);
+    if (!category.ok)
+        return category;
+    const operation = readNonEmptyString(record.value, 'operation', tool);
+    if (!operation.ok)
+        return operation;
+    const cwd = readNonEmptyString(record.value, 'cwd', tool);
+    if (!cwd.ok)
+        return cwd;
+    const result = {
+        runId: runId.value,
+        taskFingerprint: taskFingerprint.value,
+        category: category.value,
+        operation: operation.value,
+        cwd: cwd.value,
+    };
+    const copied = copyOptionalStrings(result, record.value, tool, ['agentId', 'workspaceRoot']);
+    if (!copied.ok)
+        return copied;
+    const targetPaths = readOptionalStringArray(record.value, 'targetPaths', tool);
+    if (!targetPaths.ok)
+        return targetPaths;
+    if (targetPaths.value !== undefined)
+        result.targetPaths = targetPaths.value;
+    return { ok: true, value: result };
+}
+export function validateRunStartInput(input, tool) {
+    const record = inputRecord(input, tool, ['project', 'userIntent', 'workflow', 'phase', 'selectedAgentId', 'providerAdapter', 'model']);
+    if (!record.ok)
+        return record;
+    const result = {};
+    const copied = copyRequiredStrings(result, record.value, tool, ['project', 'userIntent', 'workflow', 'phase', 'selectedAgentId', 'providerAdapter', 'model']);
+    if (!copied.ok)
+        return copied;
+    return { ok: true, value: result };
+}
+export function validateRunCheckpointInput(input, tool) {
+    const record = inputRecord(input, tool, ['runId', 'label', 'state']);
+    if (!record.ok)
+        return record;
+    const runId = readNonEmptyString(record.value, 'runId', tool);
+    if (!runId.ok)
+        return runId;
+    const label = readNonEmptyString(record.value, 'label', tool);
+    if (!label.ok)
+        return label;
+    const state = readJsonValue(record.value, 'state', tool);
+    if (!state.ok)
+        return state;
+    return { ok: true, value: { runId: runId.value, label: label.value, state: state.value } };
+}
+export function validateRunFinalizeInput(input, tool) {
+    const record = inputRecord(input, tool, ['runId', 'status', 'outcome', 'outcomeReason']);
+    if (!record.ok)
+        return record;
+    const runId = readNonEmptyString(record.value, 'runId', tool);
+    if (!runId.ok)
+        return runId;
+    const status = readRequiredOneOf(record.value, 'status', finalRunStatuses, tool);
+    if (!status.ok)
+        return status;
+    const outcome = readRequiredOneOf(record.value, 'outcome', runOutcomes, tool);
+    if (!outcome.ok)
+        return outcome;
+    const result = { runId: runId.value, status: status.value, outcome: outcome.value };
+    const copied = copyOptionalStrings(result, record.value, tool, ['outcomeReason']);
+    if (!copied.ok)
+        return copied;
+    return { ok: true, value: result };
+}
+export function validateRunResumeCandidatesInput(input, tool) {
+    const record = inputRecord(input, tool, ['project', 'limit']);
+    if (!record.ok)
+        return record;
+    const project = readNonEmptyString(record.value, 'project', tool);
+    if (!project.ok)
+        return project;
+    const result = { project: project.value };
+    if (record.value.limit !== undefined) {
+        const limit = readBoundedLimit(record.value, tool);
+        if (!limit.ok)
+            return limit;
+        result.limit = limit.value;
+    }
+    return { ok: true, value: result };
+}
+export function validateRunResumeInspectInput(input, tool) {
+    const record = inputRecord(input, tool, ['runId']);
+    if (!record.ok)
+        return record;
+    const runId = readNonEmptyString(record.value, 'runId', tool);
+    if (!runId.ok)
+        return runId;
+    return { ok: true, value: { runId: runId.value } };
+}
+export function validateRunResumeGateInput(input, tool) {
+    const record = inputRecord(input, tool, ['approvalId', 'policy']);
+    if (!record.ok)
+        return record;
+    const approvalId = readNonEmptyString(record.value, 'approvalId', tool);
+    if (!approvalId.ok)
+        return approvalId;
+    const result = { approvalId: approvalId.value };
+    if (record.value.policy !== undefined) {
+        const policy = parseOperationRetryPolicy(record.value.policy);
+        if (!policy.ok)
+            return validationFailure(policy.errors.join('; '), tool);
+        result.policy = policy.policy;
+    }
+    return { ok: true, value: result };
+}