qlogicagent 2.13.5 → 2.13.6

package/dist/protocol/wire/provider-runtime-core.js

@@ -1,488 +0,0 @@
-export const PROVIDER_RUNTIME_OPENAI_CODEX_PROVIDER_ID = "openai-codex";
-export function normalizeProviderRuntimeId(provider) {
-    const normalized = provider.trim().toLowerCase();
-    if (normalized === "z.ai" || normalized === "z-ai") {
-        return "zai";
-    }
-    if (normalized === "opencode-zen") {
-        return "opencode";
-    }
-    if (normalized === "kimi-code") {
-        return "kimi-coding";
-    }
-    if (normalized === "bedrock" || normalized === "aws-bedrock") {
-        return "amazon-bedrock";
-    }
-    if (normalized === "bytedance" || normalized === "doubao") {
-        return "volcengine";
-    }
-    return normalized;
-}
-export function normalizeProviderRuntimeIdForAuth(provider) {
-    const normalized = normalizeProviderRuntimeId(provider);
-    if (normalized === "volcengine-plan") {
-        return "volcengine";
-    }
-    if (normalized === "qwen-coding") {
-        return "qwen";
-    }
-    if (normalized === "byteplus-plan") {
-        return "byteplus";
-    }
-    return normalized;
-}
-export const resolveProviderRuntimeKeyFamily = normalizeProviderRuntimeIdForAuth;
-const DEFAULT_PROVIDER_CAPABILITIES = {
-    anthropicToolSchemaMode: "native",
-    anthropicToolChoiceMode: "native",
-    providerFamily: "default",
-    preserveAnthropicThinkingSignatures: true,
-    openAiCompatTurnValidation: true,
-    providerThoughtSignatureSanitization: false,
-    transcriptToolCallIdMode: "default",
-    transcriptToolCallIdModelHints: [],
-    providerThoughtSignatureModelHints: [],
-    dropThinkingBlockModelHints: [],
-};
-const PROVIDER_CAPABILITIES = {
-    anthropic: {
-        providerFamily: "anthropic",
-    },
-    "amazon-bedrock": {
-        providerFamily: "anthropic",
-    },
-    "kimi-coding": {
-        anthropicToolSchemaMode: "openai-functions",
-        anthropicToolChoiceMode: "openai-string-modes",
-        preserveAnthropicThinkingSignatures: false,
-    },
-    mistral: {
-        transcriptToolCallIdMode: "strict9",
-        transcriptToolCallIdModelHints: [
-            "mistral",
-            "mixtral",
-            "codestral",
-            "pixtral",
-            "devstral",
-            "ministral",
-            "mistralai",
-        ],
-    },
-    openai: {
-        providerFamily: "openai",
-    },
-    [PROVIDER_RUNTIME_OPENAI_CODEX_PROVIDER_ID]: {
-        providerFamily: "openai",
-    },
-    openrouter: {
-        openAiCompatTurnValidation: false,
-        providerThoughtSignatureSanitization: true,
-        providerThoughtSignatureModelHints: ["gemini"],
-    },
-    opencode: {
-        openAiCompatTurnValidation: false,
-        providerThoughtSignatureSanitization: true,
-        providerThoughtSignatureModelHints: ["gemini"],
-    },
-    kilocode: {
-        providerThoughtSignatureSanitization: true,
-        providerThoughtSignatureModelHints: ["gemini"],
-    },
-};
-function modelIncludesAnyHint(modelId, hints) {
-    const normalized = (modelId ?? "").toLowerCase();
-    return Boolean(normalized) && hints.some((hint) => normalized.includes(hint));
-}
-export function resolveProviderRuntimeCapabilities(provider) {
-    const normalized = normalizeProviderRuntimeId(provider ?? "");
-    return {
-        ...DEFAULT_PROVIDER_CAPABILITIES,
-        ...PROVIDER_CAPABILITIES[normalized],
-    };
-}
-export function preservesProviderRuntimeAnthropicThinkingSignatures(provider) {
-    return resolveProviderRuntimeCapabilities(provider).preserveAnthropicThinkingSignatures;
-}
-export function requiresOpenAiCompatibleAnthropicToolPayloadForProviderRuntime(provider) {
-    const capabilities = resolveProviderRuntimeCapabilities(provider);
-    return (capabilities.anthropicToolSchemaMode !== "native" ||
-        capabilities.anthropicToolChoiceMode !== "native");
-}
-export function usesOpenAiFunctionAnthropicToolSchemaForProviderRuntime(provider) {
-    return resolveProviderRuntimeCapabilities(provider).anthropicToolSchemaMode === "openai-functions";
-}
-export function usesOpenAiStringModeAnthropicToolChoiceForProviderRuntime(provider) {
-    return (resolveProviderRuntimeCapabilities(provider).anthropicToolChoiceMode ===
-        "openai-string-modes");
-}
-export function supportsOpenAiCompatTurnValidationForProviderRuntime(provider) {
-    return resolveProviderRuntimeCapabilities(provider).openAiCompatTurnValidation;
-}
-export function isOpenAiProviderRuntimeFamily(provider) {
-    return resolveProviderRuntimeCapabilities(provider).providerFamily === "openai";
-}
-export function isAnthropicProviderRuntimeFamily(provider) {
-    return resolveProviderRuntimeCapabilities(provider).providerFamily === "anthropic";
-}
-export function shouldDropThinkingBlocksForProviderRuntimeModel(params) {
-    return modelIncludesAnyHint(params.modelId, resolveProviderRuntimeCapabilities(params.provider).dropThinkingBlockModelHints);
-}
-export function shouldSanitizeProviderRuntimeThoughtSignaturesForModel(params) {
-    const capabilities = resolveProviderRuntimeCapabilities(params.provider);
-    return (capabilities.providerThoughtSignatureSanitization &&
-        modelIncludesAnyHint(params.modelId, capabilities.providerThoughtSignatureModelHints));
-}
-export function resolveProviderRuntimeTranscriptToolCallIdMode(provider, modelId) {
-    const capabilities = resolveProviderRuntimeCapabilities(provider);
-    const mode = capabilities.transcriptToolCallIdMode;
-    if (mode === "strict9") {
-        return mode;
-    }
-    if (modelIncludesAnyHint(modelId, capabilities.transcriptToolCallIdModelHints)) {
-        return "strict9";
-    }
-    return undefined;
-}
-export function createProviderRuntimeInMemoryAuthStorageBackend(initialData) {
-    let snapshot = JSON.stringify(initialData, null, 2);
-    return {
-        withLock(update) {
-            const { result, next } = update(snapshot);
-            if (typeof next === "string") {
-                snapshot = next;
-            }
-            return result;
-        },
-    };
-}
-export function createProviderRuntimeAuthStorage(params) {
-    const withInMemory = params.AuthStorageLike;
-    if (typeof withInMemory.inMemory === "function") {
-        return withInMemory.inMemory(params.credentials);
-    }
-    const withFromStorage = params.AuthStorageLike;
-    if (typeof withFromStorage.fromStorage === "function") {
-        const backend = params.createBackend?.() ?? createProviderRuntimeInMemoryAuthStorageBackend(params.credentials);
-        backend.withLock(() => ({
-            result: undefined,
-            next: JSON.stringify(params.credentials, null, 2),
-        }));
-        return withFromStorage.fromStorage(backend);
-    }
-    const withFactory = params.AuthStorageLike;
-    const withRuntimeOverride = (typeof withFactory.create === "function"
-        ? withFactory.create(params.authPath)
-        : new params.AuthStorageLike(params.authPath));
-    if (typeof withRuntimeOverride.setRuntimeApiKey === "function") {
-        for (const [provider, credential] of Object.entries(params.credentials)) {
-            if ("key" in credential) {
-                withRuntimeOverride.setRuntimeApiKey(provider, credential.key);
-                continue;
-            }
-            withRuntimeOverride.setRuntimeApiKey(provider, credential.access);
-        }
-    }
-    return withRuntimeOverride;
-}
-export function resolveProviderRuntimeAwsSdkEnvVarName(env = process.env) {
-    if (env.AWS_BEARER_TOKEN_BEDROCK?.trim()) {
-        return "AWS_BEARER_TOKEN_BEDROCK";
-    }
-    if (env.AWS_ACCESS_KEY_ID?.trim() && env.AWS_SECRET_ACCESS_KEY?.trim()) {
-        return "AWS_ACCESS_KEY_ID";
-    }
-    if (env.AWS_PROFILE?.trim()) {
-        return "AWS_PROFILE";
-    }
-    return undefined;
-}
-function resolveEnvSourceLabel(params) {
-    const shellApplied = params.envVars.some((envVar) => params.applied.has(envVar));
-    const prefix = shellApplied ? "shell env: " : "env: ";
-    return `${prefix}${params.label}`;
-}
-export function resolveProviderRuntimeAwsSdkAuthInfo(params) {
-    const env = params?.env ?? process.env;
-    const applied = new Set(params?.appliedEnvKeys ?? []);
-    if (env.AWS_BEARER_TOKEN_BEDROCK?.trim()) {
-        return {
-            mode: "aws-sdk",
-            source: resolveEnvSourceLabel({
-                applied,
-                envVars: ["AWS_BEARER_TOKEN_BEDROCK"],
-                label: "AWS_BEARER_TOKEN_BEDROCK",
-            }),
-        };
-    }
-    if (env.AWS_ACCESS_KEY_ID?.trim() && env.AWS_SECRET_ACCESS_KEY?.trim()) {
-        return {
-            mode: "aws-sdk",
-            source: resolveEnvSourceLabel({
-                applied,
-                envVars: ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"],
-                label: "AWS_ACCESS_KEY_ID + AWS_SECRET_ACCESS_KEY",
-            }),
-        };
-    }
-    if (env.AWS_PROFILE?.trim()) {
-        return {
-            mode: "aws-sdk",
-            source: resolveEnvSourceLabel({
-                applied,
-                envVars: ["AWS_PROFILE"],
-                label: "AWS_PROFILE",
-            }),
-        };
-    }
-    return { mode: "aws-sdk", source: "aws-sdk default chain" };
-}
-export const PROVIDER_RUNTIME_ENV_API_KEY_CANDIDATES = {
-    anthropic: ["ANTHROPIC_OAUTH_TOKEN", "ANTHROPIC_API_KEY"],
-    chutes: ["CHUTES_OAUTH_TOKEN", "CHUTES_API_KEY"],
-    zai: ["ZAI_API_KEY", "Z_AI_API_KEY"],
-    opencode: ["OPENCODE_API_KEY", "OPENCODE_ZEN_API_KEY"],
-    qwen: ["DASHSCOPE_API_KEY", "QWEN_API_KEY"],
-    "qwen-coding": ["DASHSCOPE_API_KEY", "QWEN_API_KEY"],
-    volcengine: ["VOLCANO_ENGINE_API_KEY", "ARK_API_KEY", "DOUBAO_API_KEY"],
-    "volcengine-plan": ["VOLCANO_ENGINE_API_KEY", "ARK_API_KEY", "DOUBAO_API_KEY"],
-    byteplus: ["BYTEPLUS_API_KEY"],
-    "byteplus-plan": ["BYTEPLUS_API_KEY"],
-    "kimi-coding": ["KIMI_API_KEY", "KIMICODE_API_KEY"],
-    huggingface: ["HUGGINGFACE_HUB_TOKEN", "HF_TOKEN"],
-    openai: ["OPENAI_API_KEY"],
-    voyage: ["VOYAGE_API_KEY"],
-    groq: ["GROQ_API_KEY"],
-    deepgram: ["DEEPGRAM_API_KEY"],
-    cerebras: ["CEREBRAS_API_KEY"],
-    xai: ["XAI_API_KEY"],
-    openrouter: ["OPENROUTER_API_KEY"],
-    litellm: ["LITELLM_API_KEY"],
-    "vercel-ai-gateway": ["AI_GATEWAY_API_KEY"],
-    "cloudflare-ai-gateway": ["CLOUDFLARE_AI_GATEWAY_API_KEY"],
-    moonshot: ["MOONSHOT_API_KEY"],
-    minimax: ["MINIMAX_API_KEY"],
-    "minimax-cn": ["MINIMAX_CN_API_KEY", "MINIMAX_API_KEY"],
-    nvidia: ["NVIDIA_API_KEY"],
-    xiaomi: ["XIAOMI_API_KEY"],
-    synthetic: ["SYNTHETIC_API_KEY"],
-    venice: ["VENICE_API_KEY"],
-    mistral: ["MISTRAL_API_KEY"],
-    together: ["TOGETHER_API_KEY"],
-    qianfan: ["QIANFAN_API_KEY"],
-    ollama: ["OLLAMA_API_KEY"],
-    vllm: ["VLLM_API_KEY"],
-    kilocode: ["KILOCODE_API_KEY"],
-};
-export function listProviderRuntimeEnvApiKeyNames() {
-    return [...new Set(Object.values(PROVIDER_RUNTIME_ENV_API_KEY_CANDIDATES).flat())];
-}
-export function resolveProviderRuntimeEnvApiKey(params) {
-    const normalized = normalizeProviderRuntimeId(params.provider);
-    const env = params.env ?? process.env;
-    const applied = new Set(params.appliedEnvKeys ?? []);
-    const pick = (envVar) => {
-        const value = env[envVar]?.trim();
-        if (!value) {
-            return null;
-        }
-        const source = applied.has(envVar) ? `shell env: ${envVar}` : `env: ${envVar}`;
-        return { apiKey: value, source };
-    };
-    const special = params.resolveSpecialApiKey?.(normalized, env, applied);
-    if (special) {
-        return special;
-    }
-    const envCandidates = PROVIDER_RUNTIME_ENV_API_KEY_CANDIDATES[normalized];
-    if (!envCandidates || envCandidates.length === 0) {
-        return null;
-    }
-    for (const envVar of envCandidates) {
-        const resolved = pick(envVar);
-        if (resolved) {
-            return resolved;
-        }
-    }
-    return null;
-}
-export function createProviderRuntimeAuthCore(deps) {
-    const normalizeProvider = deps.normalizeProviderId ?? normalizeProviderRuntimeId;
-    const resolveKeyFamily = deps.resolveKeyFamily ?? resolveProviderRuntimeKeyFamily;
-    async function resolveApiKeyForProvider(params) {
-        const { provider, cfg, profileId, preferredProfile } = params;
-        if (deps.isHubManagedProviderPathActive()) {
-            return { apiKey: "hub-managed", source: "hub-managed", mode: "api-key" };
-        }
-        const store = params.store ?? deps.profileDeps.ensureAuthProfileStore(params.agentDir);
-        const family = resolveKeyFamily(provider);
-        const providersToTry = family !== provider ? [provider, family] : [provider];
-        const customKey = deps.getCustomProviderApiKey(cfg, provider);
-        if (customKey) {
-            return { apiKey: customKey, source: "models.providers", mode: "api-key" };
-        }
-        if (profileId) {
-            const credType = deps.profileDeps.getProfileType(store, profileId);
-            if (credType !== "api_key") {
-                const resolved = await deps.profileDeps.resolveApiKeyForProfile({
-                    cfg,
-                    store,
-                    profileId,
-                    agentDir: params.agentDir,
-                });
-                if (!resolved) {
-                    throw new Error(`No credentials found for profile "${profileId}".`);
-                }
-                return {
-                    apiKey: resolved.apiKey,
-                    profileId,
-                    source: `profile:${profileId}`,
-                    mode: credType === "oauth" ? "oauth" : "token",
-                };
-            }
-        }
-        for (const tryProvider of providersToTry) {
-            const order = deps.profileDeps.resolveAuthProfileOrder({
-                cfg,
-                store,
-                provider: tryProvider,
-                preferredProfile,
-            });
-            for (const candidate of order) {
-                const candidateType = deps.profileDeps.getProfileType(store, candidate);
-                if (candidateType === "api_key") {
-                    continue;
-                }
-                try {
-                    const resolved = await deps.profileDeps.resolveApiKeyForProfile({
-                        cfg,
-                        store,
-                        profileId: candidate,
-                        agentDir: params.agentDir,
-                    });
-                    if (resolved) {
-                        return {
-                            apiKey: resolved.apiKey,
-                            profileId: candidate,
-                            source: `profile:${candidate}`,
-                            mode: candidateType === "oauth" ? "oauth" : "token",
-                        };
-                    }
-                }
-                catch {
-                    // Best-effort scan across candidate profiles.
-                }
-            }
-        }
-        const authOverride = deps.resolveProviderAuthOverride(cfg, provider);
-        if (authOverride === "aws-sdk") {
-            return resolveProviderRuntimeAwsSdkAuthInfo({
-                appliedEnvKeys: deps.getAppliedShellEnvKeys?.(),
-            });
-        }
-        const envResolved = deps.resolveEnvApiKey(provider);
-        if (envResolved) {
-            return {
-                apiKey: envResolved.apiKey,
-                source: envResolved.source,
-                mode: envResolved.source.includes("OAUTH_TOKEN") ? "oauth" : "api-key",
-            };
-        }
-        if (authOverride === undefined && normalizeProvider(provider) === "amazon-bedrock") {
-            return resolveProviderRuntimeAwsSdkAuthInfo({
-                appliedEnvKeys: deps.getAppliedShellEnvKeys?.(),
-            });
-        }
-        try {
-            const fallbackProviders = deps.getFallbackProviders?.(provider) ?? [];
-            const allProviders = [provider, ...fallbackProviders.filter(Boolean)];
-            if (family !== provider && !allProviders.includes(family)) {
-                allProviders.splice(1, 0, family);
-            }
-            for (const candidateProvider of allProviders) {
-                const platformAuth = deps.tryGetPlatformKey?.(candidateProvider);
-                if (platformAuth) {
-                    return {
-                        apiKey: platformAuth.key,
-                        source: platformAuth.source,
-                        mode: "api-key",
-                        vaultRelease: platformAuth.release,
-                        vaultReportSuccess: platformAuth.reportSuccess,
-                        vaultReportError: platformAuth.reportError,
-                    };
-                }
-            }
-        }
-        catch (error) {
-            deps.onPlatformKeyError?.(provider, error);
-        }
-        throw new Error(`No API key found for provider "${provider}". ` +
-            `Configure a local key in the desktop subscription page or ensure platform keys are available.`);
-    }
-    function resolveModelAuthMode(provider, cfg, store) {
-        const resolved = provider?.trim();
-        if (!resolved) {
-            return undefined;
-        }
-        const authOverride = deps.resolveProviderAuthOverride(cfg, resolved);
-        if (authOverride === "aws-sdk") {
-            return "aws-sdk";
-        }
-        const authStore = store ?? deps.profileDeps.ensureAuthProfileStore();
-        const profiles = deps.profileDeps.listProfilesForProvider(authStore, resolved);
-        if (profiles.length > 0) {
-            const modes = new Set(profiles
-                .map((id) => deps.profileDeps.getProfileType(authStore, id))
-                .filter((mode) => Boolean(mode)));
-            const distinct = ["oauth", "token", "api_key"].filter((key) => modes.has(key));
-            if (distinct.length >= 2) {
-                return "mixed";
-            }
-            if (modes.has("oauth")) {
-                return "oauth";
-            }
-            if (modes.has("token")) {
-                return "token";
-            }
-            if (modes.has("api_key")) {
-                return "api-key";
-            }
-        }
-        if (authOverride === undefined && normalizeProvider(resolved) === "amazon-bedrock") {
-            return "aws-sdk";
-        }
-        const envKey = deps.resolveEnvApiKey(resolved);
-        if (envKey?.apiKey) {
-            return envKey.source.includes("OAUTH_TOKEN") ? "oauth" : "api-key";
-        }
-        if (deps.getCustomProviderApiKey(cfg, resolved)) {
-            return "api-key";
-        }
-        return "unknown";
-    }
-    async function getApiKeyForModel(params) {
-        const provider = deps.getModelProvider?.(params.model);
-        if (!provider) {
-            throw new Error("Provider runtime model adapter returned no provider.");
-        }
-        return await resolveApiKeyForProvider({
-            provider,
-            cfg: params.cfg,
-            profileId: params.profileId,
-            preferredProfile: params.preferredProfile,
-            store: params.store,
-            agentDir: params.agentDir,
-        });
-    }
-    function requireApiKey(auth, provider) {
-        const normalized = deps.normalizeSecretInput?.(auth.apiKey) ?? auth.apiKey?.trim();
-        if (normalized) {
-            return normalized;
-        }
-        throw new Error(`No API key resolved for provider "${provider}" (auth mode: ${auth.mode}).`);
-    }
-    return {
-        getApiKeyForModel,
-        requireApiKey,
-        resolveApiKeyForProvider,
-        resolveModelAuthMode,
-    };
-}

package/dist/protocol/wire/provider-runtime-io.d.ts

@@ -1,20 +0,0 @@
-import { type ProviderRuntimeCredentialMap } from "./provider-runtime-core.js";
-export declare function scrubProviderRuntimeStaticAuthJsonEntries(pathname: string): void;
-type InMemoryAuthStorageBackendLike = {
-    withLock<T>(update: (current: string) => {
-        result: T;
-        next?: string;
-    }): T;
-};
-export declare function discoverProviderRuntimeAuthStorage<TAuthStorage>(params: {
-    agentDir: string;
-    AuthStorageLike: unknown;
-    credentials: ProviderRuntimeCredentialMap;
-    createBackend?: () => InMemoryAuthStorageBackendLike;
-}): TAuthStorage;
-export declare function createProviderRuntimeModelRegistry<TAuthStorage, TModelRegistry>(params: {
-    authStorage: TAuthStorage;
-    ModelRegistryLike: new (authStorage: TAuthStorage, modelsPath: string) => TModelRegistry;
-    agentDir: string;
-}): TModelRegistry;
-export {};

package/dist/protocol/wire/provider-runtime-io.js

@@ -1,57 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { createProviderRuntimeAuthStorage, } from "./provider-runtime-core.js";
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-export function scrubProviderRuntimeStaticAuthJsonEntries(pathname) {
-    if (process.env.QLOGICAGENT_AUTH_STORE_READONLY === "1") {
-        return;
-    }
-    if (!fs.existsSync(pathname)) {
-        return;
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(fs.readFileSync(pathname, "utf8"));
-    }
-    catch {
-        return;
-    }
-    if (!isRecord(parsed)) {
-        return;
-    }
-    let changed = false;
-    for (const [provider, value] of Object.entries(parsed)) {
-        if (!isRecord(value)) {
-            continue;
-        }
-        if (value.type !== "api_key") {
-            continue;
-        }
-        delete parsed[provider];
-        changed = true;
-    }
-    if (!changed) {
-        return;
-    }
-    if (Object.keys(parsed).length === 0) {
-        fs.rmSync(pathname, { force: true });
-        return;
-    }
-    fs.writeFileSync(pathname, `${JSON.stringify(parsed, null, 2)}\n`, "utf8");
-    fs.chmodSync(pathname, 0o600);
-}
-export function discoverProviderRuntimeAuthStorage(params) {
-    const authPath = path.join(params.agentDir, "auth.json");
-    scrubProviderRuntimeStaticAuthJsonEntries(authPath);
-    return createProviderRuntimeAuthStorage({
-        AuthStorageLike: params.AuthStorageLike,
-        authPath,
-        credentials: params.credentials,
-        createBackend: params.createBackend,
-    });
-}
-export function createProviderRuntimeModelRegistry(params) {
-    return new params.ModelRegistryLike(params.authStorage, path.join(params.agentDir, "models.json"));
-}

package/dist/protocol/wire/resource-manifest.d.ts

@@ -1,68 +0,0 @@
-export declare const RESOURCE_MANIFEST_SCHEMA_VERSION = 2;
-export declare const RUNTIME_ASSET_IDS: {
-    readonly gatewayImage: "gateway.image.desktop-slim";
-    readonly whisperModelTiny: "speech.whisper.model.tiny";
-    readonly ffmpegWin32X64: "runtime.ffmpeg.win32-x64";
-    readonly nodeWin32X64: "runtime.node.win32-x64";
-    readonly dockerDesktopWin32X64: "runtime.docker-desktop.win32-x64";
-    readonly dockerDesktopDarwinX64: "runtime.docker-desktop.darwin-x64";
-    readonly dockerDesktopDarwinArm64: "runtime.docker-desktop.darwin-arm64";
-};
-export declare const RUNTIME_PROFILE_IDS: {
-    readonly desktopDockerBridge: "desktop.docker-bridge";
-    readonly desktopEmbeddedWin32X64: "desktop.embedded.win32-x64";
-};
-export type RuntimeResourcePlatform = 'any' | 'win32-x64' | 'win32-arm64' | 'darwin-x64' | 'darwin-arm64' | 'linux-x64' | 'linux-arm64';
-export type RuntimeResourceAssetKind = 'container-image' | 'model' | 'runtime' | 'installer';
-export type RuntimeResourceAssetDelivery = 'remote' | 'bundled';
-export interface RuntimeResourceArtifact {
-    label?: string;
-    fileName: string;
-    size?: number;
-    sha256?: string;
-    url?: string;
-    relativePath?: string;
-}
-export interface RuntimeResourceAsset {
-    id: string;
-    version: string;
-    title: string;
-    kind: RuntimeResourceAssetKind;
-    delivery: RuntimeResourceAssetDelivery;
-    platform: RuntimeResourcePlatform;
-    description?: string;
-    artifacts: RuntimeResourceArtifact[];
-}
-export interface RuntimeResourceProfile {
-    id: string;
-    title: string;
-    platform: RuntimeResourcePlatform;
-    assetIds: string[];
-    description?: string;
-}
-export type RuntimeResourceAssetMap = Record<string, RuntimeResourceAsset>;
-export type RuntimeResourceProfileMap = Record<string, RuntimeResourceProfile>;
-export interface RuntimeManifestShortcutEntry {
-    version: string;
-    sha256: string;
-    size: number;
-    url: string;
-}
-export interface RuntimeResourceManifest {
-    schemaVersion: number;
-    channel?: string;
-    publishedAt?: string;
-    minElectronVersion?: string;
-    releaseNotes?: string;
-    assets: RuntimeResourceAssetMap;
-    profiles: RuntimeResourceProfileMap;
-    gateway?: RuntimeManifestShortcutEntry;
-    whisperModel?: RuntimeManifestShortcutEntry;
-}
-export declare function createDefaultRuntimeResourceProfiles(): RuntimeResourceProfileMap;
-export declare function getRuntimeResourceAsset(manifest: Pick<RuntimeResourceManifest, 'assets'>, assetId: string): RuntimeResourceAsset | undefined;
-export declare function getRuntimeResourceProfile(manifest: Pick<RuntimeResourceManifest, 'profiles'>, profileId: string): RuntimeResourceProfile | undefined;
-export declare function getRuntimeResourceProfileAssets(manifest: Pick<RuntimeResourceManifest, 'assets' | 'profiles'>, profileId: string): RuntimeResourceAsset[];
-export declare function upsertRuntimeResourceAsset(manifest: RuntimeResourceManifest, asset: RuntimeResourceAsset): RuntimeResourceManifest;
-export declare function getManifestShortcutEntry(asset?: RuntimeResourceAsset): RuntimeManifestShortcutEntry | undefined;
-export declare function normalizeRuntimeResourceManifest(raw: unknown): RuntimeResourceManifest;