@pie-players/pie-assessment-toolkit 0.3.68 → 0.3.69

package/dist/services/ToolRegistry.d.ts

@@ -483,6 +483,26 @@ export interface ToolRegistration {
      * @returns true if tool should be visible, false to hide
      */
     isVisibleInContext?(context: ToolContext): boolean;
+    /**
+     * Whether this tool can act on this content at all — a capability question,
+     * not a relevance heuristic. Answering `false` withdraws the tool even where
+     * a PNP grant would otherwise keep it, which {@link
+     * ToolRegistration.isVisibleInContext} deliberately cannot do.
+     *
+     * The two gates answer different questions, and most tools declare only the
+     * first. A calculator is *applicable* to every item — a learner granted one
+     * keeps it on an item that does not look mathematical — while its relevance
+     * is a guess about usefulness. An answer eliminator on an item with no choice
+     * interaction has nothing to strike through, so no grant can make it work.
+     *
+     * Declare this only where the tool's own controls provably do nothing:
+     * withdrawing a granted accommodation on a false negative is the more
+     * expensive failure. Omitting it means "applicable".
+     *
+     * @param context - The item or element context the tool would act on
+     * @returns false to withdraw the tool from this context
+     */
+    isApplicableToContent?(context: ToolContext): boolean;
     /**
      * Toolbar render contract. Required for `toolbar-toggle` and
      * `selection-gateway`; a region capability renders through
@@ -625,6 +645,20 @@ export declare class ToolRegistry {
      * @returns Array of visible tool registrations
      */
     filterVisibleInContext(allowedToolIds: string[], context: ToolContext): ToolRegistration[];
+    /**
+     * Whether a tool can act on any of the contexts it would be placed against.
+     * Unlike the relevance pass this is a veto: a `false` here removes the tool
+     * from a toolbar even when a grant protects it, so a tool answers `false`
+     * only where its controls provably do nothing.
+     *
+     * A tool that declares no applicability gate is applicable. So is one
+     * evaluated against no contexts — content that has not resolved yet cannot
+     * establish that a tool is useless.
+     *
+     * @param toolId - Tool to ask
+     * @param contexts - Every context the tool could act on at this placement
+     */
+    isApplicableToAnyContext(toolId: string, contexts: readonly ToolContext[]): boolean;
     /**
      * Get tool metadata for building UIs
      * Useful for building PNP configuration interfaces

package/dist/services/ToolRegistry.js

@@ -164,6 +164,10 @@ function assertToolRegistrationShape(registration) {
         typeof registration.isVisibleInContext !== "function") {
         throw new Error(`Invalid tool registration "${registration.toolId}": "isVisibleInContext" must be a function when present.`);
     }
+    if (registration.isApplicableToContent !== undefined &&
+        typeof registration.isApplicableToContent !== "function") {
+        throw new Error(`Invalid tool registration "${registration.toolId}": "isApplicableToContent" must be a function when present.`);
+    }
     if (registration.requiresAuthoredContent !== undefined) {
         if (typeof registration.requiresAuthoredContent !== "object" ||
             registration.requiresAuthoredContent === null ||
@@ -442,6 +446,36 @@ export class ToolRegistry {
         }
         return visible;
     }
+    /**
+     * Whether a tool can act on any of the contexts it would be placed against.
+     * Unlike the relevance pass this is a veto: a `false` here removes the tool
+     * from a toolbar even when a grant protects it, so a tool answers `false`
+     * only where its controls provably do nothing.
+     *
+     * A tool that declares no applicability gate is applicable. So is one
+     * evaluated against no contexts — content that has not resolved yet cannot
+     * establish that a tool is useless.
+     *
+     * @param toolId - Tool to ask
+     * @param contexts - Every context the tool could act on at this placement
+     */
+    isApplicableToAnyContext(toolId, contexts) {
+        const tool = this.get(toolId);
+        if (!tool?.isApplicableToContent)
+            return true;
+        if (contexts.length === 0)
+            return true;
+        return contexts.some((context) => {
+            try {
+                return tool.isApplicableToContent?.(context) ?? true;
+            }
+            catch (error) {
+                console.error(`Error evaluating applicability for tool '${toolId}':`, error);
+                // A gate that throws has not established that the tool is useless.
+                return true;
+            }
+        });
+    }
     /**
      * Get tool metadata for building UIs
      * Useful for building PNP configuration interfaces

package/dist/services/tool-context.js

@@ -300,9 +300,14 @@ export function hasChoiceInteraction(context) {
             if (!m || typeof m !== "object")
                 return false;
             const type = m.element || "";
-            if (interactionTypes.includes(type))
-                return true;
-            // Fallback for configs that don't provide canonical element names.
+            // A model that names its element has answered the question, whichever way
+            // the answer falls. `choices` is carried by interactions that are not
+            // choice interactions at all — `placement-ordering`, `categorize` and
+            // `drag-in-the-blank` each hold their draggables there — so reading it on
+            // a named model showed the answer eliminator on items where the tool does
+            // nothing. The heuristic remains for configs that name no element.
+            if (type)
+                return interactionTypes.includes(type);
             return Array.isArray(m.choices) && m.choices.length > 0;
         });
     }

package/dist/services/tool-providers/CortexToolProvider.d.ts

@@ -0,0 +1,18 @@
+/** Fully bundled open-source calculator adapter for the tool-provider registry. */
+import type { CalculatorToolProviderInitConfig } from "./LazyCalculatorToolProvider.js";
+import { LazyCalculatorToolProvider } from "./LazyCalculatorToolProvider.js";
+import type { ToolProviderCapabilities } from "./ToolProviderApi.js";
+export type CortexToolProviderConfig = CalculatorToolProviderInitConfig;
+export declare class CortexToolProvider extends LazyCalculatorToolProvider<CortexToolProviderConfig> {
+    readonly providerId = "cortex-calculator";
+    readonly providerName = "PIE Open-Source Calculator";
+    readonly version = "1";
+    readonly requiresAuth = false;
+    protected getDefinition(): {
+        backend: string;
+        moduleImportOperation: string;
+        loadProvider: () => Promise<typeof import("@pie-players/pie-calculator-cortex").CortexCalculatorProvider>;
+        initializationErrorMessage: string;
+    };
+    getCapabilities(): ToolProviderCapabilities;
+}

package/dist/services/tool-providers/CortexToolProvider.js

@@ -0,0 +1,32 @@
+/** Fully bundled open-source calculator adapter for the tool-provider registry. */
+import { LazyCalculatorToolProvider } from "./LazyCalculatorToolProvider.js";
+export class CortexToolProvider extends LazyCalculatorToolProvider {
+    providerId = "cortex-calculator";
+    providerName = "PIE Open-Source Calculator";
+    version = "1";
+    requiresAuth = false;
+    getDefinition() {
+        return {
+            backend: "cortex",
+            moduleImportOperation: "cortex-provider-module-import",
+            loadProvider: async () => {
+                const module = await import("@pie-players/pie-calculator-cortex");
+                return module.CortexCalculatorProvider;
+            },
+            initializationErrorMessage: "Failed to initialize the PIE open-source calculator provider. Confirm that this browser supports module workers and that the bundled worker assets are available.",
+        };
+    }
+    getCapabilities() {
+        return {
+            supportsOffline: true,
+            requiresAuth: false,
+            maxInstances: null,
+            features: {
+                basic: true,
+                scientific: true,
+                graphing: true,
+                fourFunction: true,
+            },
+        };
+    }
+}

package/dist/services/tool-providers/DesmosToolProvider.d.ts

@@ -1,108 +1,19 @@
-/**
- * Desmos Calculator Tool Provider
- *
- * Provides Desmos calculators (basic, scientific, graphing)
- * with authentication and proxy support.
- *
- * SECURITY BEST PRACTICE:
- * - Development: Pass apiKey directly for local testing
- * - Production: Use proxyEndpoint or authFetcher to keep API key server-side
- *
- * Part of PIE Assessment Toolkit.
- */
-import type { CalculatorProvider } from "@pie-players/pie-calculator";
-import type { ToolProviderApi, ToolProviderCapabilities } from "./ToolProviderApi.js";
-/**
- * Desmos tool provider configuration
- *
- * Auth and telemetry only. Per-calculator Desmos options are owned by the
- * calculator component, which derives them from the calculator type and passes
- * them to `createCalculator()` directly — this provider never sees that config,
- * so a defaults field here would silently do nothing.
- */
-export interface DesmosToolProviderConfig {
-    /**
-     * Desmos API key (DEVELOPMENT ONLY)
-     * Never expose in production client code!
-     *
-     * Obtain from: https://www.desmos.com/api
-     */
-    apiKey?: string;
-    /**
-     * Server proxy endpoint (PRODUCTION RECOMMENDED)
-     * Backend handles API key securely
-     *
-     * @example '/api/desmos/token'
-     * @example 'https://api.myapp.com/tools/desmos/auth'
-     */
-    proxyEndpoint?: string;
-    /**
-     * Optional telemetry callback for tool/backend instrumentation.
-     */
-    onTelemetry?: (eventName: string, payload?: Record<string, unknown>) => void | Promise<void>;
-}
-/**
- * Desmos Calculator Tool Provider
- *
- * Wraps DesmosCalculatorProvider with the ToolProviderApi interface
- * for use in the ToolProviderRegistry.
- *
- * @example
- * ```typescript
- * const provider = new DesmosToolProvider();
- *
- * await provider.initialize({
- *   apiKey: 'your-api-key', // Development only
- *   proxyEndpoint: '/api/desmos/token', // Production
- * });
- *
- * const calculatorProvider = await provider.createInstance();
- * ```
- */
-export declare class DesmosToolProvider implements ToolProviderApi<DesmosToolProviderConfig, CalculatorProvider> {
+/** Desmos calculator adapter for the generic tool-provider registry. */
+import type { CalculatorProviderInit } from "@pie-players/pie-calculator";
+import { LazyCalculatorToolProvider } from "./LazyCalculatorToolProvider.js";
+import type { ToolProviderCapabilities } from "./ToolProviderApi.js";
+/** Provider initialization is the provider-neutral calculator contract. */
+export type DesmosToolProviderConfig = CalculatorProviderInit;
+export declare class DesmosToolProvider extends LazyCalculatorToolProvider<DesmosToolProviderConfig> {
     readonly providerId = "desmos-calculator";
     readonly providerName = "Desmos Calculator";
-    readonly category: "calculator";
     readonly version = "1.12";
     readonly requiresAuth = true;
-    private desmosProvider;
-    private config;
-    private emitTelemetry;
-    /**
-     * Initialize Desmos calculator provider
-     *
-     * Loads the Desmos API library and authenticates with provided credentials.
-     *
-     * @param config Configuration with API key or proxy endpoint
-     * @throws Error if initialization fails
-     */
-    initialize(config: DesmosToolProviderConfig): Promise<void>;
-    /**
-     * Create a calculator provider instance
-     *
-     * Returns the initialized Desmos calculator provider.
-     *
-     * @param config Optional instance-specific configuration (currently unused)
-     * @returns Desmos calculator provider
-     * @throws Error if provider not initialized
-     */
-    createInstance(config?: Partial<DesmosToolProviderConfig>): Promise<CalculatorProvider>;
-    /**
-     * Get provider capabilities
-     *
-     * @returns Desmos calculator capabilities
-     */
+    protected getDefinition(): {
+        backend: string;
+        moduleImportOperation: string;
+        loadProvider: () => Promise<typeof import("@pie-players/pie-calculator-desmos").DesmosCalculatorProvider>;
+        initializationErrorMessage: string;
+    };
     getCapabilities(): ToolProviderCapabilities;
-    /**
-     * Check if provider is ready
-     *
-     * @returns true if provider is initialized
-     */
-    isReady(): boolean;
-    /**
-     * Clean up provider resources
-     *
-     * Destroys the Desmos calculator provider and releases resources.
-     */
-    destroy(): void;
 }

package/dist/services/tool-providers/DesmosToolProvider.js

@@ -1,136 +1,26 @@
-/**
- * Desmos Calculator Tool Provider
- *
- * Provides Desmos calculators (basic, scientific, graphing)
- * with authentication and proxy support.
- *
- * SECURITY BEST PRACTICE:
- * - Development: Pass apiKey directly for local testing
- * - Production: Use proxyEndpoint or authFetcher to keep API key server-side
- *
- * Part of PIE Assessment Toolkit.
- */
-/**
- * Desmos Calculator Tool Provider
- *
- * Wraps DesmosCalculatorProvider with the ToolProviderApi interface
- * for use in the ToolProviderRegistry.
- *
- * @example
- * ```typescript
- * const provider = new DesmosToolProvider();
- *
- * await provider.initialize({
- *   apiKey: 'your-api-key', // Development only
- *   proxyEndpoint: '/api/desmos/token', // Production
- * });
- *
- * const calculatorProvider = await provider.createInstance();
- * ```
- */
-export class DesmosToolProvider {
+/** Desmos calculator adapter for the generic tool-provider registry. */
+import { LazyCalculatorToolProvider } from "./LazyCalculatorToolProvider.js";
+export class DesmosToolProvider extends LazyCalculatorToolProvider {
     providerId = "desmos-calculator";
     providerName = "Desmos Calculator";
-    category = "calculator";
     version = "1.12";
     requiresAuth = true;
-    desmosProvider = null;
-    config = null;
-    async emitTelemetry(eventName, payload) {
-        try {
-            await this.config?.onTelemetry?.(eventName, payload);
-        }
-        catch (error) {
-            console.warn("[DesmosToolProvider] telemetry callback failed:", error);
-        }
-    }
-    /**
-     * Initialize Desmos calculator provider
-     *
-     * Loads the Desmos API library and authenticates with provided credentials.
-     *
-     * @param config Configuration with API key or proxy endpoint
-     * @throws Error if initialization fails
-     */
-    async initialize(config) {
-        if (this.desmosProvider) {
-            console.warn("[DesmosToolProvider] Already initialized, skipping reinitialization");
-            return;
-        }
-        this.config = config;
-        const moduleLoadStartedAt = Date.now();
-        await this.emitTelemetry("pie-tool-library-load-start", {
-            toolId: "calculator",
-            operation: "desmos-provider-module-import",
+    getDefinition() {
+        return {
             backend: "desmos",
-        });
-        const desmosModule = await (async () => {
-            try {
-                const loaded = (await import("@pie-players/pie-calculator-desmos"));
-                await this.emitTelemetry("pie-tool-library-load-success", {
-                    toolId: "calculator",
-                    operation: "desmos-provider-module-import",
-                    backend: "desmos",
-                    duration: Date.now() - moduleLoadStartedAt,
-                });
-                return loaded;
-            }
-            catch (error) {
-                await this.emitTelemetry("pie-tool-library-load-error", {
-                    toolId: "calculator",
-                    operation: "desmos-provider-module-import",
-                    backend: "desmos",
-                    duration: Date.now() - moduleLoadStartedAt,
-                    errorType: "ToolLibraryLoadError",
-                    message: error instanceof Error ? error.message : String(error),
-                });
-                throw error;
-            }
-        })();
-        this.desmosProvider = new desmosModule.DesmosCalculatorProvider();
-        // Initialize with API key or proxy
-        try {
-            await this.desmosProvider.initialize({
-                apiKey: config.apiKey,
-                proxyEndpoint: config.proxyEndpoint,
-                onTelemetry: config.onTelemetry,
-            });
-            console.log(`[DesmosToolProvider] Initialized successfully ${config.proxyEndpoint
-                ? "(using proxy)"
-                : config.apiKey
-                    ? "(direct API key)"
-                    : "(no auth)"}`);
-        }
-        catch (error) {
-            console.error("[DesmosToolProvider] Initialization failed:", error);
-            throw new Error("Failed to initialize Desmos calculator provider. Check API key or proxy endpoint.");
-        }
-    }
-    /**
-     * Create a calculator provider instance
-     *
-     * Returns the initialized Desmos calculator provider.
-     *
-     * @param config Optional instance-specific configuration (currently unused)
-     * @returns Desmos calculator provider
-     * @throws Error if provider not initialized
-     */
-    async createInstance(config) {
-        if (!this.desmosProvider) {
-            throw new Error("[DesmosToolProvider] Provider not initialized. Call initialize() first.");
-        }
-        return this.desmosProvider;
+            moduleImportOperation: "desmos-provider-module-import",
+            loadProvider: async () => {
+                const module = await import("@pie-players/pie-calculator-desmos");
+                return module.DesmosCalculatorProvider;
+            },
+            initializationErrorMessage: "Failed to initialize Desmos calculator provider. Check the application key, preloaded API, runtime endpoint, or network access.",
+        };
     }
-    /**
-     * Get provider capabilities
-     *
-     * @returns Desmos calculator capabilities
-     */
     getCapabilities() {
         return {
-            supportsOffline: false, // Requires Desmos CDN
+            supportsOffline: false,
             requiresAuth: true,
-            maxInstances: null, // Unlimited calculator instances
+            maxInstances: null,
             features: {
                 basic: true,
                 scientific: true,
@@ -139,25 +29,4 @@ export class DesmosToolProvider {
             },
         };
     }
-    /**
-     * Check if provider is ready
-     *
-     * @returns true if provider is initialized
-     */
-    isReady() {
-        return this.desmosProvider !== null;
-    }
-    /**
-     * Clean up provider resources
-     *
-     * Destroys the Desmos calculator provider and releases resources.
-     */
-    destroy() {
-        if (this.desmosProvider) {
-            this.desmosProvider.destroy();
-            this.desmosProvider = null;
-        }
-        this.config = null;
-        console.log("[DesmosToolProvider] Destroyed");
-    }
 }

package/dist/services/tool-providers/GeoGebraToolProvider.d.ts

@@ -0,0 +1,21 @@
+/** GeoGebra calculator adapter for the generic tool-provider registry. */
+import type { CalculatorToolProviderInitConfig } from "./LazyCalculatorToolProvider.js";
+import { LazyCalculatorToolProvider } from "./LazyCalculatorToolProvider.js";
+import type { ToolProviderCapabilities } from "./ToolProviderApi.js";
+export interface GeoGebraToolProviderConfig extends CalculatorToolProviderInitConfig {
+    scriptUrl?: string;
+    appletTimeoutMs?: number;
+}
+export declare class GeoGebraToolProvider extends LazyCalculatorToolProvider<GeoGebraToolProviderConfig> {
+    readonly providerId = "geogebra-calculator";
+    readonly providerName = "GeoGebra Calculator";
+    readonly version = "6";
+    readonly requiresAuth = false;
+    protected getDefinition(): {
+        backend: string;
+        moduleImportOperation: string;
+        loadProvider: () => Promise<typeof import("@pie-players/pie-calculator-geogebra").GeoGebraCalculatorProvider>;
+        initializationErrorMessage: string;
+    };
+    getCapabilities(): ToolProviderCapabilities;
+}

package/dist/services/tool-providers/GeoGebraToolProvider.js

@@ -0,0 +1,32 @@
+/** GeoGebra calculator adapter for the generic tool-provider registry. */
+import { LazyCalculatorToolProvider } from "./LazyCalculatorToolProvider.js";
+export class GeoGebraToolProvider extends LazyCalculatorToolProvider {
+    providerId = "geogebra-calculator";
+    providerName = "GeoGebra Calculator";
+    version = "6";
+    requiresAuth = false;
+    getDefinition() {
+        return {
+            backend: "geogebra",
+            moduleImportOperation: "geogebra-provider-module-import",
+            loadProvider: async () => {
+                const module = await import("@pie-players/pie-calculator-geogebra");
+                return module.GeoGebraCalculatorProvider;
+            },
+            initializationErrorMessage: "Failed to initialize GeoGebra calculator provider. Confirm that the deployment may load GeoGebra and that its script URL is reachable.",
+        };
+    }
+    getCapabilities() {
+        return {
+            supportsOffline: false,
+            requiresAuth: false,
+            maxInstances: null,
+            features: {
+                basic: true,
+                scientific: true,
+                graphing: true,
+                fourFunction: false,
+            },
+        };
+    }
+}

package/dist/services/tool-providers/LazyCalculatorToolProvider.d.ts

@@ -0,0 +1,35 @@
+import type { CalculatorProvider, CalculatorProviderInit } from "@pie-players/pie-calculator";
+import type { ToolProviderApi, ToolProviderCapabilities } from "./ToolProviderApi.js";
+export type CalculatorToolProviderInitConfig = Pick<CalculatorProviderInit, "onTelemetry">;
+type InitializableCalculatorProvider<TConfig> = CalculatorProvider & {
+    initialize(config: TConfig): Promise<void>;
+};
+interface LazyCalculatorProviderDefinition<TConfig> {
+    backend: string;
+    moduleImportOperation: string;
+    loadProvider: () => Promise<new () => InitializableCalculatorProvider<TConfig>>;
+    initializationErrorMessage: string;
+}
+/**
+ * Shared lazy-module and lifecycle implementation for calculator tool adapters.
+ * Concrete adapters own only their metadata, capabilities and provider import.
+ */
+export declare abstract class LazyCalculatorToolProvider<TConfig extends CalculatorToolProviderInitConfig> implements ToolProviderApi<TConfig, CalculatorProvider> {
+    abstract readonly providerId: string;
+    abstract readonly providerName: string;
+    readonly category: "calculator";
+    abstract readonly version: string;
+    abstract readonly requiresAuth: boolean;
+    protected abstract getDefinition(): LazyCalculatorProviderDefinition<TConfig>;
+    abstract getCapabilities(): ToolProviderCapabilities;
+    private calculatorProvider;
+    private initializationPromise;
+    private lifecycleGeneration;
+    private emitTelemetry;
+    initialize(config?: TConfig): Promise<void>;
+    private initializeProvider;
+    createInstance(): Promise<CalculatorProvider>;
+    isReady(): boolean;
+    destroy(): void;
+}
+export {};

package/dist/services/tool-providers/LazyCalculatorToolProvider.js

@@ -0,0 +1,95 @@
+/**
+ * Shared lazy-module and lifecycle implementation for calculator tool adapters.
+ * Concrete adapters own only their metadata, capabilities and provider import.
+ */
+export class LazyCalculatorToolProvider {
+    category = "calculator";
+    calculatorProvider = null;
+    initializationPromise = null;
+    lifecycleGeneration = 0;
+    async emitTelemetry(config, eventName, payload) {
+        try {
+            await config.onTelemetry?.(eventName, payload);
+        }
+        catch (error) {
+            console.warn(`[${this.providerName}] telemetry callback failed:`, error);
+        }
+    }
+    async initialize(config = {}) {
+        if (this.calculatorProvider)
+            return;
+        if (this.initializationPromise)
+            return this.initializationPromise;
+        const generation = ++this.lifecycleGeneration;
+        const initializationPromise = this.initializeProvider(config, generation);
+        this.initializationPromise = initializationPromise;
+        try {
+            await initializationPromise;
+        }
+        finally {
+            if (this.initializationPromise === initializationPromise) {
+                this.initializationPromise = null;
+            }
+        }
+    }
+    async initializeProvider(config, generation) {
+        const definition = this.getDefinition();
+        const moduleLoadStartedAt = Date.now();
+        await this.emitTelemetry(config, "pie-tool-library-load-start", {
+            toolId: "calculator",
+            operation: definition.moduleImportOperation,
+            backend: definition.backend,
+        });
+        let ProviderConstructor;
+        try {
+            ProviderConstructor = await definition.loadProvider();
+            await this.emitTelemetry(config, "pie-tool-library-load-success", {
+                toolId: "calculator",
+                operation: definition.moduleImportOperation,
+                backend: definition.backend,
+                duration: Date.now() - moduleLoadStartedAt,
+            });
+        }
+        catch (error) {
+            await this.emitTelemetry(config, "pie-tool-library-load-error", {
+                toolId: "calculator",
+                operation: definition.moduleImportOperation,
+                backend: definition.backend,
+                duration: Date.now() - moduleLoadStartedAt,
+                errorType: "ToolLibraryLoadError",
+                message: error instanceof Error ? error.message : String(error),
+            });
+            throw new Error(definition.initializationErrorMessage, { cause: error });
+        }
+        if (generation !== this.lifecycleGeneration) {
+            throw new Error(`${this.providerName} initialization was cancelled`);
+        }
+        const candidate = new ProviderConstructor();
+        try {
+            await candidate.initialize(config);
+            if (generation !== this.lifecycleGeneration) {
+                throw new Error(`${this.providerName} initialization was cancelled`);
+            }
+            this.calculatorProvider = candidate;
+        }
+        catch (error) {
+            candidate.destroy();
+            throw new Error(definition.initializationErrorMessage, { cause: error });
+        }
+    }
+    async createInstance() {
+        if (!this.calculatorProvider) {
+            throw new Error(`[${this.providerName}] Provider not initialized. Call initialize() first.`);
+        }
+        return this.calculatorProvider;
+    }
+    isReady() {
+        return this.calculatorProvider !== null;
+    }
+    destroy() {
+        this.lifecycleGeneration += 1;
+        this.initializationPromise = null;
+        this.calculatorProvider?.destroy();
+        this.calculatorProvider = null;
+    }
+}

package/dist/services/tool-providers/index.d.ts

@@ -11,5 +11,9 @@ export { ToolProviderRegistry } from "./ToolProviderRegistry.js";
 export type { ToolProviderConfig } from "./ToolProviderRegistry.js";
 export { DesmosToolProvider } from "./DesmosToolProvider.js";
 export type { DesmosToolProviderConfig } from "./DesmosToolProvider.js";
+export { CortexToolProvider } from "./CortexToolProvider.js";
+export type { CortexToolProviderConfig } from "./CortexToolProvider.js";
+export { GeoGebraToolProvider } from "./GeoGebraToolProvider.js";
+export type { GeoGebraToolProviderConfig } from "./GeoGebraToolProvider.js";
 export { TTSToolProvider } from "./TTSToolProvider.js";
 export type { TTSToolProviderConfig, TTSBackend, } from "./TTSToolProvider.js";

package/dist/services/tool-providers/index.js

@@ -10,4 +10,6 @@
 export { ToolProviderRegistry } from "./ToolProviderRegistry.js";
 // Concrete providers
 export { DesmosToolProvider } from "./DesmosToolProvider.js";
+export { CortexToolProvider } from "./CortexToolProvider.js";
+export { GeoGebraToolProvider } from "./GeoGebraToolProvider.js";
 export { TTSToolProvider } from "./TTSToolProvider.js";