import { getAdapterSessionManagement } from "@zmeel/adapter-utils";
import { execute as cloudExecute, testEnvironment as cloudTestEnvironment, sessionCodec as cloudSessionCodec, } from "@zmeel/adapter-cloud/server";
import { agentConfigurationDoc as cloudAgentConfigurationDoc, models as cloudModels } from "@zmeel/adapter-cloud";
import { execute as claudeExecute, listClaudeSkills, syncClaudeSkills, testEnvironment as claudeTestEnvironment, sessionCodec as claudeSessionCodec, getQuotaWindows as claudeGetQuotaWindows, } from "@zmeel/adapter-claude-local/server";
import { agentConfigurationDoc as claudeAgentConfigurationDoc, models as claudeModels } from "@zmeel/adapter-claude-local";
import { execute as codexExecute, listCodexSkills, syncCodexSkills, testEnvironment as codexTestEnvironment, sessionCodec as codexSessionCodec, getQuotaWindows as codexGetQuotaWindows, } from "@zmeel/adapter-codex-local/server";
import { agentConfigurationDoc as codexAgentConfigurationDoc, models as codexModels } from "@zmeel/adapter-codex-local";
import { execute as cursorExecute, listCursorSkills, syncCursorSkills, testEnvironment as cursorTestEnvironment, sessionCodec as cursorSessionCodec, } from "@zmeel/adapter-cursor-local/server";
import { agentConfigurationDoc as cursorAgentConfigurationDoc, models as cursorModels } from "@zmeel/adapter-cursor-local";
import { execute as geminiExecute, listGeminiSkills, syncGeminiSkills, testEnvironment as geminiTestEnvironment, sessionCodec as geminiSessionCodec, } from "@zmeel/adapter-gemini-local/server";
import { agentConfigurationDoc as geminiAgentConfigurationDoc, models as geminiModels } from "@zmeel/adapter-gemini-local";
import { execute as openCodeExecute, listOpenCodeSkills, syncOpenCodeSkills, testEnvironment as openCodeTestEnvironment, sessionCodec as openCodeSessionCodec, listOpenCodeModels, } from "@zmeel/adapter-opencode-local/server";
import { agentConfigurationDoc as openCodeAgentConfigurationDoc, models as openCodeModels, } from "@zmeel/adapter-opencode-local";
import { execute as openclawGatewayExecute, testEnvironment as openclawGatewayTestEnvironment, } from "@zmeel/adapter-openclaw-gateway/server";
import { agentConfigurationDoc as openclawGatewayAgentConfigurationDoc, models as openclawGatewayModels, } from "@zmeel/adapter-openclaw-gateway";
import { listCodexModels } from "./codex-models.js";
import { listCursorModels } from "./cursor-models.js";
import { execute as piExecute, listPiSkills, syncPiSkills, testEnvironment as piTestEnvironment, sessionCodec as piSessionCodec, listPiModels, } from "@zmeel/adapter-pi-local/server";
import { agentConfigurationDoc as piAgentConfigurationDoc, } from "@zmeel/adapter-pi-local";
import { execute as hermesExecute, testEnvironment as hermesTestEnvironment, sessionCodec as hermesSessionCodec, listSkills as hermesListSkills, syncSkills as hermesSyncSkills, detectModel as detectModelFromHermes, } from "hermes-paperclip-adapter/server";
import { agentConfigurationDoc as hermesAgentConfigurationDoc, models as hermesModels, } from "hermes-paperclip-adapter";
import { processAdapter } from "./process/index.js";
import { httpAdapter } from "./http/index.js";
const cloudAdapter = {
    type: "cloud",
    execute: cloudExecute,
    testEnvironment: cloudTestEnvironment,
    sessionCodec: cloudSessionCodec,
    models: cloudModels,
    agentConfigurationDoc: cloudAgentConfigurationDoc,
};
const claudeLocalAdapter = {
    type: "claude_local",
    execute: claudeExecute,
    testEnvironment: claudeTestEnvironment,
    listSkills: listClaudeSkills,
    syncSkills: syncClaudeSkills,
    sessionCodec: claudeSessionCodec,
    sessionManagement: getAdapterSessionManagement("claude_local") ?? undefined,
    models: claudeModels,
    supportsLocalAgentJwt: true,
    agentConfigurationDoc: claudeAgentConfigurationDoc,
    getQuotaWindows: claudeGetQuotaWindows,
};
const codexLocalAdapter = {
    type: "codex_local",
    execute: codexExecute,
    testEnvironment: codexTestEnvironment,
    listSkills: listCodexSkills,
    syncSkills: syncCodexSkills,
    sessionCodec: codexSessionCodec,
    sessionManagement: getAdapterSessionManagement("codex_local") ?? undefined,
    models: codexModels,
    listModels: listCodexModels,
    supportsLocalAgentJwt: true,
    agentConfigurationDoc: codexAgentConfigurationDoc,
    getQuotaWindows: codexGetQuotaWindows,
};
const cursorLocalAdapter = {
    type: "cursor",
    execute: cursorExecute,
    testEnvironment: cursorTestEnvironment,
    listSkills: listCursorSkills,
    syncSkills: syncCursorSkills,
    sessionCodec: cursorSessionCodec,
    sessionManagement: getAdapterSessionManagement("cursor") ?? undefined,
    models: cursorModels,
    listModels: listCursorModels,
    supportsLocalAgentJwt: true,
    agentConfigurationDoc: cursorAgentConfigurationDoc,
};
const geminiLocalAdapter = {
    type: "gemini_local",
    execute: geminiExecute,
    testEnvironment: geminiTestEnvironment,
    listSkills: listGeminiSkills,
    syncSkills: syncGeminiSkills,
    sessionCodec: geminiSessionCodec,
    sessionManagement: getAdapterSessionManagement("gemini_local") ?? undefined,
    models: geminiModels,
    supportsLocalAgentJwt: true,
    agentConfigurationDoc: geminiAgentConfigurationDoc,
};
const openclawGatewayAdapter = {
    type: "openclaw_gateway",
    execute: openclawGatewayExecute,
    testEnvironment: openclawGatewayTestEnvironment,
    models: openclawGatewayModels,
    supportsLocalAgentJwt: false,
    agentConfigurationDoc: openclawGatewayAgentConfigurationDoc,
};
const openCodeLocalAdapter = {
    type: "opencode_local",
    execute: openCodeExecute,
    testEnvironment: openCodeTestEnvironment,
    listSkills: listOpenCodeSkills,
    syncSkills: syncOpenCodeSkills,
    sessionCodec: openCodeSessionCodec,
    models: openCodeModels,
    sessionManagement: getAdapterSessionManagement("opencode_local") ?? undefined,
    listModels: listOpenCodeModels,
    supportsLocalAgentJwt: true,
    agentConfigurationDoc: openCodeAgentConfigurationDoc,
};
const piLocalAdapter = {
    type: "pi_local",
    execute: piExecute,
    testEnvironment: piTestEnvironment,
    listSkills: listPiSkills,
    syncSkills: syncPiSkills,
    sessionCodec: piSessionCodec,
    sessionManagement: getAdapterSessionManagement("pi_local") ?? undefined,
    models: [],
    listModels: listPiModels,
    supportsLocalAgentJwt: true,
    agentConfigurationDoc: piAgentConfigurationDoc,
};
const hermesLocalAdapter = {
    type: "hermes_local",
    execute: hermesExecute,
    testEnvironment: hermesTestEnvironment,
    sessionCodec: hermesSessionCodec,
    listSkills: hermesListSkills,
    syncSkills: hermesSyncSkills,
    models: hermesModels,
    supportsLocalAgentJwt: true,
    agentConfigurationDoc: hermesAgentConfigurationDoc,
    detectModel: () => detectModelFromHermes(),
};
const adaptersByType = new Map([
    cloudAdapter,
    claudeLocalAdapter,
    codexLocalAdapter,
    openCodeLocalAdapter,
    piLocalAdapter,
    cursorLocalAdapter,
    geminiLocalAdapter,
    openclawGatewayAdapter,
    hermesLocalAdapter,
    processAdapter,
    httpAdapter,
].map((a) => [a.type, a]));
export function getServerAdapter(type) {
    const adapter = adaptersByType.get(type);
    if (!adapter) {
        // Fall back to process adapter for unknown types
        return processAdapter;
    }
    return adapter;
}
export async function listAdapterModels(type) {
    const adapter = adaptersByType.get(type);
    if (!adapter)
        return [];
    if (adapter.listModels) {
        const discovered = await adapter.listModels();
        if (discovered.length > 0)
            return discovered;
    }
    return adapter.models ?? [];
}
export function listServerAdapters() {
    return Array.from(adaptersByType.values());
}
export async function detectAdapterModel(type) {
    const adapter = adaptersByType.get(type);
    if (!adapter?.detectModel)
        return null;
    const detected = await adapter.detectModel();
    return detected ? { model: detected.model, provider: detected.provider, source: detected.source } : null;
}
export function findServerAdapter(type) {
    return adaptersByType.get(type) ?? null;
}
//# sourceMappingURL=registry.js.map