@alisio/core 0.5.1 → 0.6.0

package/dist/config.d.ts

@@ -196,9 +196,22 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         smartDashboard: z.ZodDefault<z.ZodBoolean>;
         runtime: z.ZodDefault<z.ZodEnum<{
+            auto: "auto";
             managed: "managed";
             oci: "oci";
+            wasm: "wasm";
         }>>;
+        isolation: z.ZodDefault<z.ZodEnum<{
+            preferred: "preferred";
+            required: "required";
+            strict: "strict";
+        }>>;
+        wasm: z.ZodDefault<z.ZodObject<{
+            memoryMb: z.ZodDefault<z.ZodNumber>;
+            startupMs: z.ZodDefault<z.ZodNumber>;
+            maxInputBytes: z.ZodDefault<z.ZodNumber>;
+            nodePath: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>;
         oci: z.ZodDefault<z.ZodObject<{
             engine: z.ZodDefault<z.ZodEnum<{
                 docker: "docker";
@@ -255,6 +268,35 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
         active: z.ZodDefault<z.ZodString>;
         effort: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
+    forge: z.ZodDefault<z.ZodObject<{
+        javascript: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            host: z.ZodDefault<z.ZodEnum<{
+                auto: "auto";
+                process: "process";
+                worker: "worker";
+            }>>;
+            timeoutMs: z.ZodDefault<z.ZodNumber>;
+            memoryBytes: z.ZodDefault<z.ZodNumber>;
+            stackBytes: z.ZodDefault<z.ZodNumber>;
+            maxToolCalls: z.ZodDefault<z.ZodNumber>;
+            maxConcurrency: z.ZodDefault<z.ZodNumber>;
+            maxOutputChars: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        state: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            maxTotalBytes: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        scratch: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            root: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            retentionDays: z.ZodDefault<z.ZodNumber>;
+            maxBytes: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        guides: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
     web: z.ZodDefault<z.ZodObject<{
         iconTheme: z.ZodDefault<z.ZodString>;
     }, z.core.$strict>>;
@@ -325,7 +367,14 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
     analysis: {
         enabled: boolean;
         smartDashboard: boolean;
-        runtime: "managed" | "oci";
+        runtime: "auto" | "managed" | "oci" | "wasm";
+        isolation: "preferred" | "required" | "strict";
+        wasm: {
+            memoryMb: number;
+            startupMs: number;
+            maxInputBytes: number;
+            nodePath: string | null;
+        };
         oci: {
             engine: "docker" | "podman";
             image?: string | undefined;
@@ -379,6 +428,31 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
         active: string;
         effort?: string | undefined;
     };
+    forge: {
+        javascript: {
+            enabled: boolean;
+            host: "auto" | "process" | "worker";
+            timeoutMs: number;
+            memoryBytes: number;
+            stackBytes: number;
+            maxToolCalls: number;
+            maxConcurrency: number;
+            maxOutputChars: number;
+        };
+        state: {
+            enabled: boolean;
+            maxTotalBytes: number;
+        };
+        scratch: {
+            enabled: boolean;
+            root: string | null;
+            retentionDays: number;
+            maxBytes: number;
+        };
+        guides: {
+            enabled: boolean;
+        };
+    };
     web: {
         iconTheme: string;
     };
@@ -532,7 +606,14 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
     analysis: {
         enabled: boolean;
         smartDashboard: boolean;
-        runtime: "managed" | "oci";
+        runtime: "auto" | "managed" | "oci" | "wasm";
+        isolation: "preferred" | "required" | "strict";
+        wasm: {
+            memoryMb: number;
+            startupMs: number;
+            maxInputBytes: number;
+            nodePath: string | null;
+        };
         oci: {
             engine: "docker" | "podman";
             image?: string | undefined;
@@ -586,6 +667,31 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
         active: string;
         effort?: string | undefined;
     };
+    forge: {
+        javascript: {
+            enabled: boolean;
+            host: "auto" | "process" | "worker";
+            timeoutMs: number;
+            memoryBytes: number;
+            stackBytes: number;
+            maxToolCalls: number;
+            maxConcurrency: number;
+            maxOutputChars: number;
+        };
+        state: {
+            enabled: boolean;
+            maxTotalBytes: number;
+        };
+        scratch: {
+            enabled: boolean;
+            root: string | null;
+            retentionDays: number;
+            maxBytes: number;
+        };
+        guides: {
+            enabled: boolean;
+        };
+    };
     web: {
         iconTheme: string;
     };
@@ -705,6 +811,8 @@ declare const SETTABLE_KEYS: {
     readonly "plan.diagrams": z.ZodDefault<z.ZodBoolean>;
     readonly "plan.maxDiagrams": z.ZodDefault<z.ZodNumber>;
     readonly "web.iconTheme": z.ZodDefault<z.ZodString>;
+    readonly "forge.javascript.enabled": z.ZodDefault<z.ZodBoolean>;
+    readonly "forge.guides.enabled": z.ZodDefault<z.ZodBoolean>;
 };
 export type SettableSettingKey = keyof typeof SETTABLE_KEYS;
 export declare function isSettableSettingKey(key: string): key is SettableSettingKey;

package/dist/config.js

@@ -3,6 +3,7 @@ import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { z } from "zod";
 import { DEFAULT_DECISIONS_CONFIG } from "./decisions/service.js";
+import { DEFAULT_FORGE_LIMITS, MAX_FORGE_LIMITS } from "./forge/limits.js";
 import { exists, readJson } from "./runtime/fs.js";
 import { isPathSpec } from "./runtime/modules.js";
 const providerSchema = z
@@ -82,7 +83,42 @@ const serversSchema = (value) => z.record(z.string(), value).superRefine((server
  */
 export const OCI_IMAGE_PATTERN = /^[a-zA-Z0-9][^\s@]*@sha256:[a-f0-9]{64}$/;
 /** Analysis keys only the user (global) layer decides; a project layer cannot set them. */
-const GLOBAL_ONLY_ANALYSIS = ["runtime", "oci", "retention"];
+const GLOBAL_ONLY_ANALYSIS = ["runtime", "isolation", "oci", "wasm", "retention"];
+/**
+ * Forja keys only the user (global) layer decides (spec §10). A project may still lower
+ * `timeoutMs`, `maxToolCalls`, `maxConcurrency` and `maxOutputChars` and switch a feature off.
+ */
+const GLOBAL_ONLY_FORGE = [
+    "javascript.host",
+    "javascript.memoryBytes",
+    "javascript.stackBytes",
+    "state.maxTotalBytes",
+    "scratch",
+];
+/** The limits a project layer may lower: the same list `mergeLimits` honours. */
+const FORGE_PROJECT_LOWERABLE = [
+    "timeoutMs",
+    "maxToolCalls",
+    "maxConcurrency",
+    "maxOutputChars",
+];
+/** A Forja limit: a positive integer up to its hard global maximum, with the spec default. */
+const forgeLimit = (key) => z.number().int().min(1).max(MAX_FORGE_LIMITS[key]).default(DEFAULT_FORGE_LIMITS[key]);
+const FORGE_DEFAULTS = {
+    javascript: {
+        enabled: true,
+        host: "auto",
+        timeoutMs: DEFAULT_FORGE_LIMITS.timeoutMs,
+        memoryBytes: DEFAULT_FORGE_LIMITS.memoryBytes,
+        stackBytes: DEFAULT_FORGE_LIMITS.stackBytes,
+        maxToolCalls: DEFAULT_FORGE_LIMITS.maxToolCalls,
+        maxConcurrency: DEFAULT_FORGE_LIMITS.maxConcurrency,
+        maxOutputChars: DEFAULT_FORGE_LIMITS.maxOutputChars,
+    },
+    state: { enabled: true, maxTotalBytes: 512 * 1024 },
+    scratch: { enabled: true, root: null, retentionDays: 7, maxBytes: 256 * 1024 * 1024 },
+    guides: { enabled: true },
+};
 /** Decision Intelligence keys only the user (global) layer decides: the provider and telemetry. */
 const GLOBAL_ONLY_DECISIONS = ["provider", "telemetry"];
 /** Web UI keys only the user (global) layer decides: the server picks which theme it serves. */
@@ -289,11 +325,43 @@ const configObjectSchema = z
          */
         smartDashboard: z.boolean().default(true),
         /**
-         * Where `python_run` executes. `managed` is the discovered Python (not a sandbox); `oci`
-         * is a Docker or Podman container started from a pinned image. GLOBAL ONLY: a project
+         * Where `python_run` executes. `auto` (default) picks the most isolated backend that is
+         * ready: `oci`, then `wasm`, then `managed` (the last only under `isolation: preferred`).
+         * `managed` is the discovered Python (not a sandbox); `oci` is a Docker or Podman
+         * container started from a pinned image; `wasm` is Pyodide in a restricted Node child
+         * process. An explicit value is honored or fails, never replaced. GLOBAL ONLY: a project
          * layer cannot choose the runtime or the image (it is ignored with a diagnostic).
          */
-        runtime: z.enum(["managed", "oci"]).default("managed"),
+        runtime: z.enum(["auto", "managed", "oci", "wasm"]).default("auto"),
+        /**
+         * What `auto` may use: `preferred` falls back to the host when no isolated backend is
+         * ready, `required` never runs on the host, `strict` admits only backends whose network
+         * the OS denies (global only).
+         */
+        isolation: z.enum(["preferred", "required", "strict"]).default("preferred"),
+        /** Pyodide backend settings (global only). Read by `wasm`, and by `auto` when it is ready. */
+        wasm: z
+            .object({
+            /** Soft limit: the parent samples the child's RSS and kills it above this. */
+            memoryMb: z.number().int().min(256).max(65_536).default(3072),
+            /** Margin for loading Pyodide, added to the run's own deadline and reported apart. */
+            startupMs: z.number().int().min(1000).max(300_000).default(30_000),
+            /** Inputs above this many bytes keep `auto` away from wasm. */
+            maxInputBytes: z
+                .number()
+                .int()
+                .positive()
+                .default(100 * 1024 * 1024),
+            /** A `node` >= 22.22 / 24.13 / 25.3 for the child (needed under Bun; the running Node otherwise). */
+            nodePath: z.string().min(1).nullable().default(null),
+        })
+            .strict()
+            .default(() => ({
+            memoryMb: 3072,
+            startupMs: 30_000,
+            maxInputBytes: 100 * 1024 * 1024,
+            nodePath: null,
+        })),
         /** Container runtime settings (global only). Used when `runtime` is `oci`. */
         oci: z
             .object({
@@ -383,7 +451,14 @@ const configObjectSchema = z
         .default(() => ({
         enabled: true,
         smartDashboard: true,
-        runtime: "managed",
+        runtime: "auto",
+        isolation: "preferred",
+        wasm: {
+            memoryMb: 3072,
+            startupMs: 30_000,
+            maxInputBytes: 100 * 1024 * 1024,
+            nodePath: null,
+        },
         oci: { engine: "docker", memoryMb: 2048, cpus: 2 },
         retention: { jobsDays: 30, intermediateDays: 7, artifactsDays: 0 },
         limits: {
@@ -505,6 +580,58 @@ const configObjectSchema = z
     })
         .strict()
         .default(() => ({ active: "build" })),
+    /**
+     * Forja: isolated code execution (spec §10). `javascript.enabled` is `true` since the
+     * JavaScript engine passed its gate (Phase 3b): `js_run` replaces `execute`; `false` brings
+     * `execute` and the previous system prompt back. `javascript.host`, `memoryBytes`, `stackBytes`,
+     * `state.maxTotalBytes` and `scratch.*` are GLOBAL ONLY; a project may only lower
+     * `timeoutMs`, `maxToolCalls`, `maxConcurrency` and `maxOutputChars` and switch a feature off.
+     */
+    forge: z
+        .object({
+        javascript: z
+            .object({
+            enabled: z.boolean().default(FORGE_DEFAULTS.javascript.enabled),
+            host: z.enum(["auto", "worker", "process"]).default("auto"),
+            timeoutMs: forgeLimit("timeoutMs"),
+            memoryBytes: forgeLimit("memoryBytes"),
+            stackBytes: forgeLimit("stackBytes"),
+            maxToolCalls: forgeLimit("maxToolCalls"),
+            maxConcurrency: forgeLimit("maxConcurrency"),
+            maxOutputChars: forgeLimit("maxOutputChars"),
+        })
+            .strict()
+            .default(() => ({ ...FORGE_DEFAULTS.javascript })),
+        state: z
+            .object({
+            enabled: z.boolean().default(true),
+            maxTotalBytes: z
+                .number()
+                .int()
+                .min(1)
+                .max(8 * 1024 * 1024)
+                .default(FORGE_DEFAULTS.state.maxTotalBytes),
+        })
+            .strict()
+            .default(() => ({ ...FORGE_DEFAULTS.state })),
+        scratch: z
+            .object({
+            enabled: z.boolean().default(true),
+            /** Base of the volatile session directories; `ALISIO_TMPDIR` wins over it. */
+            root: z.string().min(1).nullable().default(null),
+            /** Days without activity before a session folder goes; `0` disables the cleanup. */
+            retentionDays: z.number().int().min(0).max(3650).default(7),
+            maxBytes: z.number().int().min(1).default(FORGE_DEFAULTS.scratch.maxBytes),
+        })
+            .strict()
+            .default(() => ({ ...FORGE_DEFAULTS.scratch })),
+        guides: z
+            .object({ enabled: z.boolean().default(true) })
+            .strict()
+            .default(() => ({ ...FORGE_DEFAULTS.guides })),
+    })
+        .strict()
+        .default(() => structuredClone(FORGE_DEFAULTS)),
     /**
      * Web UI preferences. `iconTheme` names the active `icon-theme` extension point provider
      * (`"none"` keeps the built-in inline icons). GLOBAL ONLY: the server decides which theme its
@@ -572,6 +699,44 @@ async function canonicalDirectory(path) {
 export function overridesSavedProviderProfile(provenance, hasEndpointOverride) {
     return hasEndpointOverride || !!provenance.selectedLayer?.hasLegacyProvider;
 }
+/** Whether a dotted path (`javascript.host`) is written in a raw `forge` block. */
+function forgeHas(raw, path) {
+    let current = raw;
+    for (const part of path.split(".")) {
+        if (!current || typeof current !== "object" || !(part in current))
+            return false;
+        current = current[part];
+    }
+    return true;
+}
+/**
+ * The project layer over the global one for `forge`: global-only keys always come from the global
+ * layer, a lowerable limit takes the smaller value when the project wrote it, and a feature switch
+ * the project wrote can only turn the feature off (a defaulted value never changes the global one).
+ */
+function overlayForge(global, project, raw) {
+    const javascript = { ...global.javascript };
+    for (const key of FORGE_PROJECT_LOWERABLE)
+        if (forgeHas(raw, `javascript.${key}`))
+            javascript[key] = Math.min(global.javascript[key], project.javascript[key]);
+    if (forgeHas(raw, "javascript.enabled"))
+        javascript.enabled = global.javascript.enabled && project.javascript.enabled;
+    return {
+        javascript,
+        state: {
+            ...global.state,
+            enabled: forgeHas(raw, "state.enabled")
+                ? global.state.enabled && project.state.enabled
+                : global.state.enabled,
+        },
+        scratch: global.scratch,
+        guides: {
+            enabled: forgeHas(raw, "guides.enabled")
+                ? global.guides.enabled && project.guides.enabled
+                : global.guides.enabled,
+        },
+    };
+}
 export const configHome = () => process.env.ALISIO_CONFIG_HOME ??
     join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "alisio");
 export const stateHome = () => process.env.ALISIO_STATE_HOME ??
@@ -625,6 +790,9 @@ export async function loadConfigWithProvenance(workspace, options = {}) {
         const analysisRaw = object.analysis && typeof object.analysis === "object" && !Array.isArray(object.analysis)
             ? object.analysis
             : {};
+        const forgeRaw = object.forge && typeof object.forge === "object" && !Array.isArray(object.forge)
+            ? object.forge
+            : {};
         const tasksRaw = object.tasks && typeof object.tasks === "object" && !Array.isArray(object.tasks)
             ? object.tasks
             : {};
@@ -641,6 +809,7 @@ export async function loadConfigWithProvenance(workspace, options = {}) {
             : {};
         const ignored = [
             ...GLOBAL_ONLY_ANALYSIS.filter((key) => key in analysisRaw).map((key) => `analysis.${key}`),
+            ...GLOBAL_ONLY_FORGE.filter((path) => forgeHas(forgeRaw, path)).map((path) => `forge.${path}`),
             ...GLOBAL_ONLY_DECISIONS.filter((key) => key in decisionsRaw).map((key) => `decisions.${key}`),
             ...GLOBAL_ONLY_WEB.filter((key) => key in webRaw).map((key) => `web.${key}`),
             ...Object.entries(overridesRaw)
@@ -653,6 +822,8 @@ export async function loadConfigWithProvenance(workspace, options = {}) {
             keys: new Set(Object.keys(object)),
             /** Raw keys of the layer's `analysis` block (a defaulted key is not an expressed one). */
             analysisKeys: new Set(Object.keys(analysisRaw)),
+            /** Raw `forge` block of the layer, to tell a written key from a defaulted one. */
+            forgeRaw,
             sources,
             ignored,
             file,
@@ -723,11 +894,13 @@ export async function loadConfigWithProvenance(workspace, options = {}) {
                 continue;
             }
             if (key === "analysis") {
-                // `runtime`, `oci` and `retention` are global-only (a repository must not pick the binary
+                // `runtime`, `isolation`, `oci`, `wasm` and `retention` are global-only (a repository must not pick the binary
                 // that runs scripts, nor shorten the retention of every workspace's data).
                 overlaid.analysis = {
                     ...selected.config.analysis,
                     runtime: global.config.analysis.runtime,
+                    isolation: global.config.analysis.isolation,
+                    wasm: global.config.analysis.wasm,
                     oci: global.config.analysis.oci,
                     retention: global.config.analysis.retention,
                     // A defaulted `true` must not undo the global `false`: only a key the layer wrote wins.
@@ -737,6 +910,10 @@ export async function loadConfigWithProvenance(workspace, options = {}) {
                 };
                 continue;
             }
+            if (key === "forge") {
+                overlaid.forge = overlayForge(global.config.forge, selected.config.forge, selected.forgeRaw);
+                continue;
+            }
             if (key === "decisions") {
                 // `provider` and `telemetry` are global-only (a repository cannot pick the decision
                 // engine nor its telemetry policy); the rest follows the selected layer.
@@ -912,7 +1089,10 @@ const SETTABLE_SECTIONS = {
     goal: configObjectSchema.shape.goal.removeDefault(),
     plan: configObjectSchema.shape.plan.removeDefault(),
     web: configObjectSchema.shape.web.removeDefault(),
+    forge: configObjectSchema.shape.forge.removeDefault(),
 };
+const FORGE_JAVASCRIPT = SETTABLE_SECTIONS.forge.shape.javascript.removeDefault();
+const FORGE_GUIDES = SETTABLE_SECTIONS.forge.shape.guides.removeDefault();
 const ANALYSIS_LIMITS = SETTABLE_SECTIONS.analysis.shape.limits.removeDefault();
 const ANALYSIS_RETENTION = SETTABLE_SECTIONS.analysis.shape.retention.removeDefault();
 const SETTABLE_KEYS = {
@@ -962,6 +1142,8 @@ const SETTABLE_KEYS = {
     "plan.diagrams": SETTABLE_SECTIONS.plan.shape.diagrams,
     "plan.maxDiagrams": SETTABLE_SECTIONS.plan.shape.maxDiagrams,
     "web.iconTheme": SETTABLE_SECTIONS.web.shape.iconTheme,
+    "forge.javascript.enabled": FORGE_JAVASCRIPT.shape.enabled,
+    "forge.guides.enabled": FORGE_GUIDES.shape.enabled,
 };
 export function isSettableSettingKey(key) {
     return Object.prototype.hasOwnProperty.call(SETTABLE_KEYS, key);

package/dist/core/call-internals.d.ts

@@ -0,0 +1,22 @@
+/**
+ * What only the core's own tools may do from inside a call (spec D-23, D-24): flag the running
+ * call as `effectful` and reach the run's nested-call dispatcher. It is NOT part of the SDK
+ * `ToolContext`: the runner binds it to the context object of a call in a module-private
+ * `WeakMap`, so a plugin tool, which sees only the SDK type, has no property to find and no module
+ * to import.
+ */
+import type { ToolContext } from "@alisio/sdk";
+import type { NestedCallDispatcher } from "../forge/nested.ts";
+export interface CallInternals {
+    /**
+     * Flags the running call: it may have left effects, so a cancellation must leave it pending for
+     * recovery even though its own effect is `read`. Idempotent.
+     */
+    markEffectful(): void;
+    /** The dispatcher for tool calls made from inside this call (built on first use). */
+    nested(): NestedCallDispatcher;
+}
+/** The runner binds the internals of a call to the context it hands the tool. */
+export declare function bindCallInternals(context: ToolContext, internals: CallInternals): void;
+/** The internals of the call this context belongs to; undefined for any other context. */
+export declare function callInternals(context: ToolContext): CallInternals | undefined;

package/dist/core/call-internals.js

@@ -0,0 +1,9 @@
+const bound = new WeakMap();
+/** The runner binds the internals of a call to the context it hands the tool. */
+export function bindCallInternals(context, internals) {
+    bound.set(context, internals);
+}
+/** The internals of the call this context belongs to; undefined for any other context. */
+export function callInternals(context) {
+    return bound.get(context);
+}

package/dist/core/contracts.d.ts

@@ -209,7 +209,7 @@ export interface ApprovalRequest {
     /** Capability approvals: the first 40 lines of the script. */
     preview?: string;
     /** Capability approvals: how the code runs (`managed` is not sandboxed). */
-    runtime?: "managed" | "oci";
+    runtime?: "auto" | "managed" | "oci" | "wasm";
     /** `analysis.install`: the packages, the size estimate and the network need (once or deny). */
     install?: InstallPreview;
 }
@@ -233,7 +233,7 @@ export interface CapabilityGate {
     /** Recorded as the source of interactive decisions (`tui` or `web`). */
     source?: "tui" | "web";
     /** Runtime mode shown with `analysis.run` approvals (read live: the configuration can change). */
-    runtime?: "managed" | "oci";
+    runtime?: "auto" | "managed" | "oci" | "wasm";
     /**
      * The script to show in an approval whose input does not carry it (a rerun runs a saved script).
      * Absent or undefined: the preview is taken from `input.code`.