@kaelio/ktx 0.10.0 → 0.12.0

package/dist/ingest.d.ts

@@ -60,7 +60,7 @@ export interface KtxIngestDeps {
     startLiveMemoryFlow?: typeof startLiveMemoryFlowTui;
     abortSignal?: AbortSignal;
     env?: NodeJS.ProcessEnv;
-    localIngestOptions?: Pick<RunLocalIngestOptions, 'agentRunner' | 'llmRuntime' | 'memoryModel' | 'semanticLayerCompute' | 'queryExecutor' | 'logger' | 'pullConfigOptions'>;
+    localIngestOptions?: Pick<RunLocalIngestOptions, 'agentRunner' | 'llmRuntime' | 'memoryModel' | 'semanticLayerCompute' | 'queryExecutor' | 'sqlAnalysis' | 'logger' | 'pullConfigOptions'>;
     progress?: (update: KtxIngestProgressUpdate) => void;
     runtimeIo?: KtxIngestIo;
 }

package/dist/ingest.js

@@ -11,7 +11,7 @@ import { resolveProjectEmbeddingProvider } from './embedding-resolution.js';
 import { createKtxCliIngestQueryExecutor } from './ingest-query-executor.js';
 import { readIngestReportSnapshotFile } from './ingest-report-file.js';
 import { createCliOperationalLogger } from './io/logger.js';
-import { createKtxCliLocalIngestAdapters } from './local-adapters.js';
+import { createKtxCliLocalIngestAdapters, resolveKtxCliSqlAnalysis } from './local-adapters.js';
 import { renderMemoryFlowInteractively } from './memory-flow-interactive.js';
 import { renderMemoryFlowTui, startLiveMemoryFlowTui, } from './memory-flow-tui.js';
 import { resolveVizFallback, warnVizFallbackOnce } from './viz-fallback.js';
@@ -525,7 +525,7 @@ export async function runKtxIngest(args, io = process, deps = {}) {
             const localIngestOptions = deps.localIngestOptions ?? {};
             const managedDaemon = managedDaemonOptionsForIngestRun(args, deps.runtimeIo ?? io);
             const operationalLogger = createCliOperationalLogger(io, args.outputMode);
-            const adapterOptions = {
+            const baseAdapterOptions = {
                 ...(localIngestOptions.pullConfigOptions ?? {}),
                 ...(args.databaseIntrospectionUrl ? { databaseIntrospectionUrl: args.databaseIntrospectionUrl } : {}),
                 ...(managedDaemon ? { managedDaemon } : {}),
@@ -535,6 +535,10 @@ export async function runKtxIngest(args, io = process, deps = {}) {
                     : {}),
                 logger: operationalLogger,
             };
+            // One parser-backed SQL analysis port per run: the historic-sql adapter and
+            // the ingest sql_execution tool share the same daemon-backed validator.
+            const sqlAnalysis = localIngestOptions.sqlAnalysis ?? resolveKtxCliSqlAnalysis(baseAdapterOptions);
+            const adapterOptions = { ...baseAdapterOptions, sqlAnalysis };
             const queryExecutor = localIngestOptions.queryExecutor ??
                 (deps.createQueryExecutor ?? createKtxCliIngestQueryExecutor)(ingestProject);
             if (args.adapter === 'metabase' && args.sourceDir) {
@@ -577,6 +581,7 @@ export async function runKtxIngest(args, io = process, deps = {}) {
                         metabaseConnectionId: args.connectionId,
                         ...localIngestOptions,
                         queryExecutor,
+                        sqlAnalysis,
                         trigger: 'manual_resync',
                         jobIdFactory: deps.jobIdFactory,
                         embeddingProvider,
@@ -650,6 +655,7 @@ export async function runKtxIngest(args, io = process, deps = {}) {
                     jobId,
                     ...localIngestOptions,
                     queryExecutor,
+                    sqlAnalysis,
                     pullConfigOptions: adapterOptions,
                     embeddingProvider,
                     ...(args.debugLlmRequestFile ? { llmDebugRequestFile: args.debugLlmRequestFile } : {}),

package/dist/io/symbols.d.ts

@@ -1,3 +1,5 @@
+/** Whether the active terminal renders Unicode glyphs (block/box drawing, arrows). */
+export declare const unicodeSupported: boolean;
 export declare const SYMBOLS: {
     readonly middot: "-" | "·";
     readonly emDash: "--" | "—";

package/dist/io/symbols.js

@@ -9,6 +9,8 @@ function detectUnicodeSupport(env = process.env) {
         env.TERM === 'alacritty');
 }
 const unicode = detectUnicodeSupport();
+/** Whether the active terminal renders Unicode glyphs (block/box drawing, arrows). */
+export const unicodeSupported = unicode;
 export const SYMBOLS = {
     middot: unicode ? '·' : '-',
     emDash: unicode ? '—' : '--',

package/dist/io/tty.d.ts

@@ -0,0 +1,17 @@
+import type { Writable } from 'node:stream';
+import type { KtxCliIo } from '../cli-runtime.js';
+type KtxCliOutput = (KtxCliIo['stdout'] | KtxCliIo['stderr']) & {
+    isTTY?: boolean;
+    columns?: number;
+    on?: unknown;
+};
+export declare function isWritableTtyOutput(output: KtxCliOutput): output is KtxCliOutput & Writable;
+export declare function shouldUseColorOutput(output: {
+    isTTY?: boolean;
+}): boolean;
+/**
+ * Color depth in bits for the given output: 1 when color is disabled, the
+ * stream-reported depth when available, and a 16-color baseline otherwise.
+ */
+export declare function colorDepthForOutput(output: KtxCliOutput): number;
+export {};

package/dist/io/tty.js

@@ -0,0 +1,21 @@
+export function isWritableTtyOutput(output) {
+    return (output.isTTY === true &&
+        typeof output.on === 'function' &&
+        typeof output.columns !== 'undefined');
+}
+export function shouldUseColorOutput(output) {
+    if (output.isTTY !== true)
+        return false;
+    const env = process.env;
+    return !env.NO_COLOR && env.TERM !== 'dumb' && !env.CI;
+}
+/**
+ * Color depth in bits for the given output: 1 when color is disabled, the
+ * stream-reported depth when available, and a 16-color baseline otherwise.
+ */
+export function colorDepthForOutput(output) {
+    if (!shouldUseColorOutput(output))
+        return 1;
+    const getColorDepth = output.getColorDepth;
+    return typeof getColorDepth === 'function' ? getColorDepth.call(output) : 4;
+}

package/dist/links.d.ts

@@ -0,0 +1 @@
+export declare const SLACK_URL = "https://ktx.sh/slack";

package/dist/links.js

@@ -0,0 +1 @@
+export const SLACK_URL = 'https://ktx.sh/slack';

package/dist/llm/embedding-health.js

@@ -21,7 +21,7 @@ async function withTimeout(promise, timeoutMs) {
 export async function runKtxEmbeddingHealthCheck(config, options = {}) {
     try {
         const provider = createKtxEmbeddingProvider(config, options.deps);
-        const embedding = await withTimeout(provider.embed(options.text ?? 'KTX embedding health check'), options.timeoutMs ?? 15_000);
+        const embedding = await withTimeout(provider.embed(options.text ?? 'ktx embedding health check'), options.timeoutMs ?? 15_000);
         if (embedding.length !== config.dimensions) {
             return {
                 ok: false,

package/dist/llm/embedding-provider.js

@@ -49,7 +49,7 @@ class OpenAIEmbeddingProvider {
         this.dimensions = config.dimensions;
         this.maxBatchSize = config.batchSize ?? DEFAULT_BATCH_SIZE;
         if (!config.openai?.apiKey) {
-            throw new Error('openai.apiKey is required when KTX embedding backend is openai');
+            throw new Error('openai.apiKey is required when ktx embedding backend is openai');
         }
         this.client = deps.createOpenAIClient
             ? deps.createOpenAIClient({ apiKey: config.openai.apiKey, baseURL: config.openai.baseURL })
@@ -90,7 +90,7 @@ class SentenceTransformersEmbeddingProvider {
     startupProbe;
     constructor(config, deps) {
         if (!config.sentenceTransformers?.baseURL) {
-            throw new Error('sentenceTransformers.baseURL is required when KTX embedding backend is sentence-transformers');
+            throw new Error('sentenceTransformers.baseURL is required when ktx embedding backend is sentence-transformers');
         }
         this.dimensions = config.dimensions;
         this.maxBatchSize = config.batchSize ?? DEFAULT_BATCH_SIZE;
@@ -156,6 +156,6 @@ export function createKtxEmbeddingProvider(config, deps = {}) {
         case 'sentence-transformers':
             return new SentenceTransformersEmbeddingProvider(config, deps);
         default:
-            throw new Error(`Unsupported KTX embedding backend: ${String(config.backend)}`);
+            throw new Error(`Unsupported ktx embedding backend: ${String(config.backend)}`);
     }
 }

package/dist/llm/model-provider.js

@@ -121,7 +121,7 @@ class DefaultKtxLlmProvider {
         }
         if (config.backend === 'vertex') {
             if (!config.vertex?.location) {
-                throw new Error('vertex.location is required when KTX LLM backend is vertex');
+                throw new Error('vertex.location is required when ktx LLM backend is vertex');
             }
             const vertex = (deps.createVertexAnthropic ?? createVertexAnthropic)({
                 ...(config.vertex.project ? { project: config.vertex.project } : {}),

package/dist/local-adapters.d.ts

@@ -5,6 +5,7 @@ import type { KtxLocalProject } from './context/project/project.js';
 import type { SqlAnalysisPort } from './context/sql-analysis/ports.js';
 import { type ManagedPythonDaemonHttpOptions } from './managed-python-http.js';
 import type { KtxOperationalLogger } from './io/logger.js';
+export declare function resolveKtxCliSqlAnalysis(options: KtxCliLocalIngestAdaptersOptions): SqlAnalysisPort;
 export interface KtxCliLocalIngestAdaptersOptions extends DefaultLocalIngestAdaptersOptions {
     historicSqlConnectionId?: string;
     sqlAnalysis?: SqlAnalysisPort;

package/dist/local-adapters.js

@@ -45,7 +45,7 @@ function ktxCliLookerOptions(options) {
         parser: createManagedDaemonLookerTableIdentifierParser(options.managedDaemon),
     };
 }
-function ktxCliHistoricSqlAnalysis(options) {
+export function resolveKtxCliSqlAnalysis(options) {
     if (options.sqlAnalysis) {
         return options.sqlAnalysis;
     }
@@ -234,7 +234,7 @@ function historicSqlOptionsForLocalRun(project, options) {
         return undefined;
     }
     const base = {
-        sqlAnalysis: ktxCliHistoricSqlAnalysis(options),
+        sqlAnalysis: resolveKtxCliSqlAnalysis(options),
     };
     if (dialect === 'postgres') {
         return {

package/dist/local-scan-connectors.js

@@ -11,7 +11,7 @@ export async function createKtxCliScanConnector(project, connectionId) {
     }
     const registration = getDriverRegistration(driver);
     if (!registration) {
-        throw new Error(`Connection "${connectionId}" uses driver "${driver}", which has no native standalone KTX scan connector. Supported drivers: ${SUPPORTED_DRIVERS}.`);
+        throw new Error(`Connection "${connectionId}" uses driver "${driver}", which has no native standalone ktx scan connector. Supported drivers: ${SUPPORTED_DRIVERS}.`);
     }
     const connectorModule = await registration.load();
     if (!connectorModule.isConnectionConfig(connection)) {

package/dist/managed-local-embeddings.js

@@ -1,4 +1,4 @@
-import { writePrefixedLines } from './clack.js';
+import { createCliSpinner } from './clack.js';
 import { ensureManagedPythonCommandRuntime, } from './managed-python-command.js';
 import { readManagedPythonDaemonStatus, startManagedPythonDaemon, } from './managed-python-daemon.js';
 export function managedLocalEmbeddingHealthConfig(input) {
@@ -21,14 +21,23 @@ export async function ensureManagedLocalEmbeddingsDaemon(options) {
         io: options.io,
         feature: 'local-embeddings',
     });
-    const daemon = await startDaemon({
-        cliVersion: options.cliVersion,
-        projectDir: options.projectDir,
-        features: ['local-embeddings'],
-        force: false,
-    });
+    const spinner = createCliSpinner(options.io);
+    spinner.start('Starting ktx embedding daemon (first run downloads the model)…');
+    let daemon;
+    try {
+        daemon = await startDaemon({
+            cliVersion: options.cliVersion,
+            projectDir: options.projectDir,
+            features: ['local-embeddings'],
+            force: false,
+        });
+    }
+    catch (error) {
+        spinner.error('ktx embedding daemon failed to start');
+        throw error;
+    }
     const verb = daemon.status === 'started' ? 'Started' : 'Using';
-    writePrefixedLines((chunk) => options.io.stderr.write(chunk), `${verb} KTX daemon: ${daemon.baseUrl}`);
+    spinner.stop(`${verb} ktx daemon: ${daemon.baseUrl}`);
     return {
         baseUrl: daemon.baseUrl,
         stdoutLog: daemon.state.stdoutLog,

package/dist/managed-mcp-daemon.js

@@ -92,7 +92,7 @@ export async function startKtxMcpDaemon(options) {
                 url: `http://${existing.host}:${existing.port}/mcp`,
             };
         }
-        throw new Error(`KTX MCP daemon is already running at http://${existing.host}:${existing.port}/mcp ` +
+        throw new Error(`ktx MCP daemon is already running at http://${existing.host}:${existing.port}/mcp ` +
             'with a different configuration. Run `ktx mcp stop` first, then start again.');
     }
     const portAvailable = options.portAvailable ?? defaultPortAvailable;
@@ -126,7 +126,7 @@ export async function startKtxMcpDaemon(options) {
             }),
         });
         if (!child.pid) {
-            throw new Error('Failed to start KTX MCP daemon: child process pid was not available.');
+            throw new Error('Failed to start ktx MCP daemon: child process pid was not available.');
         }
         child.unref();
         const state = {
@@ -167,7 +167,7 @@ export async function readKtxMcpDaemonStatus(options) {
     }
     return {
         kind: 'running',
-        detail: `KTX MCP daemon running at http://${state.host}:${state.port}/mcp`,
+        detail: `ktx MCP daemon running at http://${state.host}:${state.port}/mcp`,
         state,
         url: `http://${state.host}:${state.port}/mcp`,
     };

package/dist/managed-python-command.d.ts

@@ -31,4 +31,11 @@ export interface ManagedPythonSemanticLayerComputeOptions extends ManagedPythonC
 export declare function managedRuntimeInstallCommand(feature: KtxRuntimeFeature): string;
 export declare function ensureManagedPythonCommandRuntime(options: ManagedPythonCommandOptions): Promise<ManagedPythonCommandRuntime>;
 export declare function createManagedPythonSemanticLayerComputePort(options: ManagedPythonSemanticLayerComputeOptions): Promise<KtxSemanticLayerComputePort>;
+/**
+ * Defers the managed-runtime install to the first semantic-layer call so a
+ * long-lived server (the MCP server) can start and serve context tools that
+ * need no Python even when uv is absent. Caches on success only, so a runtime
+ * installed mid-session is picked up on the next call.
+ */
+export declare function createLazyManagedPythonSemanticLayerComputePort(options: ManagedPythonSemanticLayerComputeOptions): KtxSemanticLayerComputePort;
 export {};

package/dist/managed-python-command.js

@@ -1,5 +1,5 @@
 import { createPythonSemanticLayerComputePort } from './context/daemon/semantic-layer-compute.js';
-import { createClackPromptAdapter, createStaticCliSpinner } from './clack.js';
+import { createClackPromptAdapter, createCliSpinner } from './clack.js';
 import { installManagedPythonRuntime, readManagedPythonRuntimeStatus, } from './managed-python-runtime.js';
 import { readExistingTelemetryProjectId } from './telemetry/identity.js';
 export function runtimeInstallPolicyFromFlags(options) {
@@ -19,10 +19,10 @@ export function managedRuntimeInstallCommand(feature) {
 }
 function installPrompt(feature) {
     const label = feature === 'local-embeddings' ? 'local embeddings Python runtime' : 'core Python runtime';
-    return `KTX needs to install the ${label}. This downloads Python dependencies with uv. Continue?`;
+    return `ktx needs to install the ${label}. This downloads a pinned, checksum-verified uv build, Python, and dependencies. Continue?`;
 }
 function runtimeRequiredMessage(feature) {
-    return `KTX Python runtime is required for this command. Run: ${managedRuntimeInstallCommand(feature)}`;
+    return `ktx Python runtime is required for this command. Run: ${managedRuntimeInstallCommand(feature)}`;
 }
 function hasFeature(manifest, feature) {
     return manifest.features.includes(feature);
@@ -49,22 +49,22 @@ export async function ensureManagedPythonCommandRuntime(options) {
         const confirmInstall = options.confirmInstall ?? defaultConfirmInstall;
         const confirmed = await confirmInstall(installPrompt(feature), options.io);
         if (!confirmed) {
-            throw new Error(`KTX Python runtime installation was cancelled. Run: ${managedRuntimeInstallCommand(feature)}`);
+            throw new Error(`ktx Python runtime installation was cancelled. Run: ${managedRuntimeInstallCommand(feature)}`);
         }
     }
-    const progress = (options.spinner ?? (() => createStaticCliSpinner(options.io)))();
-    progress.start(`Installing KTX Python runtime (${feature}) with uv...`);
+    const progress = (options.spinner ?? (() => createCliSpinner(options.io)))();
+    progress.start(`Installing ktx Python runtime (${feature}) with uv...`);
     try {
         const installed = await installRuntime({
             cliVersion: options.cliVersion,
             features: [feature],
             force: false,
         });
-        progress.stop(`KTX Python runtime ready: ${installed.layout.versionDir}`);
+        progress.stop(`ktx Python runtime ready: ${installed.layout.versionDir}`);
         return { layout: installed.layout, manifest: installed.manifest };
     }
     catch (error) {
-        progress.error(`KTX Python runtime install failed: ${error instanceof Error ? error.message : String(error)}`);
+        progress.error(`ktx Python runtime install failed: ${error instanceof Error ? error.message : String(error)}`);
         throw error;
     }
 }
@@ -89,3 +89,29 @@ export async function createManagedPythonSemanticLayerComputePort(options) {
         ...(projectId ? { projectId } : {}),
     });
 }
+/**
+ * Defers the managed-runtime install to the first semantic-layer call so a
+ * long-lived server (the MCP server) can start and serve context tools that
+ * need no Python even when uv is absent. Caches on success only, so a runtime
+ * installed mid-session is picked up on the next call.
+ */
+export function createLazyManagedPythonSemanticLayerComputePort(options) {
+    let cached;
+    const resolve = async () => {
+        if (!cached) {
+            cached = await createManagedPythonSemanticLayerComputePort(options);
+        }
+        return cached;
+    };
+    return {
+        async query(input) {
+            return (await resolve()).query(input);
+        },
+        async validateSources(input) {
+            return (await resolve()).validateSources(input);
+        },
+        async generateSources(input) {
+            return (await resolve()).generateSources(input);
+        },
+    };
+}

package/dist/managed-python-daemon.js

@@ -11,7 +11,7 @@ export class ManagedPythonDaemonStartError extends Error {
     detail;
     stderrLog;
     constructor(detail, stderrLog) {
-        super(`KTX daemon failed to start: ${detail}. stderr: ${stderrLog}`);
+        super(`ktx daemon failed to start: ${detail}. stderr: ${stderrLog}`);
         this.name = 'ManagedPythonDaemonStartError';
         this.detail = detail;
         this.stderrLog = stderrLog;
@@ -502,7 +502,7 @@ export async function startManagedPythonDaemon(options) {
         });
         child.unref();
         if (!child.pid) {
-            throw new Error(`KTX daemon did not report a pid. stderr: ${layout.daemonStderrPath}`);
+            throw new Error(`ktx daemon did not report a pid. stderr: ${layout.daemonStderrPath}`);
         }
         const state = {
             schemaVersion: 1,

package/dist/managed-python-http.js

@@ -12,7 +12,7 @@ function normalizedBaseUrl(baseUrl) {
 function parseJsonObject(raw, path) {
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        throw new Error(`KTX daemon HTTP ${path} returned non-object JSON`);
+        throw new Error(`ktx daemon HTTP ${path} returned non-object JSON`);
     }
     return parsed;
 }
@@ -35,7 +35,7 @@ async function postManagedDaemonJson(baseUrl, path, payload) {
                 const text = Buffer.concat(chunks).toString('utf8');
                 const statusCode = response.statusCode ?? 0;
                 if (statusCode < 200 || statusCode >= 300) {
-                    reject(new Error(`KTX daemon HTTP ${path} failed with ${statusCode}: ${text}`));
+                    reject(new Error(`ktx daemon HTTP ${path} failed with ${statusCode}: ${text}`));
                     return;
                 }
                 try {
@@ -72,7 +72,7 @@ export function createManagedPythonDaemonBaseUrlResolver(options) {
             force: false,
         });
         const verb = daemon.status === 'started' ? 'Started' : 'Using existing';
-        writePrefixedLines((chunk) => options.io.stderr.write(chunk), `${verb} KTX daemon: ${daemon.baseUrl}`);
+        writePrefixedLines((chunk) => options.io.stderr.write(chunk), `${verb} ktx daemon: ${daemon.baseUrl}`);
         cachedBaseUrl = daemon.baseUrl;
         return cachedBaseUrl;
     };

package/dist/managed-python-runtime.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { type ManagedUvArtifact, type ManagedUvPlatformKey } from './managed-uv-release.js';
 export declare const runtimeFeatureSchema: z.ZodEnum<{
     core: "core";
     "local-embeddings": "local-embeddings";
@@ -92,6 +93,7 @@ export interface ManagedPythonRuntimeInstallOptions extends ManagedPythonRuntime
     features: KtxRuntimeFeature[];
     force?: boolean;
     exec?: ManagedPythonRuntimeExec;
+    fetchUvArtifact?: ManagedUvFetchArtifact;
 }
 export interface ManagedPythonRuntimeInstallResult {
     status: 'ready' | 'installed';
@@ -113,8 +115,22 @@ export interface ManagedPythonRuntimeDoctorCheck {
     detail: string;
     fix?: string;
 }
+export type ManagedUvFetchArtifact = (url: string) => Promise<Uint8Array>;
 /** @internal */
-export declare const MISSING_UV_RUNTIME_INSTALL_MESSAGE = "uv is required to install the KTX Python runtime. KTX does not download uv automatically. Install uv, make sure it is on PATH, and retry: ktx admin runtime install --yes";
+export interface ManagedUvRelease {
+    version: string;
+    artifacts: Partial<Record<ManagedUvPlatformKey, ManagedUvArtifact>>;
+}
+/** @internal */
+export interface EnsureManagedUvOptions {
+    platform?: NodeJS.Platform;
+    arch?: string;
+    env?: NodeJS.ProcessEnv;
+    homeDir?: string;
+    runtimeRoot?: string;
+    fetchArtifact?: ManagedUvFetchArtifact;
+    release?: ManagedUvRelease;
+}
 /** @internal */
 export declare function managedPythonRuntimeLayout(options: ManagedPythonRuntimeLayoutOptions): ManagedPythonRuntimeLayout;
 export declare function managedPythonDaemonLayout(options: ManagedPythonDaemonLayoutOptions): ManagedPythonDaemonLayout;
@@ -122,9 +138,22 @@ export declare function managedPythonDaemonLayout(options: ManagedPythonDaemonLa
 export declare function verifyRuntimeAsset(input: {
     assetDir: string;
 }): Promise<ManagedRuntimeAsset>;
+/** @internal */
+export declare function managedUvPath(options?: EnsureManagedUvOptions): string;
+/**
+ * ktx provisions its own pinned uv under the runtime root; uv on PATH is never
+ * consulted, so runtime installs behave identically on every machine. All
+ * failures here are environment outcomes (offline host, intercepting proxy,
+ * unsupported platform) and stay out of Error Tracking via KtxExpectedError —
+ * except a pin/layout mismatch inside a checksum-verified archive, which is a
+ * ktx release fault and must reach Error Tracking.
+ * @internal
+ */
+export declare function ensureManagedUv(options?: EnsureManagedUvOptions): Promise<string>;
 export declare function installManagedPythonRuntime(options: ManagedPythonRuntimeInstallOptions): Promise<ManagedPythonRuntimeInstallResult>;
 export declare function readManagedPythonRuntimeStatus(options: ManagedPythonRuntimeLayoutOptions): Promise<ManagedPythonRuntimeStatus>;
 export declare function doctorManagedPythonRuntime(options: ManagedPythonRuntimeLayoutOptions & {
     exec?: ManagedPythonRuntimeExec;
+    fetchUvArtifact?: ManagedUvFetchArtifact;
 }): Promise<ManagedPythonRuntimeDoctorCheck[]>;
 export {};