pi-subagents 0.69.0 → 0.70.1

package/src/api/agents.ts

@@ -1,12 +0,0 @@
-import type { RegisterRuntimeAgentInput, RuntimeAgentDefinition, RuntimeAgentRegistration } from "../agents/runtime-agent-registry.ts";
-export { registerRuntimeAgent as registerAgent } from "../agents/runtime-agent-registry.ts";
-export {
-	RUNTIME_AGENT_REGISTER_EVENT,
-	RUNTIME_AGENT_REGISTER_VERSION,
-	registerAgentViaEvents,
-	type RegisterRuntimeAgentViaEventsInput,
-	type RuntimeAgentRegistrationRequest,
-	type RuntimeAgentRegistrationResult,
-} from "../agents/runtime-agent-events.ts";
-
-export type { RegisterRuntimeAgentInput, RuntimeAgentDefinition, RuntimeAgentRegistration };

package/src/api/background-work.ts

@@ -1,206 +0,0 @@
-export const BACKGROUND_WORK_PROTOCOL_VERSION = 1;
-export const BACKGROUND_WORK_REGISTRY_KEY = "pi-subagents.background-work.v1";
-
-const MAX_PROVIDER_NAME_LENGTH = 128;
-const MAX_PROVIDERS = 100;
-const MAX_ITEM_ID_LENGTH = 256;
-/**
- * A Pi session id is the session file path, which routinely exceeds a short
- * identity budget in nested worktrees, so it is bounded like the other paths.
- */
-const MAX_SESSION_ID_LENGTH = 4_096;
-const MAX_WAKE_CHANNEL_LENGTH = 256;
-const MAX_ITEMS_PER_PROVIDER = 10_000;
-
-export interface BackgroundWorkItem {
-	id: string;
-	sessionId: string;
-}
-
-export interface BackgroundWorkReconcileContext {
-	sessionId: string;
-	nowMs: number;
-}
-
-export interface BackgroundWorkListContext {
-	sessionId: string;
-	nowMs: number;
-}
-
-export interface BackgroundWorkProvider {
-	name: string;
-	listActiveWork(context?: BackgroundWorkListContext): readonly BackgroundWorkItem[];
-	wakeChannels?: readonly string[];
-	reconcile?(context: BackgroundWorkReconcileContext): void;
-}
-
-export interface RegisteredBackgroundWorkItem extends BackgroundWorkItem {
-	provider: string;
-}
-
-export interface BackgroundWorkSnapshot {
-	providers: readonly string[];
-	items: readonly RegisteredBackgroundWorkItem[];
-}
-
-interface BackgroundWorkRegistry {
-	version: typeof BACKGROUND_WORK_PROTOCOL_VERSION;
-	providers: Map<string, BackgroundWorkProvider>;
-}
-
-function registry(): BackgroundWorkRegistry {
-	const key = Symbol.for(BACKGROUND_WORK_REGISTRY_KEY);
-	const globalObject = globalThis as Record<PropertyKey, unknown>;
-	const existing = globalObject[key];
-	if (existing === undefined) {
-		const created: BackgroundWorkRegistry = {
-			version: BACKGROUND_WORK_PROTOCOL_VERSION,
-			providers: new Map(),
-		};
-		globalObject[key] = created;
-		return created;
-	}
-	if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
-		throw new Error(`Malformed background-work registry at Symbol.for("${BACKGROUND_WORK_REGISTRY_KEY}").`);
-	}
-	const candidate = existing as Partial<BackgroundWorkRegistry>;
-	if (candidate.version !== BACKGROUND_WORK_PROTOCOL_VERSION || !(candidate.providers instanceof Map)) {
-		throw new Error(`Unsupported background-work registry at Symbol.for("${BACKGROUND_WORK_REGISTRY_KEY}").`);
-	}
-	return candidate as BackgroundWorkRegistry;
-}
-
-function validateString(value: unknown, field: string, maxLength: number): string {
-	if (typeof value !== "string" || value.length === 0 || value.trim() !== value) {
-		throw new Error(`${field} must be a non-empty string without leading or trailing whitespace.`);
-	}
-	if (value.length > maxLength) throw new Error(`${field} must be at most ${maxLength} characters.`);
-	if (value.includes("\0")) throw new Error(`${field} must not contain NUL characters.`);
-	return value;
-}
-
-function validateProvider(value: unknown): BackgroundWorkProvider {
-	if (!value || typeof value !== "object" || Array.isArray(value)) {
-		throw new Error("Background-work provider must be an object.");
-	}
-	const provider = value as Record<string, unknown>;
-	const unknownFields = Object.keys(provider).filter((key) => !["name", "listActiveWork", "wakeChannels", "reconcile"].includes(key));
-	if (unknownFields.length > 0) throw new Error(`Background-work provider has unknown fields: ${unknownFields.join(", ")}.`);
-	const name = validateString(provider.name, "Background-work provider name", MAX_PROVIDER_NAME_LENGTH);
-	if (typeof provider.listActiveWork !== "function") {
-		throw new Error(`Background-work provider '${name}' must expose listActiveWork().`);
-	}
-	if (provider.reconcile !== undefined && typeof provider.reconcile !== "function") {
-		throw new Error(`Background-work provider '${name}' reconcile must be a function when provided.`);
-	}
-	if (provider.wakeChannels !== undefined) {
-		if (!Array.isArray(provider.wakeChannels)) {
-			throw new Error(`Background-work provider '${name}' wakeChannels must be an array when provided.`);
-		}
-		const channels = provider.wakeChannels.map((channel, index) =>
-			validateString(channel, `Background-work provider '${name}' wakeChannels[${index}]`, MAX_WAKE_CHANNEL_LENGTH));
-		if (new Set(channels).size !== channels.length) {
-			throw new Error(`Background-work provider '${name}' wakeChannels must not contain duplicates.`);
-		}
-	}
-	return value as BackgroundWorkProvider;
-}
-
-function validateItem(provider: string, value: unknown, index: number): BackgroundWorkItem {
-	if (!value || typeof value !== "object" || Array.isArray(value)) {
-		throw new Error(`Background-work provider '${provider}' item ${index} must be an object.`);
-	}
-	const item = value as Record<string, unknown>;
-	const unknownFields = Object.keys(item).filter((key) => key !== "id" && key !== "sessionId");
-	if (unknownFields.length > 0) {
-		throw new Error(`Background-work provider '${provider}' item ${index} has unknown fields: ${unknownFields.join(", ")}.`);
-	}
-	return {
-		id: validateString(item.id, `Background-work provider '${provider}' item ${index} id`, MAX_ITEM_ID_LENGTH),
-		sessionId: validateString(item.sessionId, `Background-work provider '${provider}' item ${index} sessionId`, MAX_SESSION_ID_LENGTH),
-	};
-}
-
-/**
- * Register or replace one process-local background-work provider. The returned
- * disposer only removes this exact registration, so an old extension reload
- * cannot unregister its replacement.
- */
-export function registerBackgroundWorkProvider(provider: BackgroundWorkProvider): () => void {
-	const validated = validateProvider(provider);
-	const current = registry();
-	if (!current.providers.has(validated.name) && current.providers.size >= MAX_PROVIDERS) {
-		throw new Error(`Background-work registry supports at most ${MAX_PROVIDERS} providers.`);
-	}
-	current.providers.set(validated.name, validated);
-	return () => {
-		if (current.providers.get(validated.name) === validated) current.providers.delete(validated.name);
-	};
-}
-
-export function listBackgroundWorkProviders(): readonly BackgroundWorkProvider[] {
-	const current = registry();
-	if (current.providers.size > MAX_PROVIDERS) throw new Error(`Background-work registry contains more than ${MAX_PROVIDERS} providers.`);
-	const providers: BackgroundWorkProvider[] = [];
-	for (const [key, value] of current.providers) {
-		const provider = validateProvider(value);
-		if (key !== provider.name) throw new Error(`Background-work registry key '${key}' does not match provider name '${provider.name}'.`);
-		providers.push(provider);
-	}
-	return providers;
-}
-
-/** Read validated provider wake channels without reconciling or listing work. */
-export function listBackgroundWorkWakeChannels(): readonly string[] {
-	const channels = new Set<string>();
-	for (const provider of listBackgroundWorkProviders()) {
-		for (const channel of provider.wakeChannels ?? []) channels.add(channel);
-	}
-	return [...channels];
-}
-
-/** Reconcile and snapshot active provider work owned by one exact Pi session. */
-export function snapshotBackgroundWork(sessionId: string, nowMs = Date.now()): BackgroundWorkSnapshot {
-	validateString(sessionId, "Background-work snapshot sessionId", MAX_SESSION_ID_LENGTH);
-	const providers = listBackgroundWorkProviders();
-	const items: RegisteredBackgroundWorkItem[] = [];
-	const identities = new Set<string>();
-	for (const provider of providers) {
-		try {
-			provider.reconcile?.({ sessionId, nowMs });
-		} catch (error) {
-			throw new Error(
-				`Background-work provider '${provider.name}' reconcile failed: ${error instanceof Error ? error.message : String(error)}`,
-				{ cause: error },
-			);
-		}
-		let active: readonly BackgroundWorkItem[];
-		try {
-			active = provider.listActiveWork({ sessionId, nowMs });
-		} catch (error) {
-			throw new Error(
-				`Background-work provider '${provider.name}' listActiveWork failed: ${error instanceof Error ? error.message : String(error)}`,
-				{ cause: error },
-			);
-		}
-		if (!Array.isArray(active)) {
-			throw new Error(`Background-work provider '${provider.name}' listActiveWork() must return an array.`);
-		}
-		if (active.length > MAX_ITEMS_PER_PROVIDER) {
-			throw new Error(`Background-work provider '${provider.name}' returned ${active.length} items; maximum is ${MAX_ITEMS_PER_PROVIDER}.`);
-		}
-		active.forEach((value, index) => {
-			const item = validateItem(provider.name, value, index);
-			const identity = `${provider.name}\0${item.sessionId}\0${item.id}`;
-			if (identities.has(identity)) {
-				throw new Error(`Background-work provider '${provider.name}' returned duplicate item '${item.id}' for session '${item.sessionId}'.`);
-			}
-			identities.add(identity);
-			if (item.sessionId === sessionId) items.push({ provider: provider.name, ...item });
-		});
-	}
-	return {
-		providers: providers.map((provider) => provider.name),
-		items,
-	};
-}

package/src/api/capability-ceiling.ts

@@ -1,16 +0,0 @@
-export {
-	SUBAGENT_CAPABILITY_CEILING_REGISTRY_KEY,
-	SUBAGENT_CAPABILITY_CEILING_VERSION,
-	decodeSubagentCapabilityCeiling,
-	encodeSubagentCapabilityCeiling,
-	intersectSubagentCapabilityCeilings,
-	parseSubagentCapabilityCeiling,
-	registerSubagentCapabilityCeiling,
-	resolveCurrentSubagentCapabilityCeiling,
-	resolveSubagentCapabilityCeiling,
-	type RegisterSubagentCapabilityCeilingOptions,
-	type ResolvedSubagentCapabilityCeiling,
-	type SubagentCapabilityCeiling,
-	type SubagentCapabilityCeilingHandle,
-	type SubagentCapabilityAudit,
-} from "../runs/shared/capability-ceiling.ts";

package/src/api/child-tool-plan.ts

@@ -1,5 +0,0 @@
-export {
-	resolvePiLaunchToolPlan,
-	type PiLaunchToolPlan,
-	type ResolvePiLaunchToolPlanInput,
-} from "../runs/shared/child-tool-plan.ts";

package/src/api/control-channel.ts

@@ -1,4 +0,0 @@
-export {
-	requestAsyncStop,
-	type StopRequest,
-} from "../runs/background/control-channel.ts";

package/src/api/delegation.ts

@@ -1,116 +0,0 @@
-import type { IntercomBridgeConfig } from "../shared/types.ts";
-
-// This is the established extension-to-extension transport. The structured
-// delegation API intentionally reuses it instead of adding a second event
-// protocol. Unstructured legacy direct payloads are rejected.
-export const SUBAGENT_DELEGATION_REQUEST_EVENT = "prompt-template:subagent:request";
-export const SUBAGENT_DELEGATION_STARTED_EVENT = "prompt-template:subagent:started";
-export const SUBAGENT_DELEGATION_UPDATE_EVENT = "prompt-template:subagent:update";
-export const SUBAGENT_DELEGATION_RESPONSE_EVENT = "prompt-template:subagent:response";
-export const SUBAGENT_DELEGATION_CANCEL_EVENT = "prompt-template:subagent:cancel";
-
-export interface SubagentDelegationToolBudget {
-	soft?: number;
-	hard: number;
-	block?: string[] | "*";
-}
-
-export type SubagentDelegationJsonSchemaObject = Record<string, unknown>;
-
-export type SubagentDelegationThinking = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
-
-export type SubagentDelegationResultRequest =
-	| { kind: "text" }
-	| { kind: "structured"; schema: SubagentDelegationJsonSchemaObject };
-
-export interface SubagentDelegationRequest {
-	requestId: string;
-	ownerRunId: string;
-	nodeId: string;
-	agent: string;
-	task: string;
-	context: "fresh" | "fork";
-	cwd: string;
-	model?: string;
-	thinking?: SubagentDelegationThinking;
-	timeoutMs?: number;
-	toolBudget?: SubagentDelegationToolBudget;
-	skill?: string | string[] | boolean;
-	artifacts?: boolean;
-	/** Per-launch bridge config; replaces the global `intercomBridge` config. Pass the same value to preflight to compare digests. */
-	intercomBridge?: IntercomBridgeConfig;
-	result: SubagentDelegationResultRequest;
-}
-
-export interface SubagentDelegationStarted {
-	requestId: string;
-	ownerRunId: string;
-	nodeId: string;
-}
-
-export interface SubagentDelegationUpdate extends SubagentDelegationStarted {
-	runId?: string;
-	currentTool?: string;
-	currentToolArgs?: string;
-	recentOutput?: string;
-	recentOutputLines?: string[];
-	recentTools?: Array<{ tool: string; args: string }>;
-	model?: string;
-	toolCount?: number;
-	durationMs?: number;
-	tokens?: number;
-}
-
-export type SubagentDelegationStatus =
-	| "completed"
-	| "failed"
-	| "timed_out"
-	| "cancelled"
-	| "interrupted"
-	| "tool_budget_exhausted"
-	| "structured_output_failed"
-	| "acceptance_failed"
-	| "invalid_request"
-	| "unavailable_context"
-	| "duplicate_node";
-
-export type SubagentDelegationValue =
-	| { kind: "text"; text: string }
-	| { kind: "structured"; value: unknown };
-
-export interface SubagentDelegationUsage {
-	input: number;
-	output: number;
-	cacheRead: number;
-	cacheWrite: number;
-	cost: number;
-	turns: number;
-	toolCalls: number;
-	durationMs: number;
-}
-
-export interface SubagentDelegationTerminalResponse extends SubagentDelegationStarted {
-	status: Exclude<SubagentDelegationStatus, "invalid_request">;
-	error?: string;
-	runId?: string;
-	agent?: string;
-	model?: string;
-	thinking?: string;
-	exitCode?: number;
-	launchContractDigest?: string;
-	result?: SubagentDelegationValue;
-	usage?: SubagentDelegationUsage;
-}
-
-/** A malformed structured request can only be correlated by the valid identity fields it supplied. */
-export interface SubagentDelegationInvalidResponse {
-	requestId: string;
-	ownerRunId?: string;
-	nodeId?: string;
-	status: "invalid_request";
-	error?: string;
-}
-
-export type SubagentDelegationResponse = SubagentDelegationTerminalResponse | SubagentDelegationInvalidResponse;
-
-export interface SubagentDelegationCancel extends SubagentDelegationStarted {}

package/src/api/external-job-provider.ts

@@ -1,195 +0,0 @@
-export const EXTERNAL_JOB_PROVIDER_PROTOCOL_VERSION = 1;
-export const EXTERNAL_JOB_PROVIDER_REGISTRY_KEY = "pi-subagents.external-job-providers.v1";
-
-const MAX_PROVIDER_NAME_LENGTH = 128;
-const MAX_PROVIDERS = 100;
-const MAX_JOB_ID_LENGTH = 256;
-const MAX_FAILURE_CODE_LENGTH = 128;
-const MAX_FAILURE_MESSAGE_LENGTH = 4_096;
-const MAX_URL_LENGTH = 4_096;
-
-export type ExternalJobState = "queued" | "running" | "completed" | "failed" | "stopped" | "blocked";
-export type ExternalJobOperation = "start" | "follow-up" | "status" | "result" | "reattach";
-
-export type ExternalJobOptions = Record<string, unknown>;
-
-export interface ExternalJobStartInput {
-	prompt: string;
-	promptDigest: string;
-	cwd: string;
-	runId: string;
-	stepIndex: number;
-	agent: string;
-	options: ExternalJobOptions;
-	sessionId?: string;
-}
-
-export interface ExternalJobFollowUpInput extends ExternalJobStartInput {
-	sourceRunId: string;
-	sourceStepIndex: number;
-	parentProviderJobId: string;
-	requestId: string;
-	requestDigest: string;
-}
-
-export interface ExternalJobHandle {
-	providerJobId: string;
-	state: ExternalJobState;
-	handleUrl?: string;
-	conversationUrl?: string;
-	failureCode?: string;
-	failureMessage?: string;
-	blockingJobId?: string;
-}
-
-export interface ExternalJobResult extends ExternalJobHandle {
-	output?: string;
-	artifactPath?: string;
-}
-
-export interface ExternalJobProvider {
-	name: string;
-	start(input: ExternalJobStartInput): Promise<ExternalJobHandle> | ExternalJobHandle;
-	followUp?(input: ExternalJobFollowUpInput): Promise<ExternalJobHandle> | ExternalJobHandle;
-	status(providerJobId: string): Promise<ExternalJobHandle> | ExternalJobHandle;
-	result(providerJobId: string): Promise<ExternalJobResult> | ExternalJobResult;
-	reattach(providerJobId: string): Promise<ExternalJobHandle> | ExternalJobHandle;
-}
-
-export class ExternalJobProviderError extends Error {
-	readonly code: string;
-	readonly blockingJobId?: string;
-
-	constructor(message: string, options: { code: string; blockingJobId?: string; cause?: unknown }) {
-		super(message, options.cause === undefined ? undefined : { cause: options.cause });
-		this.name = "ExternalJobProviderError";
-		this.code = options.code;
-		this.blockingJobId = options.blockingJobId;
-	}
-}
-
-interface ExternalJobProviderRegistry {
-	version: typeof EXTERNAL_JOB_PROVIDER_PROTOCOL_VERSION;
-	providers: Map<string, ExternalJobProvider>;
-}
-
-function registry(): ExternalJobProviderRegistry {
-	const key = Symbol.for(EXTERNAL_JOB_PROVIDER_REGISTRY_KEY);
-	const globalObject = globalThis as Record<PropertyKey, unknown>;
-	const existing = globalObject[key];
-	if (existing === undefined) {
-		const created: ExternalJobProviderRegistry = {
-			version: EXTERNAL_JOB_PROVIDER_PROTOCOL_VERSION,
-			providers: new Map(),
-		};
-		globalObject[key] = created;
-		return created;
-	}
-	if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
-		throw new Error(`Malformed external-job provider registry at Symbol.for("${EXTERNAL_JOB_PROVIDER_REGISTRY_KEY}").`);
-	}
-	const candidate = existing as Partial<ExternalJobProviderRegistry>;
-	if (candidate.version !== EXTERNAL_JOB_PROVIDER_PROTOCOL_VERSION || !(candidate.providers instanceof Map)) {
-		throw new Error(`Unsupported external-job provider registry at Symbol.for("${EXTERNAL_JOB_PROVIDER_REGISTRY_KEY}").`);
-	}
-	return candidate as ExternalJobProviderRegistry;
-}
-
-function validateString(value: unknown, field: string, maxLength: number): string {
-	if (typeof value !== "string" || value.length === 0 || value.trim() !== value) {
-		throw new Error(`${field} must be a non-empty string without leading or trailing whitespace.`);
-	}
-	if (value.length > maxLength) throw new Error(`${field} must be at most ${maxLength} characters.`);
-	if (value.includes("\0")) throw new Error(`${field} must not contain NUL characters.`);
-	return value;
-}
-
-function validateOptionalString(value: unknown, field: string, maxLength: number): string | undefined {
-	if (value === undefined) return undefined;
-	return validateString(value, field, maxLength);
-}
-
-function validateState(value: unknown, field: string): ExternalJobState {
-	if (value === "queued" || value === "running" || value === "completed" || value === "failed" || value === "stopped" || value === "blocked") return value;
-	throw new Error(`${field} must be queued, running, completed, failed, stopped, or blocked.`);
-}
-
-function validateHandle(provider: string, value: unknown, field: string, extraFields: readonly string[] = []): ExternalJobHandle {
-	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${field} from external-job provider '${provider}' must be an object.`);
-	const handle = value as Record<string, unknown>;
-	const supported = new Set(["providerJobId", "state", "handleUrl", "conversationUrl", "failureCode", "failureMessage", "blockingJobId", ...extraFields]);
-	const unknown = Object.keys(handle).filter((key) => !supported.has(key));
-	if (unknown.length > 0) throw new Error(`${field} from external-job provider '${provider}' has unknown fields: ${unknown.join(", ")}.`);
-	const handleUrl = validateOptionalString(handle.handleUrl, `${field}.handleUrl`, MAX_URL_LENGTH);
-	const conversationUrl = validateOptionalString(handle.conversationUrl, `${field}.conversationUrl`, MAX_URL_LENGTH);
-	const failureCode = validateOptionalString(handle.failureCode, `${field}.failureCode`, MAX_FAILURE_CODE_LENGTH);
-	const failureMessage = validateOptionalString(handle.failureMessage, `${field}.failureMessage`, MAX_FAILURE_MESSAGE_LENGTH);
-	const blockingJobId = validateOptionalString(handle.blockingJobId, `${field}.blockingJobId`, MAX_JOB_ID_LENGTH);
-	return {
-		providerJobId: validateString(handle.providerJobId, `${field}.providerJobId`, MAX_JOB_ID_LENGTH),
-		state: validateState(handle.state, `${field}.state`),
-		...(handleUrl ? { handleUrl } : {}),
-		...(conversationUrl ? { conversationUrl } : {}),
-		...(failureCode ? { failureCode } : {}),
-		...(failureMessage ? { failureMessage } : {}),
-		...(blockingJobId ? { blockingJobId } : {}),
-	};
-}
-
-export function validateExternalJobHandle(provider: string, value: unknown, field = "External-job handle"): ExternalJobHandle {
-	return validateHandle(provider, value, field);
-}
-
-export function validateExternalJobResult(provider: string, value: unknown, field = "External-job result"): ExternalJobResult {
-	const result = validateHandle(provider, value, field, ["output", "artifactPath"]) as ExternalJobResult;
-	const record = value as Record<string, unknown>;
-	const output = validateOptionalString(record.output, `${field}.output`, 1024 * 1024);
-	const artifactPath = validateOptionalString(record.artifactPath, `${field}.artifactPath`, MAX_URL_LENGTH);
-	return {
-		...result,
-		...(output !== undefined ? { output } : {}),
-		...(artifactPath !== undefined ? { artifactPath } : {}),
-	};
-}
-
-function validateProvider(value: unknown): ExternalJobProvider {
-	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("External-job provider must be an object.");
-	const provider = value as Record<string, unknown>;
-	// Tolerate extra provider fields (for example kind, wakeChannels, or future
-	// operations) so one evolving provider cannot poison registry reads for all
-	// providers. Payload validation stays strict.
-	const name = validateString(provider.name, "External-job provider name", MAX_PROVIDER_NAME_LENGTH);
-	for (const op of ["start", "status", "result", "reattach"] as const) {
-		if (typeof provider[op] !== "function") throw new Error(`External-job provider '${name}' must expose ${op}().`);
-	}
-	return value as ExternalJobProvider;
-}
-
-export function registerExternalJobProvider(provider: ExternalJobProvider): () => void {
-	const validated = validateProvider(provider);
-	const current = registry();
-	if (!current.providers.has(validated.name) && current.providers.size >= MAX_PROVIDERS) {
-		throw new Error(`External-job provider registry supports at most ${MAX_PROVIDERS} providers.`);
-	}
-	current.providers.set(validated.name, validated);
-	return () => {
-		if (current.providers.get(validated.name) === validated) current.providers.delete(validated.name);
-	};
-}
-
-export function listExternalJobProviders(): readonly ExternalJobProvider[] {
-	const current = registry();
-	if (current.providers.size > MAX_PROVIDERS) throw new Error(`External-job provider registry contains more than ${MAX_PROVIDERS} providers.`);
-	const providers: ExternalJobProvider[] = [];
-	for (const [key, value] of current.providers) {
-		const provider = validateProvider(value);
-		if (key !== provider.name) throw new Error(`External-job provider registry key '${key}' does not match provider name '${provider.name}'.`);
-		providers.push(provider);
-	}
-	return providers;
-}
-
-export function getExternalJobProvider(name: string): ExternalJobProvider | undefined {
-	const safeName = validateString(name, "External-job provider name", MAX_PROVIDER_NAME_LENGTH);
-	return listExternalJobProviders().find((provider) => provider.name === safeName);
-}