import {
AcpRegistryListProvidersResult,
AcpRegistryOperationError,
AcpRegistryListSessionsResult,
AcpRegistryProbeResult,
type AcpRegistryProbeAuthMethod,
type AcpRegistryProbeModel,
type AcpRegistryUrlAuthAction,
type ProviderInstanceId,
type ServerProviderSkill,
type ServerProviderSlashCommand,
} from "@t3tools/contracts";
import { AcpRegistrySettings } from "../settings.ts";
import * as SecureRandom from "effect/crypto/SecureRandom";
import * as Deferred from "effect/Deferred";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Ref from "effect/Ref";
import * as Result from "effect/Result";
import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
import type * as EffectAcpErrors from "effect-acp/errors";
import type * as EffectAcpSchema from "effect-acp/compat";
import * as PtyAdapter from "@t3tools/shared/PtyAdapter";
import * as AcpRegistrySupport from "./AcpRegistrySupport.ts";
import {
findModelConfigOption,
parseSessionModeState,
} from "@t3tools/provider-acp/server/runtimeModel";
import {
acpProviderOptionDescriptors,
flattenSelectChoices,
} from "@t3tools/provider-acp/server/sessionConfig";
import * as AcpRegistryRuntimeCoordinator from "./AcpRegistryRuntimeCoordinator.ts";
import * as AcpSessionRuntime from "@t3tools/provider-acp/server/AcpSessionRuntime";
const MAX_AUTH_METHODS = 32;
const MAX_MODELS = 256;
const MAX_ID_LENGTH = 128;
const MAX_NAME_LENGTH = 160;
const MAX_DESCRIPTION_LENGTH = 1_024;
const MAX_COMMANDS = 128;
const MAX_COMMAND_LINE_LENGTH = 2_048;
const PROBE_TIMEOUT_SECONDS = 60;
const PROBE_TIMEOUT = `${PROBE_TIMEOUT_SECONDS} seconds`;
const COMMAND_ADVERTISEMENT_GRACE = "500 millis";
const boundedText = (value: string, maximumLength: number): string =>
value.trim().slice(0, maximumLength);
const boundedOpaqueValue = (value: string, maximumLength: number): string | undefined =>
value.length > 0 && value === value.trim() && value.length <= maximumLength ? value : undefined;
export function normalizeAcpRegistryWebUrl(value: string): string | undefined {
if (value.length > 2_048 || !URL.canParse(value)) return undefined;
const url = new URL(value);
return url.protocol === "https:" || url.protocol === "http:" ? url.href : undefined;
}
function normalizedModel(id: string, candidate: AcpRegistryProbeModel): AcpRegistryProbeModel {
return {
id,
name: boundedText(candidate.name, MAX_NAME_LENGTH) || id,
description:
candidate.description === null
? null
: boundedText(candidate.description, MAX_DESCRIPTION_LENGTH) || null,
};
}
function normalizeModels(
candidates: ReadonlyArray<AcpRegistryProbeModel>,
currentModelId: string | null,
): ReadonlyArray<AcpRegistryProbeModel> {
const seen = new Set<string>();
const models: Array<AcpRegistryProbeModel> = [];
for (const candidate of candidates) {
if (models.length === MAX_MODELS) break;
const id = boundedOpaqueValue(candidate.id, MAX_ID_LENGTH);
if (id === undefined || seen.has(id)) continue;
seen.add(id);
models.push(normalizedModel(id, candidate));
}
// Keep the running model visible even when its advertised position exceeds the cap.
if (currentModelId !== null && models.length === MAX_MODELS && !seen.has(currentModelId)) {
const current = candidates.find((candidate) => candidate.id === currentModelId);
if (current !== undefined) {
models[MAX_MODELS - 1] = normalizedModel(currentModelId, current);
}
}
return models;
}
export interface AcpRegistryAuthSpawnContext {
readonly command: string;
readonly args: ReadonlyArray<string>;
}
const SHELL_SAFE_TOKEN = /^[A-Za-z0-9_@%+=:,./-]+$/u;
function shellDisplayToken(token: string): string {
return SHELL_SAFE_TOKEN.test(token) ? token : `'${token.replaceAll("'", `'\\''`)}'`;
}
function terminalAuthCommand(
method: Extract<EffectAcpSchema.AuthMethod, { readonly type: "terminal" }>,
spawn: AcpRegistryAuthSpawnContext,
): string | undefined {
const environmentPrefix = Object.entries(method.env ?? {}).map(
([name, value]) => `${name}=${shellDisplayToken(value)}`,
);
const command = [spawn.command, ...spawn.args, ...(method.args ?? [])].map(shellDisplayToken);
const displayCommand = [...environmentPrefix, ...command].join(" ");
return displayCommand.length <= MAX_COMMAND_LINE_LENGTH ? displayCommand : undefined;
}
export function normalizeAcpRegistryAuthMethods(
methods: ReadonlyArray<EffectAcpSchema.AuthMethod> | undefined,
spawn?: AcpRegistryAuthSpawnContext,
): ReadonlyArray<AcpRegistryProbeAuthMethod> {
const normalized: Array<AcpRegistryProbeAuthMethod> = [];
for (const method of methods ?? []) {
const id = boundedOpaqueValue(method.id, MAX_ID_LENGTH);
if (id === undefined) continue;
const type = method.type ?? "agent";
const envVarNames =
type === "env_var" && "vars" in method
? method.vars
.flatMap((variable) => {
const name = boundedOpaqueValue(variable.name, MAX_ID_LENGTH);
return name === undefined ? [] : [name];
})
.slice(0, 16)
: [];
const command =
spawn !== undefined && "type" in method && method.type === "terminal"
? terminalAuthCommand(method, spawn)
: undefined;
const link =
type === "env_var" && "link" in method && method.link
? normalizeAcpRegistryWebUrl(method.link)
: undefined;
normalized.push({
id,
name: boundedText(method.name, MAX_NAME_LENGTH) || id,
description:
method.description == null
? null
: boundedText(method.description, MAX_DESCRIPTION_LENGTH) || null,
type,
...(command === undefined ? {} : { command }),
...(envVarNames.length > 0 ? { envVarNames } : {}),
...(link === undefined ? {} : { link }),
});
if (normalized.length === MAX_AUTH_METHODS) break;
}
return normalized;
}
export interface AcpRegistryAvailableCommands {
readonly slashCommands: ReadonlyArray<ServerProviderSlashCommand>;
readonly skills: ReadonlyArray<ServerProviderSkill>;
}
export interface AcpRegistryLiveConfiguration {
readonly models: ReadonlyArray<AcpRegistryProbeModel>;
readonly currentModelId: string | null;
readonly configOptions: AcpRegistryProbeResult["configOptions"];
}
export function normalizeAcpRegistryLiveConfiguration(
configOptions: ReadonlyArray<EffectAcpSchema.SessionConfigOption>,
modeState?: Parameters<typeof acpProviderOptionDescriptors>[0]["modeState"],
modelState?: EffectAcpSchema.SessionModelState | null,
): AcpRegistryLiveConfiguration {
const modelOption = findModelConfigOption(configOptions);
const currentModelId =
modelOption?.type === "select" ? modelOption.currentValue : modelState?.currentModelId;
const candidates =
modelOption === undefined
? (modelState?.availableModels ?? []).map((model) => ({
id: model.modelId,
name: model.name,
description: model.description ?? null,
}))
: flattenSelectChoices(modelOption.options).map((model) => ({
id: model.value,
name: model.name,
description: model.description ?? null,
}));
const boundedCurrentModelId =
currentModelId === undefined
? null
: (boundedOpaqueValue(currentModelId, MAX_ID_LENGTH) ?? null);
const models = normalizeModels(candidates, boundedCurrentModelId);
return {
models,
currentModelId: models.some((model) => model.id === boundedCurrentModelId)
? boundedCurrentModelId
: null,
configOptions: acpProviderOptionDescriptors({ configOptions, modeState }),
};
}
const emptyAcpRegistryAvailableCommands = (): AcpRegistryAvailableCommands => ({
slashCommands: [],
skills: [],
});
export function normalizeAcpRegistryCommands(
commands: ReadonlyArray<EffectAcpSchema.AvailableCommand>,
): AcpRegistryAvailableCommands {
const seen = new Set<string>();
const slashCommands: Array<ServerProviderSlashCommand> = [];
const skills: Array<ServerProviderSkill> = [];
let accepted = 0;
for (const command of commands) {
const name = boundedOpaqueValue(command.name, MAX_ID_LENGTH);
if (name === undefined) continue;
const key = name.toLowerCase();
if (seen.has(key)) continue;
seen.add(key);
const description = boundedText(command.description, MAX_DESCRIPTION_LENGTH);
const hint = command.input ? boundedText(command.input.hint, MAX_DESCRIPTION_LENGTH) : "";
if (name.startsWith("$")) {
const skillName = boundedOpaqueValue(name.slice(1), MAX_ID_LENGTH);
if (skillName === undefined) continue;
skills.push({
name: skillName,
...(description ? { description } : {}),
path: `acp://skill/${encodeURIComponent(skillName)}`,
scope: "agent",
enabled: true,
});
} else {
slashCommands.push({
name,
...(description ? { description } : {}),
...(hint ? { input: { hint } } : {}),
});
}
accepted += 1;
if (accepted === MAX_COMMANDS) break;
}
return { slashCommands, skills };
}
export function acpRegistryProbeResult(
instanceId: ProviderInstanceId,
started: AcpSessionRuntime.AcpSessionRuntimeStartResult,
icon: string | null = null,
spawn?: AcpRegistryAuthSpawnContext,
): AcpRegistryProbeResult {
const liveConfiguration = normalizeAcpRegistryLiveConfiguration(
started.sessionSetupResult.configOptions ?? [],
parseSessionModeState(started.sessionSetupResult),
started.sessionSetupResult.models,
);
return AcpRegistryProbeResult.make({
instanceId,
ready: true,
icon,
authMethods: normalizeAcpRegistryAuthMethods(started.initializeResult.authMethods, spawn),
sessionManagement: {
canList: started.initializeResult.agentCapabilities?.sessionCapabilities?.list != null,
canLoad: started.initializeResult.agentCapabilities?.loadSession === true,
canResume: started.initializeResult.agentCapabilities?.sessionCapabilities?.resume != null,
canLogout: started.initializeResult.agentCapabilities?.auth?.logout != null,
canDelete: started.initializeResult.agentCapabilities?.sessionCapabilities?.delete != null,
canConfigureProviders: started.initializeResult.agentCapabilities?.providers != null,
},
...liveConfiguration,
});
}
export function acpRegistryProbeFailure(
error: EffectAcpErrors.AcpError,
authMethods: ReadonlyArray<AcpRegistryProbeAuthMethod> = [],
authAction?: AcpRegistryUrlAuthAction,
): AcpRegistryOperationError {
const detail = error._tag === "AcpTransportError" && error.detail ? error.detail : error.message;
const authenticationFailed =
(error._tag === "AcpRequestError" && error.code === -32000) ||
/\b(?:authenticat(?:e|ed|es|ing|ion)|credentials?|log(?:[\s-]+)?in)\b/iu.test(detail);
return new AcpRegistryOperationError({
reason: authenticationFailed ? "authentication_failed" : "probe_failed",
message: authenticationFailed
? "The ACP agent could not complete authentication."
: "The ACP agent could not create a test session.",
cause: error,
...(authMethods.length > 0 ? { authMethods } : {}),
...(authAction === undefined ? {} : { authAction }),
});
}
export interface AcpRegistryConfigurationProbeInput {
readonly instanceId: ProviderInstanceId;
readonly settings: AcpRegistrySettings;
readonly cwd: string;
readonly environment: NodeJS.ProcessEnv;
}
type AcpRegistryManagementInput = AcpRegistryConfigurationProbeInput;
export interface AcpRegistryConfigurationProbeResult {
readonly probe: AcpRegistryProbeResult;
readonly slashCommands: ReadonlyArray<ServerProviderSlashCommand>;
readonly skills: ReadonlyArray<ServerProviderSkill>;
}
export type AcpRegistryConfigurationProbe<Requirements = never> = (
input: AcpRegistryConfigurationProbeInput,
) => Effect.Effect<AcpRegistryConfigurationProbeResult, AcpRegistryOperationError, Requirements>;
export const probeAcpRegistryConfiguration = Effect.fn("AcpRegistryProbe.probeConfiguration")(
function* (
input: AcpRegistryConfigurationProbeInput,
): Effect.fn.Return<
AcpRegistryConfigurationProbeResult,
AcpRegistryOperationError,
| AcpRegistrySupport.AcpRegistryCatalog
| ChildProcessSpawner.ChildProcessSpawner
| SecureRandom.SecureRandom
> {
const catalog = yield* AcpRegistrySupport.AcpRegistryCatalog;
const childProcessSpawner = yield* ChildProcessSpawner.ChildProcessSpawner;
const random = yield* SecureRandom.SecureRandom;
const pty = yield* Effect.serviceOption(PtyAdapter.PtyAdapter);
const result = yield* Effect.gen(function* () {
// Resolution may install packages; bound it by the probe deadline.
const resolved = yield* catalog
.resolve(input.settings, input.cwd, input.environment)
.pipe(Effect.mapError(AcpRegistrySupport.toAcpRegistryOperationError));
const authMethodsRef = yield* Ref.make<ReadonlyArray<AcpRegistryProbeAuthMethod>>([]);
const authActionRef = yield* Ref.make<AcpRegistryUrlAuthAction | undefined>(undefined);
const runtimeCoordinator = yield* Effect.serviceOption(
AcpRegistryRuntimeCoordinator.AcpRegistryRuntimeCoordinator,
);
const runtimeContext = yield* Layer.build(
AcpSessionRuntime.layer({
spawn: resolved.spawn,
cwd: input.cwd,
clientCapabilities: {
auth: { terminal: Option.isSome(pty) },
elicitation: { url: {} },
fs: { readTextFile: false, writeTextFile: false },
terminal: false,
},
clientInfo: { name: "t3-code-provider-test", version: "0.0.0" },
authenticateOnAuthRequired: false,
onInitialized: (initializeResult) =>
Ref.set(
authMethodsRef,
normalizeAcpRegistryAuthMethods(initializeResult.authMethods, {
command: resolved.spawn.command,
args: resolved.spawn.args,
}),
),
...(input.settings.authMethodId ? { authMethodId: input.settings.authMethodId } : {}),
}).pipe(
Layer.provide(
Layer.mergeAll(
Layer.succeed(ChildProcessSpawner.ChildProcessSpawner, childProcessSpawner),
Layer.succeed(SecureRandom.SecureRandom, random),
),
),
),
);
const runtime = yield* Effect.service(AcpSessionRuntime.AcpSessionRuntime).pipe(
Effect.provide(runtimeContext),
);
const commandsRef = yield* Ref.make<AcpRegistryAvailableCommands>(
emptyAcpRegistryAvailableCommands(),
);
const commandsAdvertised = yield* Deferred.make<void>();
yield* runtime.handleElicitation((request) =>
Effect.gen(function* () {
if (
request.mode !== "url" ||
!("url" in request) ||
!("elicitationId" in request) ||
typeof request.url !== "string" ||
typeof request.elicitationId !== "string"
) {
return { action: "decline" } as const;
}
const url = normalizeAcpRegistryWebUrl(request.url);
const elicitationId = boundedOpaqueValue(request.elicitationId, MAX_ID_LENGTH);
if (url === undefined || elicitationId === undefined) {
return { action: "decline" } as const;
}
const action: AcpRegistryUrlAuthAction = {
elicitationId,
url,
message: boundedText(request.message, MAX_DESCRIPTION_LENGTH),
};
yield* Ref.set(authActionRef, action);
const accepted = yield* Option.match(runtimeCoordinator, {
onNone: () => Effect.succeed(false),
onSome: (coordinator) => coordinator.requestUrlAuthentication(input.instanceId, action),
});
return accepted ? ({ action: "accept" } as const) : ({ action: "decline" } as const);
}),
);
yield* runtime.handleSessionUpdate((notification) => {
const update = notification.update;
return update.sessionUpdate === "available_commands_update"
? Ref.set(commandsRef, normalizeAcpRegistryCommands(update.availableCommands)).pipe(
Effect.andThen(Deferred.succeed(commandsAdvertised, undefined)),
Effect.asVoid,
)
: Effect.void;
});
const startResult = yield* Effect.result(runtime.start());
if (Result.isFailure(startResult)) {
return yield* acpRegistryProbeFailure(
startResult.failure,
yield* Ref.get(authMethodsRef),
yield* Ref.get(authActionRef),
);
}
const started = startResult.success;
yield* Deferred.await(commandsAdvertised).pipe(
Effect.timeoutOption(COMMAND_ADVERTISEMENT_GRACE),
);
return { resolved, started, commands: yield* Ref.get(commandsRef) };
}).pipe(
Effect.scoped,
Effect.timeoutOrElse({
duration: PROBE_TIMEOUT,
orElse: () =>
Effect.fail(
new AcpRegistryOperationError({
reason: "probe_failed",
message: `The ACP agent did not resolve and create a test session within ${PROBE_TIMEOUT_SECONDS} seconds. Package installation or agent startup may be slow; this check retries on the next provider refresh.`,
}),
),
}),
Effect.mapError((error) =>
error._tag === "AcpRegistryOperationError" ? error : acpRegistryProbeFailure(error),
),
);
return {
probe: acpRegistryProbeResult(
input.instanceId,
result.started,
result.resolved.agent?.icon ?? null,
{
command: result.resolved.spawn.command,
args: result.resolved.spawn.args,
},
),
slashCommands: result.commands.slashCommands,
skills: result.commands.skills,
};
},
);
const MANAGEMENT_TIMEOUT = Duration.seconds(60);
const makeAcpRegistryManagementRuntime = Effect.fn("AcpRegistryProbe.makeManagementRuntime")(
function* (input: AcpRegistryManagementInput) {
const catalog = yield* AcpRegistrySupport.AcpRegistryCatalog;
const childProcessSpawner = yield* ChildProcessSpawner.ChildProcessSpawner;
const random = yield* SecureRandom.SecureRandom;
const runtimeCoordinator = yield* Effect.serviceOption(
AcpRegistryRuntimeCoordinator.AcpRegistryRuntimeCoordinator,
);
const resolved = yield* catalog
.resolve(input.settings, input.cwd, input.environment)
.pipe(Effect.mapError(AcpRegistrySupport.toAcpRegistryOperationError));
const runtimeContext = yield* Layer.build(
AcpSessionRuntime.layer({
spawn: resolved.spawn,
cwd: input.cwd,
clientCapabilities: {
auth: { terminal: false },
elicitation: { url: {} },
fs: { readTextFile: false, writeTextFile: false },
terminal: false,
},
clientInfo: { name: "t3-code-session-manager", version: "0.0.0" },
authenticateOnAuthRequired: false,
...(input.settings.authMethodId ? { authMethodId: input.settings.authMethodId } : {}),
}).pipe(
Layer.provide(
Layer.mergeAll(
Layer.succeed(ChildProcessSpawner.ChildProcessSpawner, childProcessSpawner),
Layer.succeed(SecureRandom.SecureRandom, random),
),
),
),
);
const runtime = yield* Effect.service(AcpSessionRuntime.AcpSessionRuntime).pipe(
Effect.provide(runtimeContext),
);
yield* runtime.handleElicitation((request) =>
Effect.gen(function* () {
if (
request.mode !== "url" ||
!("url" in request) ||
!("elicitationId" in request) ||
typeof request.url !== "string" ||
typeof request.elicitationId !== "string"
) {
return { action: "decline" } as const;
}
const url = normalizeAcpRegistryWebUrl(request.url);
const elicitationId = boundedOpaqueValue(request.elicitationId, MAX_ID_LENGTH);
if (url === undefined || elicitationId === undefined) {
return { action: "decline" } as const;
}
const action: AcpRegistryUrlAuthAction = {
elicitationId,
url,
message: boundedText(request.message, MAX_DESCRIPTION_LENGTH),
};
const accepted = yield* Option.match(runtimeCoordinator, {
onNone: () => Effect.succeed(false),
onSome: (coordinator) => coordinator.requestUrlAuthentication(input.instanceId, action),
});
return accepted ? ({ action: "accept" } as const) : ({ action: "decline" } as const);
}),
);
return runtime;
},
);
function managementFailure(
operation:
| "list"
| "delete"
| "providers_list"
| "providers_set"
| "providers_disable"
| "logout",
error: EffectAcpErrors.AcpError | AcpRegistryOperationError,
): AcpRegistryOperationError {
if (error._tag === "AcpRegistryOperationError") return error;
if (error._tag === "AcpRequestError" && error.code === -32601) {
if (operation === "list") {
return new AcpRegistryOperationError({
reason: "session_list_unsupported",
message: "The ACP agent does not advertise session listing.",
cause: error,
});
}
if (operation === "delete") {
return new AcpRegistryOperationError({
reason: "session_delete_unsupported",
message: "The ACP agent does not advertise session deletion.",
cause: error,
});
}
if (operation.startsWith("providers_")) {
return new AcpRegistryOperationError({
reason: "providers_unsupported",
message: "The ACP agent does not advertise provider configuration.",
cause: error,
});
}
return new AcpRegistryOperationError({
reason: "logout_unsupported",
message: "The ACP agent does not advertise logout.",
cause: error,
});
}
const classified = acpRegistryProbeFailure(error);
if (classified.reason === "authentication_failed") return classified;
const failure =
operation === "delete"
? { reason: "session_delete_failed" as const, message: "Could not delete the ACP session." }
: operation === "providers_list"
? { reason: "providers_list_failed" as const, message: "Could not list ACP providers." }
: operation === "providers_set" || operation === "providers_disable"
? {
reason: "provider_configuration_failed" as const,
message: "Could not update the ACP provider configuration.",
}
: undefined;
return failure === undefined
? classified
: new AcpRegistryOperationError({ ...failure, cause: error });
}
export const listAcpRegistrySessions = Effect.fn("AcpRegistryProbe.listSessions")(
function* (input: AcpRegistryManagementInput & { readonly cursor?: string }) {
const runtime = yield* makeAcpRegistryManagementRuntime(input);
const initialized = yield* runtime.initialize();
const listed = yield* runtime.listSessions(input.cursor);
const sessions = listed.sessions.slice(0, 256).flatMap((session) => {
const sessionId = boundedOpaqueValue(session.sessionId, 1_024);
const cwd = boundedOpaqueValue(session.cwd, 4_096);
if (sessionId === undefined || cwd === undefined) return [];
return [
{
sessionId,
cwd,
additionalDirectories: (session.additionalDirectories ?? [])
.flatMap((directory) => {
const normalized = boundedOpaqueValue(directory, 4_096);
return normalized === undefined ? [] : [normalized];
})
.slice(0, 32),
title:
session.title === undefined || session.title === null
? null
: boundedText(session.title, 1_024) || null,
updatedAt:
session.updatedAt === undefined || session.updatedAt === null
? null
: boundedText(session.updatedAt, 128) || null,
importedThreadId: null,
},
];
});
return AcpRegistryListSessionsResult.make({
sessions,
nextCursor:
listed.nextCursor === undefined || listed.nextCursor === null
? null
: boundedText(listed.nextCursor, 2_048) || null,
canLoad: initialized.agentCapabilities?.loadSession === true,
canResume: initialized.agentCapabilities?.sessionCapabilities?.resume != null,
canDelete: initialized.agentCapabilities?.sessionCapabilities?.delete != null,
});
},
(effect) =>
effect.pipe(
Effect.scoped,
Effect.timeoutOrElse({
duration: MANAGEMENT_TIMEOUT,
orElse: () =>
Effect.fail(
new AcpRegistryOperationError({
reason: "probe_failed",
message: "The ACP session list request timed out.",
}),
),
}),
Effect.mapError((error) => managementFailure("list", error)),
),
);
export const deleteAcpRegistrySession = Effect.fn("AcpRegistryProbe.deleteSession")(
function* (input: AcpRegistryManagementInput & { readonly sessionId: string }) {
const runtime = yield* makeAcpRegistryManagementRuntime(input);
yield* runtime.deleteSession(input.sessionId);
},
(effect) =>
effect.pipe(
Effect.scoped,
Effect.timeoutOrElse({
duration: MANAGEMENT_TIMEOUT,
orElse: () =>
Effect.fail(
new AcpRegistryOperationError({
reason: "session_delete_failed",
message: "The ACP session delete request timed out.",
}),
),
}),
Effect.mapError((error) => managementFailure("delete", error)),
),
);
export const listAcpRegistryProviders = Effect.fn("AcpRegistryProbe.listProviders")(
function* (input: AcpRegistryManagementInput) {
const runtime = yield* makeAcpRegistryManagementRuntime(input);
const listed = yield* runtime.listProviders;
return AcpRegistryListProvidersResult.make({
providers: listed.providers.slice(0, 64).flatMap((provider) => {
const providerId = boundedOpaqueValue(provider.providerId, 256);
if (providerId === undefined) return [];
const supported = provider.supported
.flatMap((protocol) => {
const value = boundedOpaqueValue(protocol, 64);
return value === undefined ? [] : [value];
})
.slice(0, 16);
const current = provider.current;
const currentApiType =
current == null ? undefined : boundedOpaqueValue(current.apiType, 64);
const currentBaseUrl =
current == null ? undefined : normalizeAcpRegistryWebUrl(current.baseUrl);
return [
{
providerId,
supported,
required: provider.required,
current:
currentApiType === undefined || currentBaseUrl === undefined
? null
: { apiType: currentApiType, baseUrl: currentBaseUrl },
},
];
}),
});
},
(effect) =>
effect.pipe(
Effect.scoped,
Effect.timeoutOrElse({
duration: MANAGEMENT_TIMEOUT,
orElse: () =>
Effect.fail(
new AcpRegistryOperationError({
reason: "providers_list_failed",
message: "The ACP provider list request timed out.",
}),
),
}),
Effect.mapError((error) => managementFailure("providers_list", error)),
),
);
export const setAcpRegistryProvider = Effect.fn("AcpRegistryProbe.setProvider")(
function* (input: AcpRegistryManagementInput & EffectAcpSchema.SetProviderRequest) {
const runtime = yield* makeAcpRegistryManagementRuntime(input);
yield* runtime.setProvider({
providerId: input.providerId,
apiType: input.apiType,
baseUrl: input.baseUrl,
...(input.headers === undefined ? {} : { headers: input.headers }),
});
},
(effect) =>
effect.pipe(
Effect.scoped,
Effect.timeoutOrElse({
duration: MANAGEMENT_TIMEOUT,
orElse: () =>
Effect.fail(
new AcpRegistryOperationError({
reason: "provider_configuration_failed",
message: "The ACP provider configuration request timed out.",
}),
),
}),
Effect.mapError((error) => managementFailure("providers_set", error)),
),
);
export const disableAcpRegistryProvider = Effect.fn("AcpRegistryProbe.disableProvider")(
function* (input: AcpRegistryManagementInput & { readonly providerId: string }) {
const runtime = yield* makeAcpRegistryManagementRuntime(input);
yield* runtime.disableProvider(input.providerId);
},
(effect) =>
effect.pipe(
Effect.scoped,
Effect.timeoutOrElse({
duration: MANAGEMENT_TIMEOUT,
orElse: () =>
Effect.fail(
new AcpRegistryOperationError({
reason: "provider_configuration_failed",
message: "The ACP provider disable request timed out.",
}),
),
}),
Effect.mapError((error) => managementFailure("providers_disable", error)),
),
);
export const logoutAcpRegistry = Effect.fn("AcpRegistryProbe.logout")(
function* (input: AcpRegistryManagementInput) {
const runtime = yield* makeAcpRegistryManagementRuntime(input);
yield* runtime.logout;
},
(effect) =>
effect.pipe(
Effect.scoped,
Effect.timeoutOrElse({
duration: MANAGEMENT_TIMEOUT,
orElse: () =>
Effect.fail(
new AcpRegistryOperationError({
reason: "probe_failed",
message: "The ACP logout request timed out.",
}),
),
}),
Effect.mapError((error) => managementFailure("logout", error)),
),
);