@skillprint/cocos-sdk 0.0.1

package/cc.d.ts

@@ -0,0 +1,58 @@
+declare module 'cc' {
+    export const _decorator: {
+        ccclass(name?: string): Function;
+        property(options?: any): Function;
+    };
+    export class Component {
+        node: any;
+        enabled: boolean;
+        start(): void;
+        onLoad(): void;
+        onDestroy(): void;
+        schedule(callback: any, interval?: number, repeat?: number, delay?: number): void;
+        unschedule(callback: any): void;
+        getComponent<T>(type: any): T | null;
+        addComponent<T>(type: any): T;
+    }
+    export class Camera {
+        targetTexture: any;
+        node: any;
+        enabled: boolean;
+        render(): void;
+    }
+    export class RenderTexture {
+        reset(config: any): void;
+        readPixels(x?: number, y?: number, width?: number, height?: number, buffer?: Uint8Array): Uint8Array;
+        destroy(): void;
+    }
+    export const view: {
+        getVisibleSize(): { width: number; height: number };
+    };
+    export const sys: {
+        isBrowser: boolean;
+        isNative: boolean;
+        localStorage: {
+            setItem(key: string, value: string): void;
+            getItem(key: string): string | null;
+        };
+    };
+    export const native: {
+        fileUtils: {
+            getWritablePath(): string;
+            getDataFromFile(filePath: string): ArrayBuffer | null;
+            removeFile(filePath: string): boolean;
+        };
+        saveImageData(data: Uint8Array, width: number, height: number, filePath: string): Promise<void>;
+    };
+    export const director: {
+        addPersistRootNode(node: any): void;
+        getScene(): {
+            children: any[];
+        } | null;
+        once(event: string, callback: Function, target?: any): void;
+    };
+    export const Director: {
+        EVENT_AFTER_RENDER: string;
+    };
+    export function Enum(obj: any): any;
+}

package/dist/ScreenshotUtility.d.ts

@@ -0,0 +1,27 @@
+import { Camera } from 'cc';
+export declare class ScreenshotUtility {
+    private logger;
+    constructor(logger?: (msg: string, level: 'Info' | 'Warning' | 'Error') => void);
+    private log;
+    /**
+     * Captures a screenshot from the specified camera, flips it vertically,
+     * downscales it if necessary, and returns a JPEG Blob (Web) or ArrayBuffer (Native).
+     */
+    captureScreenshot(camera: Camera, maxWidth?: number, jpegQuality?: number): Promise<Blob | ArrayBuffer | null>;
+    /**
+     * Vertically flips the raw pixel buffer in-place.
+     */
+    private flipY;
+    /**
+     * HTML5 Canvas based JPEG encoder and scaling for web platforms
+     */
+    private encodeOnWeb;
+    /**
+     * Native file and image API based JPEG encoder for Android/iOS/Desktop
+     */
+    private encodeOnNative;
+    /**
+     * Simple pixel downsampling helper for native builds without canvas API
+     */
+    private downsamplePixels;
+}

package/dist/ScreenshotUtility.js

@@ -0,0 +1,216 @@
+import { RenderTexture, view, sys, native, director, Director } from 'cc';
+export class ScreenshotUtility {
+    constructor(logger) {
+        this.logger = null;
+        if (logger) {
+            this.logger = logger;
+        }
+    }
+    log(msg, level = 'Info') {
+        if (this.logger) {
+            this.logger(msg, level);
+        }
+        else {
+            const prefix = `[ScreenshotUtility] [${level}]`;
+            if (level === 'Error') {
+                console.error(`${prefix} ${msg}`);
+            }
+            else if (level === 'Warning') {
+                console.warn(`${prefix} ${msg}`);
+            }
+            else {
+                console.log(`${prefix} ${msg}`);
+            }
+        }
+    }
+    /**
+     * Captures a screenshot from the specified camera, flips it vertically,
+     * downscales it if necessary, and returns a JPEG Blob (Web) or ArrayBuffer (Native).
+     */
+    async captureScreenshot(camera, maxWidth = 960, jpegQuality = 60) {
+        if (!camera) {
+            this.log('Cannot capture: Camera is null', 'Error');
+            return null;
+        }
+        try {
+            const visibleSize = view.getVisibleSize();
+            const width = Math.floor(visibleSize.width);
+            const height = Math.floor(visibleSize.height);
+            this.log(`Capturing screenshot: resolution ${width}x${height}`, 'Info');
+            // 1. Create RenderTexture
+            const renderTexture = new RenderTexture();
+            renderTexture.reset({
+                width: width,
+                height: height
+            });
+            // 2. Render camera into the texture by waiting for the render pipeline cycle
+            const prevTarget = camera.targetTexture;
+            camera.targetTexture = renderTexture;
+            await new Promise((resolve) => {
+                director.once(Director.EVENT_AFTER_RENDER, resolve);
+            });
+            camera.targetTexture = prevTarget; // restore camera settings
+            // 3. Read pixels from GPU
+            const pixelBuffer = new Uint8Array(width * height * 4);
+            renderTexture.readPixels(0, 0, width, height, pixelBuffer);
+            // Clean up RenderTexture immediately to free GPU memory
+            renderTexture.destroy();
+            // 4. Flip pixel coordinates vertically (WebGL reads bottom-to-top)
+            this.flipY(pixelBuffer, width, height);
+            // 5. Handle Platform-Specific Encoding
+            if (sys.isBrowser) {
+                return await this.encodeOnWeb(pixelBuffer, width, height, maxWidth, jpegQuality);
+            }
+            else if (sys.isNative && !!native && typeof native.saveImageData === 'function') {
+                return await this.encodeOnNative(pixelBuffer, width, height, maxWidth, jpegQuality);
+            }
+            else {
+                this.log('Platform not supported for screenshot encoding. Returning raw buffer.', 'Warning');
+                return pixelBuffer.buffer;
+            }
+        }
+        catch (err) {
+            this.log(`Failed to capture screenshot: ${err.message || err}`, 'Error');
+            return null;
+        }
+    }
+    /**
+     * Vertically flips the raw pixel buffer in-place.
+     */
+    flipY(pixels, width, height) {
+        const rowBytes = width * 4;
+        const tempRow = new Uint8Array(rowBytes);
+        for (let row = 0; row < Math.floor(height / 2); row++) {
+            const topOffset = row * rowBytes;
+            const bottomOffset = (height - 1 - row) * rowBytes;
+            // Swap top and bottom rows
+            tempRow.set(pixels.subarray(topOffset, topOffset + rowBytes));
+            pixels.set(pixels.subarray(bottomOffset, bottomOffset + rowBytes), topOffset);
+            pixels.set(tempRow, bottomOffset);
+        }
+    }
+    /**
+     * HTML5 Canvas based JPEG encoder and scaling for web platforms
+     */
+    encodeOnWeb(pixels, width, height, maxWidth, jpegQuality) {
+        return new Promise((resolve) => {
+            try {
+                // Determine target dimensions
+                let destWidth = width;
+                let destHeight = height;
+                if (maxWidth > 0 && width > maxWidth) {
+                    const scale = maxWidth / width;
+                    destWidth = maxWidth;
+                    destHeight = Math.floor(height * scale);
+                }
+                // Create offscreen canvas for rendering
+                const canvas = document.createElement('canvas');
+                canvas.width = destWidth;
+                canvas.height = destHeight;
+                const ctx = canvas.getContext('2d');
+                if (!ctx) {
+                    this.log('Could not get HTML5 canvas 2D context', 'Error');
+                    resolve(null);
+                    return;
+                }
+                if (destWidth === width && destHeight === height) {
+                    // Direct copy
+                    const imgData = ctx.createImageData(width, height);
+                    imgData.data.set(pixels);
+                    ctx.putImageData(imgData, 0, 0);
+                }
+                else {
+                    // Downscale using intermediate canvas drawing
+                    const srcCanvas = document.createElement('canvas');
+                    srcCanvas.width = width;
+                    srcCanvas.height = height;
+                    const srcCtx = srcCanvas.getContext('2d');
+                    if (srcCtx) {
+                        const imgData = srcCtx.createImageData(width, height);
+                        imgData.data.set(pixels);
+                        srcCtx.putImageData(imgData, 0, 0);
+                        // Render downscaled image
+                        ctx.drawImage(srcCanvas, 0, 0, destWidth, destHeight);
+                    }
+                    else {
+                        resolve(null);
+                        return;
+                    }
+                }
+                const qualityFactor = Math.max(0.01, Math.min(1.0, jpegQuality / 100));
+                canvas.toBlob((blob) => {
+                    resolve(blob);
+                }, 'image/jpeg', qualityFactor);
+            }
+            catch (err) {
+                this.log(`Web encoding failed: ${err.message || err}`, 'Error');
+                resolve(null);
+            }
+        });
+    }
+    /**
+     * Native file and image API based JPEG encoder for Android/iOS/Desktop
+     */
+    async encodeOnNative(pixels, width, height, maxWidth, jpegQuality) {
+        try {
+            // Note: Cocos Creator Native saveImageData saves raw pixel buffers to file.
+            // Under the hood, if the filename has a .jpg extension, it handles JPEG compression.
+            const writablePath = native.fileUtils.getWritablePath();
+            const filePath = `${writablePath}temp_screenshot.jpg`;
+            // If downscaling is needed natively, we pass smaller dimensions if native API supports scaling, 
+            // otherwise saveImageData handles saving raw buffer.
+            let targetWidth = width;
+            let targetHeight = height;
+            let finalPixels = pixels;
+            if (maxWidth > 0 && width > maxWidth) {
+                const scale = maxWidth / width;
+                targetWidth = maxWidth;
+                targetHeight = Math.floor(height * scale);
+                // Perform a simple downsampling if size is reduced (e.g. skip pixels)
+                // In Cocos 3.x, saveImageData is standard, so we can save it and let the engine compress it.
+                // We'll downsample finalPixels array to match target size
+                finalPixels = this.downsamplePixels(pixels, width, height, targetWidth, targetHeight);
+            }
+            // Save image using Cocos native APIs (saves as JPEG on .jpg extension)
+            // Note: native.saveImageData returns a Promise or runs synchronously. In 3.8.x, it returns a Promise.
+            await native.saveImageData(finalPixels, targetWidth, targetHeight, filePath);
+            // Read the saved file back into memory
+            const arrayBuffer = native.fileUtils.getDataFromFile(filePath);
+            // Clean up the temporary file
+            native.fileUtils.removeFile(filePath);
+            if (arrayBuffer && arrayBuffer.byteLength > 0) {
+                this.log(`Native screenshot encoded successfully. Size: ${arrayBuffer.byteLength} bytes`, 'Info');
+                return arrayBuffer;
+            }
+            else {
+                this.log('Failed to read native saved screenshot back from local storage', 'Error');
+                return null;
+            }
+        }
+        catch (err) {
+            this.log(`Native encoding failed: ${err.message || err}`, 'Error');
+            return null;
+        }
+    }
+    /**
+     * Simple pixel downsampling helper for native builds without canvas API
+     */
+    downsamplePixels(pixels, srcW, srcH, destW, destH) {
+        const destPixels = new Uint8Array(destW * destH * 4);
+        const xRatio = srcW / destW;
+        const yRatio = srcH / destH;
+        for (let y = 0; y < destH; y++) {
+            for (let x = 0; x < destW; x++) {
+                const srcX = Math.floor(x * xRatio);
+                const srcY = Math.floor(y * yRatio);
+                const srcIdx = (srcY * srcW + srcX) * 4;
+                const destIdx = (y * destW + x) * 4;
+                destPixels[destIdx] = pixels[srcIdx]; // R
+                destPixels[destIdx + 1] = pixels[srcIdx + 1]; // G
+                destPixels[destIdx + 2] = pixels[srcIdx + 2]; // B
+                destPixels[destIdx + 3] = pixels[srcIdx + 3]; // A
+            }
+        }
+        return destPixels;
+    }
+}

package/dist/SkillprintAPIClient.d.ts

@@ -0,0 +1,23 @@
+import { ParameterInfo, ParameterUpdateResult } from './SkillprintTypes';
+export declare class SkillprintAPIClient {
+    private baseUrl;
+    private partnerApiKey;
+    private userToken;
+    private logger;
+    private static readonly START_SESSION_ENDPOINT;
+    private static readonly UPLOAD_SCREENSHOTS_ENDPOINT;
+    private static readonly POLL_RESULTS_ENDPOINT;
+    private static readonly CREATE_USER_ENDPOINT;
+    private static readonly GET_USER_TOKEN_ENDPOINT;
+    private static readonly MAX_UPLOAD_RETRIES;
+    private static readonly RETRY_BASE_DELAY_MS;
+    constructor(baseUrl: string, partnerApiKey: string, logger?: (msg: string, level: 'Info' | 'Warning' | 'Error') => void);
+    private log;
+    startSession(sessionId: string, targetMood: string, customPlayerId: string | null, gameName: string, gameParameters: ParameterInfo[]): Promise<boolean>;
+    postScreenshots(sessionId: string, screenshots: (Blob | ArrayBuffer)[], isLastChunk: boolean): Promise<boolean>;
+    pollParameterResults(sessionId: string): Promise<ParameterUpdateResult[]>;
+    getParsedValue(update: ParameterUpdateResult): any;
+    createOrGetUserToken(customPlayerId: string): Promise<string | null>;
+    private createUser;
+    private getUserToken;
+}

package/dist/SkillprintAPIClient.js

@@ -0,0 +1,284 @@
+export class SkillprintAPIClient {
+    constructor(baseUrl, partnerApiKey, logger) {
+        this.userToken = null;
+        this.logger = null;
+        this.baseUrl = baseUrl.replace(/\/+$/, '');
+        this.partnerApiKey = partnerApiKey;
+        if (logger) {
+            this.logger = logger;
+        }
+    }
+    log(msg, level = 'Info') {
+        if (this.logger) {
+            this.logger(msg, level);
+        }
+        else {
+            const prefix = `[SkillprintAPIClient] [${level}]`;
+            if (level === 'Error') {
+                console.error(`${prefix} ${msg}`);
+            }
+            else if (level === 'Warning') {
+                console.warn(`${prefix} ${msg}`);
+            }
+            else {
+                console.log(`${prefix} ${msg}`);
+            }
+        }
+    }
+    async startSession(sessionId, targetMood, customPlayerId, gameName, gameParameters) {
+        const url = `${this.baseUrl}${SkillprintAPIClient.START_SESSION_ENDPOINT}`;
+        this.log(`Starting session: POST ${url}`, 'Info');
+        this.log(`Starting session: MOOD ${targetMood}`, 'Warning');
+        // Provision/retrieve user token if customPlayerId is provided
+        if (customPlayerId) {
+            try {
+                this.userToken = await this.createOrGetUserToken(customPlayerId);
+                if (this.userToken) {
+                    this.log(`User token obtained successfully for player: ${customPlayerId}`, 'Info');
+                }
+                else {
+                    this.log(`Could not retrieve user token for player: ${customPlayerId}. Continuing without token.`, 'Warning');
+                }
+            }
+            catch (err) {
+                this.log(`Error obtaining user token: ${err.message || err}. Continuing without token.`, 'Warning');
+            }
+        }
+        const requestData = {
+            sessionId: sessionId,
+            game: gameName,
+            targetMood: targetMood,
+            gameParameters: gameParameters
+        };
+        const headers = {
+            'Content-Type': 'application/json',
+            'Authorization': `Api-Key ${this.partnerApiKey}`
+        };
+        if (this.userToken) {
+            headers['X-Auth-Token'] = `Token ${this.userToken}`;
+        }
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: headers,
+                body: JSON.stringify(requestData)
+            });
+            const text = await response.text();
+            if (response.ok) {
+                this.log(`StartSession successful. Response: ${text}`, 'Info');
+                return true;
+            }
+            else {
+                this.log(`StartSession Error: ${response.statusText}. Response: ${text}`, 'Error');
+                return false;
+            }
+        }
+        catch (err) {
+            this.log(`StartSession Network Error: ${err.message || err}`, 'Error');
+            return false;
+        }
+    }
+    async postScreenshots(sessionId, screenshots, isLastChunk) {
+        const endpoint = SkillprintAPIClient.UPLOAD_SCREENSHOTS_ENDPOINT.replace('{sessionId}', sessionId);
+        const url = `${this.baseUrl}${endpoint}`;
+        this.log(`Posting ${screenshots.length} screenshots (isLastChunk: ${isLastChunk}): POST ${url}`, 'Info');
+        if (screenshots.length === 0 && !isLastChunk) {
+            this.log(`No screenshots provided, and isLastChunk is false. Skipping.`, 'Warning');
+            return false;
+        }
+        let attempt = 0;
+        let succeeded = false;
+        let lastError = '';
+        while (attempt <= SkillprintAPIClient.MAX_UPLOAD_RETRIES && !succeeded) {
+            if (attempt > 0) {
+                const delay = SkillprintAPIClient.RETRY_BASE_DELAY_MS * Math.pow(2, attempt - 1);
+                this.log(`Retrying screenshot upload (attempt ${attempt + 1}/${SkillprintAPIClient.MAX_UPLOAD_RETRIES + 1}) after ${delay}ms...`, 'Warning');
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+            try {
+                const formData = new FormData();
+                formData.append('is_last_chunk', isLastChunk.toString().toLowerCase());
+                screenshots.forEach((screenshot, i) => {
+                    const blob = screenshot instanceof ArrayBuffer ? new Blob([screenshot], { type: 'image/jpeg' }) : screenshot;
+                    formData.append(`screenshot${i}`, blob, `screenshot_${i}.jpg`);
+                });
+                const headers = {
+                    'Authorization': `Api-Key ${this.partnerApiKey}`
+                };
+                if (this.userToken) {
+                    headers['X-Auth-Token'] = `Token ${this.userToken}`;
+                }
+                // Note: Do not set Content-Type header when sending FormData.
+                // The browser will automatically set the correct multipart/form-data boundary.
+                const response = await fetch(url, {
+                    method: 'POST',
+                    headers: headers,
+                    body: formData
+                });
+                const text = await response.text();
+                if (response.ok) {
+                    this.log(`PostScreenshots successful. Response: ${text}`, 'Info');
+                    succeeded = true;
+                }
+                else {
+                    lastError = `Status: ${response.statusText} | Response: ${text}`;
+                    this.log(`PostScreenshots Error (attempt ${attempt + 1}): ${lastError}`, 'Error');
+                }
+            }
+            catch (err) {
+                lastError = err.message || String(err);
+                this.log(`PostScreenshots Network Error (attempt ${attempt + 1}): ${lastError}`, 'Error');
+            }
+            attempt++;
+        }
+        if (!succeeded) {
+            this.log(`PostScreenshots failed after ${SkillprintAPIClient.MAX_UPLOAD_RETRIES + 1} attempts. Last error: ${lastError}`, 'Error');
+        }
+        return succeeded;
+    }
+    async pollParameterResults(sessionId) {
+        const endpoint = SkillprintAPIClient.POLL_RESULTS_ENDPOINT.replace('{sessionId}', sessionId);
+        const url = `${this.baseUrl}${endpoint}`;
+        this.log(`Polling results: GET ${url}`, 'Info');
+        const headers = {
+            'Authorization': `Api-Key ${this.partnerApiKey}`,
+            'Accept': 'application/json'
+        };
+        if (this.userToken) {
+            headers['X-Auth-Token'] = `Token ${this.userToken}`;
+        }
+        try {
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: headers
+            });
+            const text = await response.text();
+            if (response.ok) {
+                this.log(`PollResults successful. Response: ${text}`, 'Info');
+                let data;
+                try {
+                    data = JSON.parse(text);
+                }
+                catch (jsonErr) {
+                    // Try parsing as array directly if it was wrapped or malformed
+                    if (text.trim().startsWith('[')) {
+                        data = { parameterUpdates: JSON.parse(text) };
+                    }
+                    else {
+                        throw jsonErr;
+                    }
+                }
+                let updates = [];
+                if (data && Array.isArray(data.parameterUpdates)) {
+                    updates = data.parameterUpdates;
+                }
+                else if (Array.isArray(data)) {
+                    updates = data;
+                }
+                // Map updates to extract the parsed values
+                updates.forEach((update) => {
+                    this.log(`Parameter Update: ${update.parameterName} = ${this.getParsedValue(update)}`, 'Info');
+                });
+                return updates;
+            }
+            else {
+                this.log(`PollResults Error: ${response.statusText}. Response: ${text}`, 'Error');
+                return [];
+            }
+        }
+        catch (err) {
+            this.log(`PollResults Error: ${err.message || err}`, 'Error');
+            return [];
+        }
+    }
+    getParsedValue(update) {
+        // Retrieve the newValue or find the key with the parameterName (for legacy or alternative responses)
+        if (update.newValue !== undefined && update.newValue !== null) {
+            return update.newValue;
+        }
+        if (update.parameterName && update[update.parameterName] !== undefined) {
+            return update[update.parameterName];
+        }
+        return null;
+    }
+    async createOrGetUserToken(customPlayerId) {
+        if (!customPlayerId)
+            return null;
+        // Try getting token first
+        let token = await this.getUserToken(customPlayerId);
+        if (token)
+            return token;
+        // User doesn't exist, create user
+        const created = await this.createUser(customPlayerId);
+        if (created) {
+            // Retrieve token again after creation
+            token = await this.getUserToken(customPlayerId);
+            return token;
+        }
+        return null;
+    }
+    async createUser(internalId) {
+        const url = `${this.baseUrl}${SkillprintAPIClient.CREATE_USER_ENDPOINT}`;
+        this.log(`Creating user: POST ${url} with internalId: ${internalId}`, 'Info');
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Api-Key ${this.partnerApiKey}`
+                },
+                body: JSON.stringify({ internalId: internalId })
+            });
+            const text = await response.text();
+            if (response.ok) {
+                this.log(`CreateUser successful. Response: ${text}`, 'Info');
+                return true;
+            }
+            else {
+                this.log(`CreateUser Error: ${response.statusText}. Response: ${text}`, 'Error');
+                return false;
+            }
+        }
+        catch (err) {
+            this.log(`CreateUser Network Error: ${err.message || err}`, 'Error');
+            return false;
+        }
+    }
+    async getUserToken(internalId) {
+        const url = `${this.baseUrl}${SkillprintAPIClient.GET_USER_TOKEN_ENDPOINT}`;
+        this.log(`Getting user token: POST ${url} with internalId: ${internalId}`, 'Info');
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Api-Key ${this.partnerApiKey}`
+                },
+                body: JSON.stringify({ internalId: internalId })
+            });
+            const text = await response.text();
+            if (response.ok) {
+                this.log(`GetUserToken successful. Response: ${text}`, 'Info');
+                const data = JSON.parse(text);
+                return data.token || null;
+            }
+            else {
+                this.log(`GetUserToken Error: ${response.statusText}. Response: ${text}`, 'Error');
+                return null;
+            }
+        }
+        catch (err) {
+            this.log(`GetUserToken Network Error: ${err.message || err}`, 'Error');
+            return null;
+        }
+    }
+}
+// Endpoints
+SkillprintAPIClient.START_SESSION_ENDPOINT = '/games/api/sessions/';
+SkillprintAPIClient.UPLOAD_SCREENSHOTS_ENDPOINT = '/games/api/record-session/{sessionId}/';
+SkillprintAPIClient.POLL_RESULTS_ENDPOINT = '/games/api/sessions/{sessionId}/';
+SkillprintAPIClient.CREATE_USER_ENDPOINT = '/partners/api/users/add/';
+SkillprintAPIClient.GET_USER_TOKEN_ENDPOINT = '/partners/api/users/auth/token/';
+// Retry settings
+SkillprintAPIClient.MAX_UPLOAD_RETRIES = 2;
+SkillprintAPIClient.RETRY_BASE_DELAY_MS = 1000;

package/dist/SkillprintConfigComponent.d.ts

@@ -0,0 +1,17 @@
+import { Component } from 'cc';
+import { ApiEnvironment, SkillprintConfig } from './SkillprintTypes';
+export declare class SkillprintConfigComponent extends Component {
+    gameName: string;
+    targetEnvironment: ApiEnvironment;
+    stagingPartnerApiKey: string;
+    stagingApiBaseUrl: string;
+    productionPartnerApiKey: string;
+    productionApiBaseUrl: string;
+    screenshotMaxWidth: number;
+    screenshotJpegQuality: number;
+    screenshotIntervalSeconds: number;
+    screenshotPostIntervalSeconds: number;
+    pollResultsIntervalSeconds: number;
+    enableDebugLogging: boolean;
+    getConfig(): SkillprintConfig;
+}