@alisio/core 0.5.2 → 0.7.0

package/dist/forge/catalog-view.js

@@ -0,0 +1,43 @@
+import { effectOf } from "../permissions/decide.js";
+export const CATALOG_DEFAULT_LIMIT = 10;
+export const CATALOG_MAX_LIMIT = 25;
+const SUMMARY_CHARS = 160;
+/** The first sentence of a description, bounded. */
+export function summarize(description) {
+    const flat = description.replace(/\s+/g, " ").trim();
+    const end = flat.search(/[.!?](\s|$)/);
+    const sentence = end >= 0 ? flat.slice(0, end + 1) : flat;
+    return sentence.length > SUMMARY_CHARS ? `${sentence.slice(0, SUMMARY_CHARS - 1)}…` : sentence;
+}
+const terms = (query) => query
+    .toLowerCase()
+    .split(/[^a-z0-9_]+/)
+    .filter(Boolean);
+/** Tools whose name or description holds every term of the query (all of them for an empty query). */
+export function searchCatalog(tools, query, limit = CATALOG_DEFAULT_LIMIT) {
+    const wanted = terms(query);
+    const bounded = Math.max(1, Math.min(Math.floor(limit), CATALOG_MAX_LIMIT));
+    return tools
+        .filter((tool) => {
+        const haystack = `${tool.name} ${tool.description}`.toLowerCase();
+        return wanted.every((term) => haystack.includes(term));
+    })
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .slice(0, bounded)
+        .map((tool) => ({
+        name: tool.name,
+        effect: effectOf(tool),
+        summary: summarize(tool.description),
+    }));
+}
+export function describeTool(tools, name) {
+    const tool = tools.find((candidate) => candidate.name === name);
+    if (!tool)
+        return undefined;
+    return {
+        name: tool.name,
+        effect: effectOf(tool),
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+    };
+}

package/dist/forge/errors.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Forja error codes and the error type that carries them. Pure: no I/O. The Python specification
+ * adds its own codes with the same shape.
+ */
+export declare const FORGE_ERROR_CODES: readonly ["INVALID_INPUT", "ENGINE_UNAVAILABLE", "SCRIPT_SYNTAX", "SCRIPT_RUNTIME", "PERMISSION_DENIED", "APPROVAL_REQUIRED", "TOOL_UNAVAILABLE", "TOOL_INPUT_INVALID", "TOOL_FAILED", "BUDGET_EXCEEDED", "OUTPUT_LIMIT", "MEMORY_LIMIT", "STACK_LIMIT", "TIMEOUT", "CANCELLED", "STATE_CONFLICT", "PROTOCOL_VIOLATION", "UNRESOLVABLE_PROMISE", "ISOLATE_FAILURE", 
+/** Python: the artifact publisher refused the files the script left (symlink, size, count). */
+"PUBLICATION_REJECTED"];
+export type ForgeErrorCode = (typeof FORGE_ERROR_CODES)[number];
+/** Points the model at the guide topic that explains how to recover from an error. */
+export interface GuideHint {
+    topic: string;
+    reason: string;
+}
+/**
+ * The one-line pointer the model reads (spec §8.4): the reason and the guide topic to call, never the
+ * guide itself. An anchor (`js.patterns#filtering`) names a section of the topic.
+ */
+export declare function renderHint(hint: GuideHint): string;
+export declare class ForgeError extends Error {
+    readonly code: ForgeErrorCode;
+    readonly hint?: GuideHint;
+    constructor(code: ForgeErrorCode, message: string, options?: {
+        hint?: GuideHint;
+    });
+}
+export declare function isForgeError(value: unknown): value is ForgeError;

package/dist/forge/errors.js

@@ -0,0 +1,49 @@
+/**
+ * Forja error codes and the error type that carries them. Pure: no I/O. The Python specification
+ * adds its own codes with the same shape.
+ */
+export const FORGE_ERROR_CODES = [
+    "INVALID_INPUT",
+    "ENGINE_UNAVAILABLE",
+    "SCRIPT_SYNTAX",
+    "SCRIPT_RUNTIME",
+    "PERMISSION_DENIED",
+    "APPROVAL_REQUIRED",
+    "TOOL_UNAVAILABLE",
+    "TOOL_INPUT_INVALID",
+    "TOOL_FAILED",
+    "BUDGET_EXCEEDED",
+    "OUTPUT_LIMIT",
+    "MEMORY_LIMIT",
+    "STACK_LIMIT",
+    "TIMEOUT",
+    "CANCELLED",
+    "STATE_CONFLICT",
+    "PROTOCOL_VIOLATION",
+    "UNRESOLVABLE_PROMISE",
+    "ISOLATE_FAILURE",
+    /** Python: the artifact publisher refused the files the script left (symlink, size, count). */
+    "PUBLICATION_REJECTED",
+];
+/**
+ * The one-line pointer the model reads (spec §8.4): the reason and the guide topic to call, never the
+ * guide itself. An anchor (`js.patterns#filtering`) names a section of the topic.
+ */
+export function renderHint(hint) {
+    const [topic = hint.topic, anchor] = hint.topic.split("#");
+    return `${hint.reason} (forge_guide topic "${topic}"${anchor ? `, section #${anchor}` : ""})`;
+}
+export class ForgeError extends Error {
+    code;
+    hint;
+    constructor(code, message, options = {}) {
+        super(message);
+        this.name = "ForgeError";
+        this.code = code;
+        if (options.hint)
+            this.hint = options.hint;
+    }
+}
+export function isForgeError(value) {
+    return value instanceof ForgeError;
+}

package/dist/forge/guides/javascript.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The JavaScript topics of `forge_guide` (spec §8.3): `js.api`, `js.patterns` and `js.tools`. Pure
+ * functions of the engine's live state (effective limits, host) and, for `js.tools`, of the tools
+ * a script can call right now. No I/O here; the provider gathers the state.
+ */
+import type { IsolationLevel } from "@alisio/sdk";
+import type { ForgeLimits } from "../limits.ts";
+/** What the guide needs to know about the running JavaScript engine. */
+export interface JavascriptGuideState {
+    /** Engine build, e.g. `quickjs-wasi@3.6.2`. */
+    version: string;
+    isolation: IsolationLevel;
+    host: "worker" | "process";
+    limits: ForgeLimits;
+}
+/** One line of the permission-filtered catalog summary. */
+export interface CatalogSummaryEntry {
+    name: string;
+    effect: string;
+}
+/** The most entries `js.tools` lists (spec §8.3). */
+export declare const TOOLS_GUIDE_MAX_ENTRIES = 40;
+export declare function jsApiGuide(state: JavascriptGuideState): string;
+export declare function jsPatternsGuide(state: JavascriptGuideState): string;
+export declare function jsToolsGuide(catalog: readonly CatalogSummaryEntry[] | undefined): string;

package/dist/forge/guides/javascript.js

@@ -0,0 +1,90 @@
+/** The most entries `js.tools` lists (spec §8.3). */
+export const TOOLS_GUIDE_MAX_ENTRIES = 40;
+const KiB = 1024;
+const MiB = 1024 * KiB;
+const size = (bytes) => bytes >= MiB && bytes % MiB === 0
+    ? `${bytes / MiB} MiB`
+    : bytes >= KiB
+        ? `${Math.round(bytes / KiB)} KiB`
+        : `${bytes} B`;
+const seconds = (ms) => `${Math.round((ms / 1000) * 10) / 10} s`;
+export function jsApiGuide(state) {
+    const l = state.limits;
+    const where = state.host === "worker" ? "a worker thread of this process" : "a child process of this program";
+    return [
+        `# js_run API (${state.version})`,
+        "",
+        `Isolation: ${state.isolation}. A fresh VM per run, hosted in ${where}. No imports, require, network, files, timers or WebAssembly. The body is an async function: use await and \`return\` a small JSON value.`,
+        "",
+        "## Globals",
+        "- `tools.call(name, input?)`: call another tool; resolves to its JSON result (or its text), rejects with an error that has `code` and `message`. `callTool` is the same.",
+        "- `catalog.search(query, {limit?})`: `[{name, effect, summary}]`. `catalog.describe(name)`: `{name, effect, description, inputSchema}`. Call it before using a tool you do not know.",
+        "- `state.get(key)`, `state.set(key, value)`, `state.delete(key)`: small JSON kept for later runs of this session; committed only if the run succeeds.",
+        "- `text(value)`: explicit output for the model. `progress({message, completed?, total?})`: live progress. `console.log/warn/error` go to the output too.",
+        "- `parallel.map(items, fn, {concurrency?})`: results in input order; no new item starts after the first failure and it rejects with that error. `parallel.settle(...)`: every result as `{ok:true,value}` or `{ok:false,error:{code,message}}`.",
+        "",
+        "## Effective limits now",
+        `- Time ${seconds(l.timeoutMs)} per run (\`timeoutMs\` can only lower it); heap ${size(l.memoryBytes)}; stack ${size(l.stackBytes)}; source ${size(l.maxSourceBytes)}.`,
+        `- Nested calls: ${l.maxToolCalls} per run, ${l.maxConcurrency} at once (\`Promise.all\` does not avoid this); input ${size(l.maxCallInputBytes)}, response ${size(l.maxCallResponseBytes)} each.`,
+        `- Returned to you: at most ${l.maxOutputChars} characters (\`OUTPUT_LIMIT\` beyond that); retained output ${size(l.maxRetainedOutputBytes)}.`,
+        "",
+        "## Permissions",
+        "Nested calls pass the same gate as a direct call of this session and never open an approval: a tool that needs one fails with `APPROVAL_REQUIRED`; call it directly instead. `js.tools` lists what is callable now.",
+        "",
+        "## Errors you can catch",
+        "`TOOL_UNAVAILABLE`, `TOOL_INPUT_INVALID`, `TOOL_FAILED`, `PERMISSION_DENIED`, `APPROVAL_REQUIRED`, `BUDGET_EXCEEDED`, `OUTPUT_LIMIT`. Anything else a script throws is `SCRIPT_RUNTIME`.",
+    ].join("\n");
+}
+export function jsPatternsGuide(state) {
+    const l = state.limits;
+    return [
+        "# js_run patterns",
+        "",
+        "## #filtering",
+        `Filter, aggregate or count INSIDE the script and return the result, not the data: the model sees at most ${l.maxOutputChars} characters.`,
+        "```js",
+        'const rows = await tools.call("<tool>", { /* input */ });  // check the shape with catalog.describe',
+        "const big = rows.filter((r) => r.size > 1000);",
+        "return { total: rows.length, big: big.length, sample: big.slice(0, 5) };",
+        "```",
+        "",
+        "## #parallel",
+        `Use \`parallel.map(items, fn, {concurrency: 4})\` for independent reads: up to ${l.maxConcurrency} run at once, ${l.maxToolCalls} in total. It stops at the first failure. Use \`parallel.settle\` when partial results are fine and report the failed ones.`,
+        "```js",
+        'const results = await parallel.settle(paths, (p) => tools.call("read_file", { path: p, limit: 50 }));',
+        "return results.map((r, i) => (r.ok ? { path: paths[i], ok: true } : { path: paths[i], error: r.error.code }));",
+        "```",
+        "",
+        "## #pagination",
+        "Loop until the tool says there is no more, and keep only what you need from each page. Count calls: the budget is shared by the whole run.",
+        "",
+        "## #state",
+        "`state.set('cursor', value)` survives to the next run, but only when this run succeeds. Keep it small JSON; large data belongs in a scratchpad file.",
+        "",
+        "## #files",
+        "Scripts cannot touch files. To keep a long script, write it to the scratchpad with the file tools and run it with `js_run` `codePath` (a .js file); edit it between runs instead of resending the code. Intermediate results go to scratchpad files the same way.",
+        "",
+        "## #errors",
+        "Wrap risky calls in try/catch and return `{ error: e.code }`. A script that throws ends the run; one that returns a value is a success even if some calls failed (check `calls` in the result).",
+    ].join("\n");
+}
+export function jsToolsGuide(catalog) {
+    const head = ["# Tools a script can call now", ""];
+    if (!catalog)
+        return [
+            ...head,
+            "The tool list depends on the live session and is not available here. Inside a script, `await catalog.search('')` lists what is callable and `await catalog.describe(name)` gives the schema.",
+        ].join("\n");
+    const sorted = [...catalog].sort((a, b) => a.name.localeCompare(b.name));
+    const shown = sorted.slice(0, TOOLS_GUIDE_MAX_ENTRIES);
+    const more = sorted.length - shown.length;
+    return [
+        ...head,
+        `Only tools this session's permissions allow without asking are listed (${sorted.length}). Others fail with \`APPROVAL_REQUIRED\` or \`PERMISSION_DENIED\`; call those directly.`,
+        "",
+        ...shown.map((tool) => `- ${tool.name} (${tool.effect})`),
+        ...(more > 0 ? [`- ... and ${more} more: use \`catalog.search(query)\``] : []),
+        "",
+        "Details and input schemas: `await catalog.describe(name)` inside the script. Never reachable from a script: `js_run`, `forge_guide`, `task`, `task_wait`, `send_message`, `ask_user_question`. `python_run` only when this run allows analysis or process effects.",
+    ].join("\n");
+}

package/dist/forge/guides/provider.d.ts

@@ -0,0 +1,42 @@
+import { type CatalogSummaryEntry, type JavascriptGuideState } from "./javascript.ts";
+import { type PythonEnvironment } from "./python.ts";
+export declare const JS_GUIDE_TOPICS: readonly ["js.api", "js.patterns", "js.tools"];
+export declare const PYTHON_GUIDE_TOPICS: readonly ["python.runtime", "python.data", "python.ml", "python.dashboards", "python.environment"];
+export declare const GUIDE_TOPICS: readonly ["js.api", "js.patterns", "js.tools", "python.runtime", "python.data", "python.ml", "python.dashboards", "python.environment"];
+export type GuideTopic = (typeof GUIDE_TOPICS)[number];
+/** Hard bound of one topic (spec §8.3). */
+export declare const GUIDE_MAX_BYTES = 4096;
+/** Characters of the SHA-256 kept as the etag. */
+export declare const ETAG_LENGTH = 16;
+export interface GuideSources {
+    /** Present when the JavaScript engine is ready; its absence removes the `js.*` topics. */
+    javascript?: () => Promise<JavascriptGuideState>;
+    /** Present when `python_run` is registered; its absence removes the `python.*` topics. */
+    python?: () => Promise<PythonEnvironment>;
+}
+export type GuideResponse = {
+    unchanged: true;
+    etag: string;
+} | {
+    unchanged: false;
+    topic: GuideTopic;
+    etag: string;
+    content: string;
+};
+export interface GuideRequest {
+    topic: string;
+    ifNoneMatch?: string | undefined;
+    /** The tools a script can call right now (for `js.tools`). */
+    catalog?: readonly CatalogSummaryEntry[] | undefined;
+}
+export declare class UnknownGuideTopicError extends Error {
+    constructor(topic: string, available: readonly string[]);
+}
+export declare const etagOf: (content: string) => string;
+export declare class GuideProvider {
+    #private;
+    constructor(sources: GuideSources);
+    /** The topics that exist now: the JavaScript ones with a ready engine, the Python ones with `python_run`. */
+    topics(): GuideTopic[];
+    get(request: GuideRequest): Promise<GuideResponse>;
+}

package/dist/forge/guides/provider.js

@@ -0,0 +1,96 @@
+/**
+ * `GuideProvider` (spec §8.3, D12, Lazy Load): layer 2 of the incremental context. Each topic is
+ * generated on request from the live state of the engines, so a guide never describes a limit, a
+ * package or a guarantee the engine does not have right now. Nothing is built at construction.
+ * Every topic is at most 4 KiB and carries an `etag` (truncated SHA-256 of its content); a caller
+ * that already holds the same etag gets `{ unchanged: true }`.
+ */
+import { createHash } from "node:crypto";
+import { jsApiGuide, jsPatternsGuide, jsToolsGuide, } from "./javascript.js";
+import { pythonDashboardsGuide, pythonDataGuide, pythonEnvironmentGuide, pythonMlGuide, pythonRuntimeGuide, } from "./python.js";
+export const JS_GUIDE_TOPICS = ["js.api", "js.patterns", "js.tools"];
+export const PYTHON_GUIDE_TOPICS = [
+    "python.runtime",
+    "python.data",
+    "python.ml",
+    "python.dashboards",
+    "python.environment",
+];
+export const GUIDE_TOPICS = [...JS_GUIDE_TOPICS, ...PYTHON_GUIDE_TOPICS];
+/** Hard bound of one topic (spec §8.3). */
+export const GUIDE_MAX_BYTES = 4096;
+/** Characters of the SHA-256 kept as the etag. */
+export const ETAG_LENGTH = 16;
+export class UnknownGuideTopicError extends Error {
+    constructor(topic, available) {
+        super(`Unknown guide topic "${topic}". Available: ${available.join(", ")}`);
+        this.name = "UnknownGuideTopicError";
+    }
+}
+export const etagOf = (content) => createHash("sha256").update(content).digest("hex").slice(0, ETAG_LENGTH);
+/** Cuts to the byte bound on a character boundary, saying so. */
+function bounded(content) {
+    if (Buffer.byteLength(content) <= GUIDE_MAX_BYTES)
+        return content;
+    const note = "\n[guide cut at 4 KiB]";
+    let out = content;
+    while (Buffer.byteLength(out) + Buffer.byteLength(note) > GUIDE_MAX_BYTES)
+        out = out.slice(0, -64);
+    return out + note;
+}
+export class GuideProvider {
+    #sources;
+    constructor(sources) {
+        this.#sources = sources;
+    }
+    /** The topics that exist now: the JavaScript ones with a ready engine, the Python ones with `python_run`. */
+    topics() {
+        return [
+            ...(this.#sources.javascript ? JS_GUIDE_TOPICS : []),
+            ...(this.#sources.python ? PYTHON_GUIDE_TOPICS : []),
+        ];
+    }
+    async get(request) {
+        const available = this.topics();
+        const topic = available.find((candidate) => candidate === request.topic);
+        if (!topic)
+            throw new UnknownGuideTopicError(request.topic, available);
+        const content = bounded(await this.#render(topic, request));
+        const etag = etagOf(content);
+        if (request.ifNoneMatch !== undefined && request.ifNoneMatch === etag)
+            return { unchanged: true, etag };
+        return { unchanged: false, topic, etag, content };
+    }
+    async #render(topic, request) {
+        switch (topic) {
+            case "js.api":
+                return jsApiGuide(await this.#js());
+            case "js.patterns":
+                return jsPatternsGuide(await this.#js());
+            case "js.tools":
+                return jsToolsGuide(request.catalog);
+            case "python.runtime":
+                return pythonRuntimeGuide(await this.#py());
+            case "python.data":
+                return pythonDataGuide(await this.#py());
+            case "python.ml":
+                return pythonMlGuide(await this.#py());
+            case "python.dashboards":
+                return pythonDashboardsGuide(await this.#py());
+            case "python.environment":
+                return pythonEnvironmentGuide(await this.#py());
+        }
+    }
+    #js() {
+        const source = this.#sources.javascript;
+        if (!source)
+            throw new Error("the JavaScript engine is not available");
+        return source();
+    }
+    #py() {
+        const source = this.#sources.python;
+        if (!source)
+            throw new Error("python_run is not available");
+        return source();
+    }
+}

package/dist/forge/guides/python-environment.d.ts

@@ -0,0 +1,15 @@
+import type { PythonBackend, PythonBackendId } from "../python/backend.ts";
+import { type IsolationPolicy, type PythonRuntimeSetting } from "../python/backend-selector.ts";
+import type { PythonEnvironment } from "./python.ts";
+export interface PythonEnvironmentDeps {
+    backends: Partial<Record<PythonBackendId, PythonBackend>>;
+    /** `analysis.runtime`, read live. */
+    runtime(): PythonRuntimeSetting;
+    /** `analysis.isolation`, read live. */
+    isolation(): IsolationPolicy;
+    /** The extras installed in the managed virtual environment (`analysis`, `science`). */
+    managedExtras(): Promise<readonly string[]>;
+    /** `analysis.smartDashboard`. */
+    smartDashboard(): boolean;
+}
+export declare function probePythonEnvironment(deps: PythonEnvironmentDeps, signal?: AbortSignal): Promise<PythonEnvironment>;

package/dist/forge/guides/python-environment.js

@@ -0,0 +1,81 @@
+/**
+ * Gathers the `PythonEnvironment` snapshot the Python guides are written from: the backend the
+ * selector would choose RIGHT NOW (same chain, same settings as `python_run`, no script known) and
+ * the packages that backend really has. It probes readiness like a call would and never starts a
+ * script or installs anything.
+ */
+import { EXTRAS_DISTRIBUTIONS } from "../../analysis/requirements.js";
+import { isForgeError } from "../errors.js";
+import { createPythonBackendSelector, neededBackends, } from "../python/backend-selector.js";
+import { PYODIDE_PROFILE_ORDER, PYODIDE_PROFILES } from "../python/pyodide-manifest.js";
+const selector = createPythonBackendSelector();
+async function packagesOf(backend, deps) {
+    if (backend.id === "wasm") {
+        const installed = (await backend.describe()).profiles ?? [];
+        const top = PYODIDE_PROFILE_ORDER.filter((profile) => installed.includes(profile)).at(-1);
+        return top
+            ? {
+                known: true,
+                packages: [...PYODIDE_PROFILES[top]],
+                detail: `Pyodide profile "${top}" is installed (profiles: ${installed.join(", ")}).`,
+            }
+            : { known: true, packages: [], detail: "No Pyodide package profile is installed (base)." };
+    }
+    if (backend.id === "managed") {
+        const extras = await deps.managedExtras();
+        const top = extras.includes("science")
+            ? "science"
+            : extras.includes("analysis")
+                ? "analysis"
+                : undefined;
+        return top
+            ? {
+                known: true,
+                packages: [...EXTRAS_DISTRIBUTIONS[top]],
+                detail: `The "${top}" extras are installed in the managed environment.`,
+            }
+            : {
+                known: true,
+                packages: [],
+                detail: "No extras are installed; pass `extras` to ask the user to install them.",
+            };
+    }
+    return {
+        known: false,
+        detail: "A container has the packages of its image; scripts cannot install anything (no network).",
+    };
+}
+export async function probePythonEnvironment(deps, signal) {
+    const runtime = deps.runtime();
+    const isolation = deps.isolation();
+    const smartDashboard = deps.smartDashboard();
+    const wanted = neededBackends({ runtime, isolation });
+    const readiness = {};
+    const networkDenied = {};
+    await Promise.all(wanted.map(async (id) => {
+        const backend = deps.backends[id];
+        readiness[id] = backend
+            ? await backend.check(signal)
+            : { ready: false, reason: `${id} is not available here` };
+        if (backend && readiness[id]?.ready && isolation === "strict")
+            networkDenied[id] = (await backend.describe()).capabilities.networkDeniedByOS;
+    }));
+    try {
+        const chosen = selector.select({ runtime, isolation, readiness, networkDenied });
+        const backend = deps.backends[chosen.engine];
+        if (!backend)
+            return { available: false, reason: `${chosen.engine} is not available here`, smartDashboard };
+        return {
+            available: true,
+            backend: chosen.engine,
+            reason: chosen.reason,
+            packages: await packagesOf(backend, deps),
+            smartDashboard,
+        };
+    }
+    catch (error) {
+        if (!isForgeError(error))
+            throw error;
+        return { available: false, reason: error.message, smartDashboard };
+    }
+}

package/dist/forge/guides/python.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The Python topics of `forge_guide` (spec §8.3; Python spec §4.3, §6, §7, §8): `python.runtime`,
+ * `python.data`, `python.ml`, `python.dashboards` and `python.environment`. Pure functions of a
+ * `PythonEnvironment` snapshot: the backend the selector would choose right now and what that
+ * backend really provides. No guide ever claims a guarantee the chosen backend does not give.
+ */
+import type { PythonBackendId } from "../python/backend.ts";
+export type PackageKnowledge = 
+/** The packages this backend provides right now (a distribution name each). */
+{
+    known: true;
+    packages: string[];
+    detail: string;
+}
+/** The backend's packages cannot be listed from here (a container image). */
+ | {
+    known: false;
+    detail: string;
+};
+export type PythonEnvironment = {
+    available: true;
+    backend: PythonBackendId;
+    /** Why the selector chose it (its own `reason`). */
+    reason: string;
+    packages: PackageKnowledge;
+    /** `analysis.smartDashboard`: `dashboard_generate` exists. */
+    smartDashboard: boolean;
+} | {
+    available: false;
+    /** The selector's message: every backend's reason and the shortest fix. */
+    reason: string;
+    smartDashboard: boolean;
+};
+export declare function pythonRuntimeGuide(env: PythonEnvironment): string;
+export declare function pythonDataGuide(env: PythonEnvironment): string;
+export declare function pythonMlGuide(env: PythonEnvironment): string;
+export declare function pythonDashboardsGuide(env: PythonEnvironment): string;
+export declare function pythonEnvironmentGuide(env: PythonEnvironment): string;