@ai2070/l0/dist/adapters/registry.js

L0: The Missing Reliability Substrate for AI

const registeredAdapters = [];
export function registerAdapter(adapter, options = {}) {
    if (!adapter.detect) {
        if (!options.silent &&
            typeof process !== "undefined" &&
            process.env?.NODE_ENV !== "production") {
            console.warn(`⚠️  Adapter "${adapter.name}" has no detect() method.\n` +
                `   It will not be used for auto-detection.\n` +
                `   Use explicit \`adapter: myAdapter\` instead, or add a detect() method.`);
        }
    }
    if (registeredAdapters.some((a) => a.name === adapter.name)) {
        throw new Error(`Adapter "${adapter.name}" is already registered`);
    }
    registeredAdapters.push(adapter);
}
export function unregisterAdapter(name) {
    const index = registeredAdapters.findIndex((a) => a.name === name);
    if (index === -1)
        return false;
    registeredAdapters.splice(index, 1);
    return true;
}
export function getAdapter(name) {
    return registeredAdapters.find((a) => a.name === name);
}
export function getRegisteredStreamAdapters() {
    return registeredAdapters.map((a) => a.name);
}
export function clearAdapters() {
    registeredAdapters.length = 0;
}
export function unregisterAllExcept(except = []) {
    const exceptSet = new Set(except);
    const toRemove = registeredAdapters
        .filter((a) => !exceptSet.has(a.name))
        .map((a) => a.name);
    for (const name of toRemove) {
        unregisterAdapter(name);
    }
    return toRemove;
}
export function detectAdapter(input) {
    const detectableAdapters = registeredAdapters.filter((a) => a.detect);
    const matches = detectableAdapters.filter((a) => a.detect(input));
    if (matches.length === 0) {
        const registered = getRegisteredStreamAdapters();
        const detectable = detectableAdapters.map((a) => a.name);
        const adapterList = detectable.length > 0 ? `[${detectable.join(", ")}]` : "(none)";
        const hint = registered.length > detectable.length
            ? ` (${registered.length - detectable.length} adapter(s) without detect() were skipped)`
            : "";
        throw new Error(`No registered adapter detected for stream. ` +
            `Detectable adapters: ${adapterList}${hint}. ` +
            `Use explicit \`adapter: myAdapter\` or register an adapter with detect().`);
    }
    if (matches.length > 1) {
        throw new Error(`Multiple adapters detected for stream: [${matches.map((a) => a.name).join(", ")}]. ` +
            `Use explicit \`adapter: myAdapter\` to disambiguate.`);
    }
    return matches[0];
}
export function hasMatchingAdapter(input) {
    const detectableAdapters = registeredAdapters.filter((a) => a.detect);
    const matches = detectableAdapters.filter((a) => a.detect(input));
    return matches.length === 1;
}
//# sourceMappingURL=registry.js.map