@pie-players/pie-assessment-toolkit 0.3.74 → 0.3.75

package/dist/services/tool-config-validation.d.ts

@@ -4,12 +4,11 @@ import type { ToolRegistry } from "./ToolRegistry.js";
 export type ToolConfigStrictness = "off" | "warn" | "error";
 export type ToolConfigDiagnosticSeverity = "warning" | "error";
 export interface ToolConfigDiagnostic {
-    code: "tools.unknownToolId" | "tools.unsupportedLevel" | "tools.unplaceableActivation" | "tools.registryUnavailable" | "tools.unknownProviderKey" | "tools.removedProviderKey" | "tools.providerSanitizeFailed" | "tools.providerValidateFailed" | "tools.invalidProviderValidation";
+    code: "tools.unknownToolId" | "tools.unsupportedLevel" | "tools.unplaceableActivation" | "tools.registryUnavailable" | "tools.unknownProviderKey" | "tools.providerSanitizeFailed" | "tools.providerValidateFailed" | "tools.invalidProviderValidation";
     severity: ToolConfigDiagnosticSeverity;
     path: string;
     message: string;
     toolId?: string;
-    providerId?: string;
 }
 export interface ToolConfigValidationOptions {
     strictness?: ToolConfigStrictness;
@@ -34,8 +33,8 @@ export declare function normalizeAndValidateToolsConfig(input?: ToolsConfigInput
  */
 export declare function collectToolConfigDiagnostics(input: ToolsConfigInput | null | undefined, toolRegistry: ToolRegistry | null | undefined): ToolConfigValidationResult;
 /**
- * Report diagnostics as {@link normalizeAndValidateToolsConfig} does: a removed
- * provider key throws at every strictness, `"warn"` prints every diagnostic, and
- * `"error"` throws the blocking ones or, when there are none, prints the rest.
+ * Report diagnostics as {@link normalizeAndValidateToolsConfig} does: `"warn"`
+ * prints every diagnostic, and `"error"` throws the blocking ones or, when there
+ * are none, prints the rest.
  */
 export declare function reportToolConfigDiagnostics(diagnostics: ToolConfigDiagnostic[], options?: Pick<ToolConfigValidationOptions, "strictness" | "source">): void;

package/dist/services/tool-config-validation.js

@@ -34,21 +34,20 @@ function getRegistryToolMap(toolRegistry) {
         .sort((left, right) => left.toolId.localeCompare(right.toolId))
         .map((tool) => [tool.toolId, tool]));
 }
-function sanitizeProviderConfig(providerId, providerConfig, tool, diagnostics) {
-    if (!providerConfig || !tool?.provider?.sanitizeConfig)
+function sanitizeToolConfig(toolId, providerConfig, tool, diagnostics) {
+    if (!providerConfig || !tool?.sanitizeConfig)
         return providerConfig;
     try {
-        const sanitized = tool.provider.sanitizeConfig(providerConfig);
+        const sanitized = tool.sanitizeConfig(providerConfig);
         if (!sanitized ||
             typeof sanitized !== "object" ||
             Array.isArray(sanitized)) {
             diagnostics.push(createDiagnostic({
                 code: "tools.providerSanitizeFailed",
                 severity: "error",
-                path: `providers.${providerId}`,
-                message: `Provider sanitizer for "${providerId}" must return an object.`,
-                providerId,
-                toolId: providerId,
+                path: `providers.${toolId}`,
+                message: `Config sanitizer of tool "${toolId}" must return an object.`,
+                toolId,
             }));
             return providerConfig;
         }
@@ -58,36 +57,33 @@ function sanitizeProviderConfig(providerId, providerConfig, tool, diagnostics) {
         diagnostics.push(createDiagnostic({
             code: "tools.providerSanitizeFailed",
             severity: "error",
-            path: `providers.${providerId}`,
-            message: `Provider sanitizer failed for "${providerId}": ${error instanceof Error ? error.message : String(error)}`,
-            providerId,
-            toolId: providerId,
+            path: `providers.${toolId}`,
+            message: `Config sanitizer of tool "${toolId}" failed: ${error instanceof Error ? error.message : String(error)}`,
+            toolId,
         }));
         return providerConfig;
     }
 }
-function validateProviderConfig(providerId, providerConfig, tool, diagnostics) {
-    if (!providerConfig || !tool?.provider?.validateConfig)
+function validateToolConfig(toolId, providerConfig, tool, diagnostics) {
+    if (!providerConfig || !tool?.validateConfig)
         return;
     try {
-        const providerDiagnostics = tool.provider.validateConfig(providerConfig);
-        if (!Array.isArray(providerDiagnostics)) {
+        const toolDiagnostics = tool.validateConfig(providerConfig);
+        if (!Array.isArray(toolDiagnostics)) {
             diagnostics.push(createDiagnostic({
                 code: "tools.invalidProviderValidation",
                 severity: "error",
-                path: `providers.${providerId}`,
-                message: `Provider validator for "${providerId}" must return an array.`,
-                providerId,
-                toolId: providerId,
+                path: `providers.${toolId}`,
+                message: `Config validator of tool "${toolId}" must return an array.`,
+                toolId,
             }));
             return;
         }
-        for (const diagnostic of providerDiagnostics) {
+        for (const diagnostic of toolDiagnostics) {
             diagnostics.push({
                 ...diagnostic,
-                path: diagnostic.path || `providers.${providerId}`,
-                providerId: diagnostic.providerId || providerId,
-                toolId: diagnostic.toolId || providerId,
+                path: diagnostic.path || `providers.${toolId}`,
+                toolId: diagnostic.toolId || toolId,
             });
         }
     }
@@ -95,10 +91,9 @@ function validateProviderConfig(providerId, providerConfig, tool, diagnostics) {
         diagnostics.push(createDiagnostic({
             code: "tools.providerValidateFailed",
             severity: "error",
-            path: `providers.${providerId}`,
-            message: `Provider validator failed for "${providerId}": ${error instanceof Error ? error.message : String(error)}`,
-            providerId,
-            toolId: providerId,
+            path: `providers.${toolId}`,
+            message: `Config validator of tool "${toolId}" failed: ${error instanceof Error ? error.message : String(error)}`,
+            toolId,
         }));
     }
 }
@@ -176,27 +171,16 @@ function collectPolicyDiagnostics(config, toolMap, diagnostics) {
         }));
     }
 }
-function collectProviderKeyDiagnostics(config, toolMap, hasRemovedTtsKey, diagnostics) {
-    if (hasRemovedTtsKey) {
-        diagnostics.push(createDiagnostic({
-            code: "tools.removedProviderKey",
-            severity: "error",
-            path: "providers.tts",
-            message: `Provider key "tts" is no longer supported. Use "providers.textToSpeech".`,
-            providerId: "tts",
-            toolId: "textToSpeech",
-        }));
-    }
-    for (const providerId of Object.keys(config.providers).sort()) {
-        if (toolMap.size === 0 || toolMap.has(providerId))
+function collectProviderKeyDiagnostics(config, toolMap, diagnostics) {
+    for (const key of Object.keys(config.providers).sort()) {
+        if (toolMap.size === 0 || toolMap.has(key))
             continue;
         diagnostics.push(createDiagnostic({
             code: "tools.unknownProviderKey",
             severity: "error",
-            path: `providers.${providerId}`,
-            message: `Unknown provider key "${providerId}".`,
-            providerId,
-            toolId: providerId,
+            path: `providers.${key}`,
+            message: `Unknown provider key "${key}".`,
+            toolId: key,
         }));
     }
 }
@@ -245,18 +229,13 @@ export function collectToolConfigDiagnostics(input, toolRegistry) {
             message: 'No tool registry was supplied, so tool ids, placement levels and provider config were not validated, and a coordinator without one registers no tool providers. Pass `toolRegistry` to the coordinator or the toolkit it is bound to — for the packaged capability set, `createPackagedToolRegistry()` from "@pie-players/pie-default-tool-loaders".',
         }));
     }
-    const hasRemovedTtsKey = Object.hasOwn(normalized.providers, "tts");
     const nextProviders = {
         ...(normalized.providers || {}),
     };
-    for (const providerId of Object.keys(nextProviders).sort()) {
-        if (providerId === "tts") {
-            delete nextProviders.tts;
-            continue;
-        }
-        const tool = registryTools.get(providerId);
-        nextProviders[providerId] = sanitizeProviderConfig(providerId, nextProviders[providerId], tool, diagnostics);
-        validateProviderConfig(providerId, nextProviders[providerId], tool, diagnostics);
+    for (const toolId of Object.keys(nextProviders).sort()) {
+        const tool = registryTools.get(toolId);
+        nextProviders[toolId] = sanitizeToolConfig(toolId, nextProviders[toolId], tool, diagnostics);
+        validateToolConfig(toolId, nextProviders[toolId], tool, diagnostics);
     }
     const nextConfig = {
         ...normalized,
@@ -264,24 +243,20 @@ export function collectToolConfigDiagnostics(input, toolRegistry) {
     };
     collectPlacementDiagnostics(nextConfig, registryTools, diagnostics);
     collectPolicyDiagnostics(nextConfig, registryTools, diagnostics);
-    collectProviderKeyDiagnostics(nextConfig, registryTools, hasRemovedTtsKey, diagnostics);
+    collectProviderKeyDiagnostics(nextConfig, registryTools, diagnostics);
     return {
         config: nextConfig,
         diagnostics,
     };
 }
 /**
- * Report diagnostics as {@link normalizeAndValidateToolsConfig} does: a removed
- * provider key throws at every strictness, `"warn"` prints every diagnostic, and
- * `"error"` throws the blocking ones or, when there are none, prints the rest.
+ * Report diagnostics as {@link normalizeAndValidateToolsConfig} does: `"warn"`
+ * prints every diagnostic, and `"error"` throws the blocking ones or, when there
+ * are none, prints the rest.
  */
 export function reportToolConfigDiagnostics(diagnostics, options = {}) {
     const strictness = normalizeToolConfigStrictness(options.strictness);
     const source = options.source ?? "tools";
-    const removedKeys = diagnostics.filter((entry) => entry.code === "tools.removedProviderKey");
-    if (removedKeys.length > 0) {
-        throwValidationError(removedKeys, source);
-    }
     if (strictness === "warn") {
         emitWarnings(diagnostics, source);
     }

package/dist/services/tool-context.d.ts

@@ -101,14 +101,6 @@ export interface ElementToolContext extends BaseToolContext {
  * Union type of all tool contexts
  */
 export type ToolContext = AssessmentToolContext | SectionToolContext | ItemToolContext | PassageToolContext | RubricToolContext | ElementToolContext;
-/**
- * Type guard to check if context is at assessment level
- */
-export declare function isAssessmentContext(context: ToolContext): context is AssessmentToolContext;
-/**
- * Type guard to check if context is at section level
- */
-export declare function isSectionContext(context: ToolContext): context is SectionToolContext;
 /**
  * Type guard to check if context is at item level
  */

package/dist/services/tool-context.js

@@ -4,18 +4,6 @@
  * Defines the context types passed to tools for making visibility and behavior decisions.
  * Each context level provides increasingly specific information about where the tool is being used.
  */
-/**
- * Type guard to check if context is at assessment level
- */
-export function isAssessmentContext(context) {
-    return context.level === "assessment";
-}
-/**
- * Type guard to check if context is at section level
- */
-export function isSectionContext(context) {
-    return context.level === "section";
-}
 /**
  * Type guard to check if context is at item level
  */

package/dist/services/tool-icons.d.ts

@@ -9,9 +9,10 @@
  * Names are generic shapes ("book-open", "beaker"), never capability names. Core
  * naming a capability is what the composition layer exists to prevent.
  *
- * Exported through `tools/internal` as well: a registration composing a selection
- * gateway renders its own buttons and has to draw the same icon the toolbar button
- * draws, or the learner sees two unrelated affordances for one tool.
+ * `resolveFallbackToolIcon` is exported through `tools/registration` as well: a
+ * registration composing a selection gateway renders its own buttons and has to
+ * draw the same icon the toolbar button draws, or the learner sees two unrelated
+ * affordances for one tool.
  */
 export declare const TOOL_FALLBACK_ICONS: Readonly<Record<string, string>>;
 /** Icon markup for `name`, or `null` when nothing built in matches. */

package/dist/services/tool-icons.js

@@ -9,9 +9,10 @@
  * Names are generic shapes ("book-open", "beaker"), never capability names. Core
  * naming a capability is what the composition layer exists to prevent.
  *
- * Exported through `tools/internal` as well: a registration composing a selection
- * gateway renders its own buttons and has to draw the same icon the toolbar button
- * draws, or the learner sees two unrelated affordances for one tool.
+ * `resolveFallbackToolIcon` is exported through `tools/registration` as well: a
+ * registration composing a selection gateway renders its own buttons and has to
+ * draw the same icon the toolbar button draws, or the learner sees two unrelated
+ * affordances for one tool.
  */
 export const TOOL_FALLBACK_ICONS = {
     calculator: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M7 2h10a2 2 0 0 1 2 2v16a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2Zm0 2v4h10V4H7Zm0 6v2h2v-2H7Zm4 0v2h2v-2h-2Zm4 0v2h2v-2h-2Zm-8 4v2h2v-2H7Zm4 0v2h2v-2h-2Zm4 0v2h2v-2h-2Zm-8 4v2h2v-2H7Zm4 0v2h2v-2h-2Zm4 0v2h2v-2h-2Z" fill="currentColor"/></svg>',

package/dist/services/tool-instance-id.d.ts

@@ -11,4 +11,3 @@ export declare function registerToolScopeLevel(scopeLevel: string): void;
 export declare function isRegisteredToolScopeLevel(scopeLevel: string): scopeLevel is ToolScopeLevel;
 export declare function createScopedToolId(baseToolId: string, scopeLevel: ToolScopeLevel, scopeId: string): string;
 export declare function parseScopedToolId(id: string): ParsedToolInstanceId | null;
-export declare function toOverlayToolId(id: string): string;

package/dist/services/tool-instance-id.js

@@ -46,9 +46,3 @@ export function parseScopedToolId(id) {
         scopeId,
     };
 }
-export function toOverlayToolId(id) {
-    const parsed = parseScopedToolId(id);
-    if (!parsed)
-        return id;
-    return createScopedToolId(parsed.baseToolId, parsed.scopeLevel, parsed.scopeId);
-}

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

@@ -1,10 +1,12 @@
 /**
  * TTS Tool Provider
  *
- * Unified provider for all TTS backends:
- * - Browser Web Speech API (no auth)
- * - AWS Polly (requires auth via server proxy)
- * - Google Cloud TTS (requires auth via server proxy)
+ * Unified provider for both TTS backends:
+ * - `browser`: the Web Speech API (no auth)
+ * - `server`: a TTS server, its service named by the config's `provider`.
+ *   `polly` and `google` run on the `pie` transport; `custom` runs on the
+ *   `custom` transport to a host's own service, which takes `lang_id`,
+ *   `speedRate` and `cache`
  *
  * Part of PIE Assessment Toolkit.
  */
@@ -13,12 +15,10 @@ import type { RuntimeTTSConfig, TTSRuntimeSettings } from "../tts-runtime-config
 import type { ToolProviderApi, ToolProviderCapabilities } from "./ToolProviderApi.js";
 export type TTSBackend = NonNullable<TTSRuntimeSettings["backend"]>;
 /**
- * The runtime provider config plus the backend selection and instrumentation
- * this tool provider reads.
+ * The runtime provider config plus the credentials and instrumentation this
+ * tool provider reads. The backend is fixed at construction.
  */
 export type TTSToolProviderConfig = RuntimeTTSConfig & {
-    backend: TTSBackend;
-    serverProvider?: TTSRuntimeSettings["serverProvider"];
     /**
      * Bearer token for a server backend, sent as `Authorization`. A host supplies
      * it through `provider.runtime.authFetcher`.
@@ -38,34 +38,34 @@ export type TTSToolProviderOptions = {
 /**
  * TTS Tool Provider
  *
- * Wraps TTS providers (Browser, Polly, Google) with the ToolProviderApi interface
+ * Wraps the browser or a server TTS provider with the ToolProviderApi interface
  * for use in the ToolProviderRegistry.
  *
  * @example Browser TTS (no auth)
  * ```typescript
  * const provider = new TTSToolProvider();
- * await provider.initialize({ backend: 'browser' });
+ * await provider.initialize({});
  * const ttsProvider = await provider.createInstance();
  * ```
  *
  * @example Server TTS
  * ```typescript
- * const provider = new TTSToolProvider('polly', {
+ * const provider = new TTSToolProvider('server', {
  *   loadServerProvider: async () => ServerTTSProvider,
  * });
  * await provider.initialize({
- *   backend: 'polly',
+ *   provider: 'polly',
  *   apiEndpoint: '/api/tts',
  * });
  * const ttsProvider = await provider.createInstance();
  * ```
  */
-export declare class TTSToolProvider implements ToolProviderApi<TTSToolProviderConfig, ITTSProvider> {
-    readonly providerId = "tts-service";
+export declare class TTSToolProvider implements ToolProviderApi<ITTSProvider> {
     readonly providerName = "Text-to-Speech";
     readonly category: "tts";
     readonly version = "1.0";
     readonly requiresAuth: boolean;
+    private readonly backend;
     private ttsProvider;
     private config;
     private readonly loadServerProvider;
@@ -82,7 +82,7 @@ export declare class TTSToolProvider implements ToolProviderApi<TTSToolProviderC
      *
      * Sets up the appropriate TTS backend.
      *
-     * @param config Configuration with backend type and credentials
+     * @param config Runtime configuration and credentials
      * @throws Error if initialization fails or required config missing
      */
     initialize(config: TTSToolProviderConfig): Promise<void>;
@@ -91,7 +91,7 @@ export declare class TTSToolProvider implements ToolProviderApi<TTSToolProviderC
      */
     private _initializeBrowserTTS;
     /**
-     * Initialize server-based TTS (Polly, Google)
+     * Initialize server-based TTS
      */
     private _initializeServerTTS;
     /**
@@ -105,9 +105,8 @@ export declare class TTSToolProvider implements ToolProviderApi<TTSToolProviderC
      */
     createInstance(config?: Partial<TTSToolProviderConfig>): Promise<ITTSProvider>;
     /**
-     * Get provider capabilities
-     *
-     * @returns TTS capabilities based on backend
+     * The backend's capabilities. Its features are the speech provider's own,
+     * and all false before {@link initialize} creates it.
      */
     getCapabilities(): ToolProviderCapabilities;
     /**

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

@@ -1,14 +1,18 @@
 /**
  * TTS Tool Provider
  *
- * Unified provider for all TTS backends:
- * - Browser Web Speech API (no auth)
- * - AWS Polly (requires auth via server proxy)
- * - Google Cloud TTS (requires auth via server proxy)
+ * Unified provider for both TTS backends:
+ * - `browser`: the Web Speech API (no auth)
+ * - `server`: a TTS server, its service named by the config's `provider`.
+ *   `polly` and `google` run on the `pie` transport; `custom` runs on the
+ *   `custom` transport to a host's own service, which takes `lang_id`,
+ *   `speedRate` and `cache`
  *
  * Part of PIE Assessment Toolkit.
  */
+import { createPieLogger, isTtsDebugEnabled, } from "@pie-players/pie-players-shared/pie";
 import { BrowserTTSProvider } from "../../services/tts/browser-provider.js";
+const logger = createPieLogger("tts-tool-provider", isTtsDebugEnabled);
 /**
  * Binds a server backend's provider to the config the registry initialized this
  * tool provider with, including what `provider.runtime.authFetcher` returned.
@@ -34,7 +38,6 @@ function bindServerBackendConfig(provider, bound) {
             };
             return provider.initialize(merged);
         },
-        supportsFeature: (feature) => provider.supportsFeature(feature),
         getCapabilities: () => provider.getCapabilities(),
         destroy: () => provider.destroy(),
     };
@@ -42,34 +45,34 @@ function bindServerBackendConfig(provider, bound) {
 /**
  * TTS Tool Provider
  *
- * Wraps TTS providers (Browser, Polly, Google) with the ToolProviderApi interface
+ * Wraps the browser or a server TTS provider with the ToolProviderApi interface
  * for use in the ToolProviderRegistry.
  *
  * @example Browser TTS (no auth)
  * ```typescript
  * const provider = new TTSToolProvider();
- * await provider.initialize({ backend: 'browser' });
+ * await provider.initialize({});
  * const ttsProvider = await provider.createInstance();
  * ```
  *
  * @example Server TTS
  * ```typescript
- * const provider = new TTSToolProvider('polly', {
+ * const provider = new TTSToolProvider('server', {
  *   loadServerProvider: async () => ServerTTSProvider,
  * });
  * await provider.initialize({
- *   backend: 'polly',
+ *   provider: 'polly',
  *   apiEndpoint: '/api/tts',
  * });
  * const ttsProvider = await provider.createInstance();
  * ```
  */
 export class TTSToolProvider {
-    providerId = "tts-service";
     providerName = "Text-to-Speech";
     category = "tts";
     version = "1.0";
     requiresAuth;
+    backend;
     ttsProvider = null;
     config = null;
     loadServerProvider;
@@ -88,6 +91,7 @@ export class TTSToolProvider {
      * @param options Loader for the server adapter, required by server backends
      */
     constructor(backend = "browser", options = {}) {
+        this.backend = backend;
         this.requiresAuth = backend !== "browser";
         this.loadServerProvider = options.loadServerProvider;
     }
@@ -96,7 +100,7 @@ export class TTSToolProvider {
      *
      * Sets up the appropriate TTS backend.
      *
-     * @param config Configuration with backend type and credentials
+     * @param config Runtime configuration and credentials
      * @throws Error if initialization fails or required config missing
      */
     async initialize(config) {
@@ -105,19 +109,17 @@ export class TTSToolProvider {
             return;
         }
         this.config = config;
-        switch (config.backend) {
+        switch (this.backend) {
             case "browser":
                 await this._initializeBrowserTTS(config);
                 break;
-            case "polly":
-            case "google":
             case "server":
                 await this._initializeServerTTS(config);
                 break;
             default:
-                throw new Error(`[TTSToolProvider] Unknown backend: ${config.backend}`);
+                throw new Error(`[TTSToolProvider] Unknown backend: ${this.backend}`);
         }
-        console.log(`[TTSToolProvider] Initialized successfully (backend: ${config.backend})`);
+        logger.debug(`initialized (backend: ${this.backend})`);
     }
     /**
      * Initialize browser TTS (Web Speech API)
@@ -128,10 +130,10 @@ export class TTSToolProvider {
             throw new Error("[TTSToolProvider] Browser TTS not supported (Web Speech API not available)");
         }
         this.ttsProvider = new BrowserTTSProvider();
-        console.log("[TTSToolProvider] Browser TTS initialized (Web Speech API)");
+        logger.debug("browser TTS initialized (Web Speech API)");
     }
     /**
-     * Initialize server-based TTS (Polly, Google)
+     * Initialize server-based TTS
      */
     async _initializeServerTTS(config) {
         if (!config.apiEndpoint) {
@@ -141,11 +143,12 @@ export class TTSToolProvider {
         if (!loadServerProvider) {
             throw new Error("[TTSToolProvider] server-based TTS backends need the loadServerProvider option");
         }
+        const serverProvider = config.provider || this.backend;
         const moduleLoadStartedAt = Date.now();
         await this.emitTelemetry("pie-tool-library-load-start", {
             toolId: "textToSpeech",
             operation: "server-provider-module-import",
-            backend: config.serverProvider || config.backend,
+            backend: serverProvider,
         });
         const ServerProvider = await (async () => {
             try {
@@ -153,7 +156,7 @@ export class TTSToolProvider {
                 await this.emitTelemetry("pie-tool-library-load-success", {
                     toolId: "textToSpeech",
                     operation: "server-provider-module-import",
-                    backend: config.serverProvider || config.backend,
+                    backend: serverProvider,
                     duration: Date.now() - moduleLoadStartedAt,
                 });
                 return loaded;
@@ -162,7 +165,7 @@ export class TTSToolProvider {
                 await this.emitTelemetry("pie-tool-library-load-error", {
                     toolId: "textToSpeech",
                     operation: "server-provider-module-import",
-                    backend: config.serverProvider || config.backend,
+                    backend: serverProvider,
                     duration: Date.now() - moduleLoadStartedAt,
                     errorType: "ToolLibraryLoadError",
                     message: error instanceof Error ? error.message : String(error),
@@ -170,9 +173,9 @@ export class TTSToolProvider {
                 throw error;
             }
         })();
-        const { backend, serverProvider, onTelemetry, ...backendConfig } = config;
+        const { onTelemetry: _onTelemetry, ...backendConfig } = config;
         this.ttsProvider = bindServerBackendConfig(new ServerProvider(), backendConfig);
-        console.log(`[TTSToolProvider] Server TTS initialized (provider: ${config.serverProvider || config.backend})`);
+        logger.debug(`server TTS initialized (provider: ${serverProvider})`);
     }
     /**
      * Create a TTS provider instance
@@ -190,23 +193,23 @@ export class TTSToolProvider {
         return this.ttsProvider;
     }
     /**
-     * Get provider capabilities
-     *
-     * @returns TTS capabilities based on backend
+     * The backend's capabilities. Its features are the speech provider's own,
+     * and all false before {@link initialize} creates it.
      */
     getCapabilities() {
-        const isBrowser = this.config?.backend === "browser";
+        const isBrowser = this.backend === "browser";
+        const speech = this.ttsProvider?.getCapabilities();
         return {
             supportsOffline: isBrowser,
             requiresAuth: !isBrowser,
             maxInstances: 1, // Single TTS instance (playback is sequential)
             features: {
-                wordBoundary: true, // All backends support word highlighting
-                pause: true,
-                resume: true,
-                rateControl: true,
-                pitchControl: isBrowser, // Only browser supports pitch
-                voiceSelection: true,
+                wordBoundary: speech?.supportsWordBoundary ?? false,
+                pause: speech?.supportsPause ?? false,
+                resume: speech?.supportsResume ?? false,
+                rateControl: speech?.supportsRateControl ?? false,
+                pitchControl: speech?.supportsPitchControl ?? false,
+                voiceSelection: speech?.supportsVoiceSelection ?? false,
             },
         };
     }
@@ -229,6 +232,6 @@ export class TTSToolProvider {
             this.ttsProvider = null;
         }
         this.config = null;
-        console.log("[TTSToolProvider] Destroyed");
+        logger.debug("destroyed");
     }
 }

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

@@ -11,14 +11,20 @@ export interface ToolProviderCapabilities {
     maxInstances?: number | null;
     features: Record<string, boolean>;
 }
-export interface ToolProviderApi<TConfig = any, TInstance = any> {
-    readonly providerId: string;
+/**
+ * A tool's provider. It registers under its tool's id, which is how the toolkit
+ * and the tool find it; it carries no id of its own.
+ *
+ * Config takes no type parameter (ADR 0002): an implementation narrows it in its
+ * own method signatures.
+ */
+export interface ToolProviderApi<TInstance = any> {
     readonly providerName: string;
     readonly category: ToolCategory;
     readonly version: string;
     readonly requiresAuth: boolean;
-    initialize(config: TConfig): Promise<void>;
-    createInstance(config?: Partial<TConfig>): Promise<TInstance>;
+    initialize(config: unknown): Promise<void>;
+    createInstance(config?: unknown): Promise<TInstance>;
     getCapabilities(): ToolProviderCapabilities;
     isReady(): boolean;
     destroy(): void;