@framers/agentos-ext-ml-classifiers 0.1.0 → 0.3.1

package/dist/classifiers/WorkerClassifierProxy.d.ts

@@ -1,158 +0,0 @@
-/**
- * @fileoverview WorkerClassifierProxy — wraps an IContentClassifier to run
- * inference inside a Web Worker, with automatic main-thread fallback.
- *
- * ## Why a proxy?
- * ML inference (even quantized ONNX / WASM pipelines) can block the main
- * thread for 50–500 ms per classification.  Moving classification into a
- * Web Worker keeps the UI responsive.  This proxy makes the switch
- * transparent to callers: they still call `classify(text)` and receive a
- * `ClassificationResult`; the underlying transport (Worker vs. direct call)
- * is an implementation detail.
- *
- * ## Fallback policy
- * The proxy falls back to direct (main-thread) delegation whenever:
- *  - The global `Worker` constructor is undefined (Node.js, older browsers).
- *  - `browserConfig.useWebWorker` is explicitly `false`.
- *  - Worker creation throws (e.g. strict CSP that blocks `blob:` URLs).
- *
- * Once a fallback has been triggered by a Worker creation error the proxy
- * sets `workerFailed = true` and remains in fallback mode for all subsequent
- * calls.
- *
- * ## IContentClassifier contract
- * The proxy forwards all identity fields (`id`, `displayName`, `description`,
- * `modelId`) and the `isLoaded` state directly from the wrapped classifier so
- * it is completely transparent to the orchestrator.
- *
- * @module agentos/extensions/packs/ml-classifiers/classifiers/WorkerClassifierProxy
- */
-import type { ClassificationResult } from '@framers/agentos';
-import type { IContentClassifier } from '../IContentClassifier';
-import type { BrowserConfig } from '../types';
-/**
- * Transparent proxy around an {@link IContentClassifier} that offloads
- * `classify()` calls to a Web Worker when the browser environment supports it.
- *
- * In all other environments (Node.js, strict CSP, explicit opt-out) the proxy
- * delegates calls directly to the wrapped classifier on the main thread.
- *
- * @implements {IContentClassifier}
- *
- * @example Browser context — Web Worker path
- * ```typescript
- * const toxicity = new ToxicityClassifier(serviceRegistry);
- * const proxy = new WorkerClassifierProxy(toxicity, { useWebWorker: true });
- * const result = await proxy.classify('some text');
- * ```
- *
- * @example Node.js / forced fallback path
- * ```typescript
- * const proxy = new WorkerClassifierProxy(toxicity, { useWebWorker: false });
- * // Delegates directly to toxicity.classify() on the same thread.
- * ```
- */
-export declare class WorkerClassifierProxy implements IContentClassifier {
-    private readonly wrapped;
-    private readonly browserConfig?;
-    /**
-     * {@inheritDoc IContentClassifier.id}
-     * Delegated from the wrapped classifier so this proxy is transparent in
-     * the orchestrator's service-ID lookups.
-     */
-    get id(): string;
-    /**
-     * {@inheritDoc IContentClassifier.displayName}
-     * Returns the wrapped classifier's display name with a `(Worker)` suffix
-     * when the Web Worker path is active, so logs clearly indicate the mode.
-     */
-    get displayName(): string;
-    /**
-     * {@inheritDoc IContentClassifier.description}
-     * Delegated directly from the wrapped classifier.
-     */
-    get description(): string;
-    /**
-     * {@inheritDoc IContentClassifier.modelId}
-     * Delegated directly from the wrapped classifier.
-     */
-    get modelId(): string;
-    /**
-     * {@inheritDoc IContentClassifier.isLoaded}
-     *
-     * Reflects the wrapped classifier's `isLoaded` state.  The wrapped
-     * instance is the authoritative source because it owns the model weights
-     * (whether they live in the Worker or on the main thread).
-     */
-    get isLoaded(): boolean;
-    /**
-     * IContentClassifier requires `isLoaded` to be settable via the interface
-     * contract (`isLoaded: boolean`).  We store the value through the wrapped
-     * classifier so the authoritative state lives in one place.
-     */
-    set isLoaded(value: boolean);
-    /**
-     * Set to `true` after a Worker creation failure.  Once set, all subsequent
-     * `classify()` calls are routed directly to the wrapped classifier without
-     * attempting to re-create the Worker.
-     */
-    private workerFailed;
-    /**
-     * Create a WorkerClassifierProxy.
-     *
-     * @param wrapped       - The real classifier to delegate to.  In Worker
-     *                        mode this classifier is still responsible for
-     *                        model loading and inference; the proxy just
-     *                        changes the thread on which it executes.
-     * @param browserConfig - Optional browser-side configuration.  Controls
-     *                        whether Worker mode is attempted
-     *                        (`useWebWorker`, default `true`).
-     */
-    constructor(wrapped: IContentClassifier, browserConfig?: BrowserConfig | undefined);
-    /**
-     * Classify the provided text, routing to a Web Worker when available.
-     *
-     * ### Routing decision (evaluated once per call)
-     * 1. `typeof Worker === 'undefined'` → fallback (Node.js / no Worker API).
-     * 2. `browserConfig.useWebWorker === false` → fallback (explicit opt-out).
-     * 3. `workerFailed === true` → fallback (previous Worker creation error).
-     * 4. Otherwise → attempt to run in a Web Worker.
-     *
-     * If the Worker is created but fails to post a result within the
-     * classification request, the error is propagated as a rejected promise
-     * (not silently swallowed) so the orchestrator can log and fall back at
-     * a higher level.
-     *
-     * @param text - The text to classify.  Must not be empty.
-     * @returns A promise that resolves with the classification result.
-     */
-    classify(text: string): Promise<ClassificationResult>;
-    /**
-     * Release resources held by the wrapped classifier.
-     *
-     * Delegates to `wrapped.dispose()` if it exists.  Idempotent.
-     */
-    dispose(): Promise<void>;
-    /**
-     * Determine whether the current environment and configuration support
-     * running inference in a Web Worker.
-     *
-     * @returns `true` when Web Worker mode should be attempted.
-     */
-    private shouldUseWebWorker;
-    /**
-     * Run `classify(text)` inside a transient Web Worker.
-     *
-     * Each call creates a new Worker, sends a single `classify` message,
-     * awaits the `result` or `error` response, then terminates the Worker.
-     *
-     * If Worker creation itself throws (e.g. CSP violation), `workerFailed`
-     * is set to `true` and the call falls back to the wrapped classifier on
-     * the main thread.
-     *
-     * @param text - The text to classify inside the Worker.
-     * @returns A promise resolving with the {@link ClassificationResult}.
-     */
-    private classifyInWorker;
-}
-//# sourceMappingURL=WorkerClassifierProxy.d.ts.map

package/dist/classifiers/WorkerClassifierProxy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"WorkerClassifierProxy.d.ts","sourceRoot":"","sources":["../../src/classifiers/WorkerClassifierProxy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAoE9C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,qBAAsB,YAAW,kBAAkB;IAsF5D,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC;IAlFjC;;;;OAIG;IACH,IAAI,EAAE,IAAI,MAAM,CAEf;IAED;;;;OAIG;IACH,IAAI,WAAW,IAAI,MAAM,CAExB;IAED;;;OAGG;IACH,IAAI,WAAW,IAAI,MAAM,CAExB;IAED;;;OAGG;IACH,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED;;;;;;OAMG;IACH,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED;;;;OAIG;IACH,IAAI,QAAQ,CAAC,KAAK,EAAE,OAAO,EAE1B;IAMD;;;;OAIG;IACH,OAAO,CAAC,YAAY,CAAS;IAM7B;;;;;;;;;;OAUG;gBAEgB,OAAO,EAAE,kBAAkB,EAC3B,aAAa,CAAC,EAAE,aAAa,YAAA;IAOhD;;;;;;;;;;;;;;;;OAgBG;IACG,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAiB3D;;;;OAIG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAU9B;;;;;OAKG;IACH,OAAO,CAAC,kBAAkB;IAmB1B;;;;;;;;;;;;OAYG;YACW,gBAAgB;CA8D/B"}

package/dist/classifiers/WorkerClassifierProxy.js

@@ -1,268 +0,0 @@
-/**
- * @fileoverview WorkerClassifierProxy — wraps an IContentClassifier to run
- * inference inside a Web Worker, with automatic main-thread fallback.
- *
- * ## Why a proxy?
- * ML inference (even quantized ONNX / WASM pipelines) can block the main
- * thread for 50–500 ms per classification.  Moving classification into a
- * Web Worker keeps the UI responsive.  This proxy makes the switch
- * transparent to callers: they still call `classify(text)` and receive a
- * `ClassificationResult`; the underlying transport (Worker vs. direct call)
- * is an implementation detail.
- *
- * ## Fallback policy
- * The proxy falls back to direct (main-thread) delegation whenever:
- *  - The global `Worker` constructor is undefined (Node.js, older browsers).
- *  - `browserConfig.useWebWorker` is explicitly `false`.
- *  - Worker creation throws (e.g. strict CSP that blocks `blob:` URLs).
- *
- * Once a fallback has been triggered by a Worker creation error the proxy
- * sets `workerFailed = true` and remains in fallback mode for all subsequent
- * calls.
- *
- * ## IContentClassifier contract
- * The proxy forwards all identity fields (`id`, `displayName`, `description`,
- * `modelId`) and the `isLoaded` state directly from the wrapped classifier so
- * it is completely transparent to the orchestrator.
- *
- * @module agentos/extensions/packs/ml-classifiers/classifiers/WorkerClassifierProxy
- */
-// ---------------------------------------------------------------------------
-// WorkerClassifierProxy
-// ---------------------------------------------------------------------------
-/**
- * Transparent proxy around an {@link IContentClassifier} that offloads
- * `classify()` calls to a Web Worker when the browser environment supports it.
- *
- * In all other environments (Node.js, strict CSP, explicit opt-out) the proxy
- * delegates calls directly to the wrapped classifier on the main thread.
- *
- * @implements {IContentClassifier}
- *
- * @example Browser context — Web Worker path
- * ```typescript
- * const toxicity = new ToxicityClassifier(serviceRegistry);
- * const proxy = new WorkerClassifierProxy(toxicity, { useWebWorker: true });
- * const result = await proxy.classify('some text');
- * ```
- *
- * @example Node.js / forced fallback path
- * ```typescript
- * const proxy = new WorkerClassifierProxy(toxicity, { useWebWorker: false });
- * // Delegates directly to toxicity.classify() on the same thread.
- * ```
- */
-export class WorkerClassifierProxy {
-    wrapped;
-    browserConfig;
-    // -------------------------------------------------------------------------
-    // IContentClassifier identity — delegated from wrapped classifier
-    // -------------------------------------------------------------------------
-    /**
-     * {@inheritDoc IContentClassifier.id}
-     * Delegated from the wrapped classifier so this proxy is transparent in
-     * the orchestrator's service-ID lookups.
-     */
-    get id() {
-        return this.wrapped.id;
-    }
-    /**
-     * {@inheritDoc IContentClassifier.displayName}
-     * Returns the wrapped classifier's display name with a `(Worker)` suffix
-     * when the Web Worker path is active, so logs clearly indicate the mode.
-     */
-    get displayName() {
-        return this.wrapped.displayName;
-    }
-    /**
-     * {@inheritDoc IContentClassifier.description}
-     * Delegated directly from the wrapped classifier.
-     */
-    get description() {
-        return this.wrapped.description;
-    }
-    /**
-     * {@inheritDoc IContentClassifier.modelId}
-     * Delegated directly from the wrapped classifier.
-     */
-    get modelId() {
-        return this.wrapped.modelId;
-    }
-    /**
-     * {@inheritDoc IContentClassifier.isLoaded}
-     *
-     * Reflects the wrapped classifier's `isLoaded` state.  The wrapped
-     * instance is the authoritative source because it owns the model weights
-     * (whether they live in the Worker or on the main thread).
-     */
-    get isLoaded() {
-        return this.wrapped.isLoaded;
-    }
-    /**
-     * IContentClassifier requires `isLoaded` to be settable via the interface
-     * contract (`isLoaded: boolean`).  We store the value through the wrapped
-     * classifier so the authoritative state lives in one place.
-     */
-    set isLoaded(value) {
-        this.wrapped.isLoaded = value;
-    }
-    // -------------------------------------------------------------------------
-    // Internal state
-    // -------------------------------------------------------------------------
-    /**
-     * Set to `true` after a Worker creation failure.  Once set, all subsequent
-     * `classify()` calls are routed directly to the wrapped classifier without
-     * attempting to re-create the Worker.
-     */
-    workerFailed = false;
-    // -------------------------------------------------------------------------
-    // Constructor
-    // -------------------------------------------------------------------------
-    /**
-     * Create a WorkerClassifierProxy.
-     *
-     * @param wrapped       - The real classifier to delegate to.  In Worker
-     *                        mode this classifier is still responsible for
-     *                        model loading and inference; the proxy just
-     *                        changes the thread on which it executes.
-     * @param browserConfig - Optional browser-side configuration.  Controls
-     *                        whether Worker mode is attempted
-     *                        (`useWebWorker`, default `true`).
-     */
-    constructor(wrapped, browserConfig) {
-        this.wrapped = wrapped;
-        this.browserConfig = browserConfig;
-    }
-    // -------------------------------------------------------------------------
-    // classify
-    // -------------------------------------------------------------------------
-    /**
-     * Classify the provided text, routing to a Web Worker when available.
-     *
-     * ### Routing decision (evaluated once per call)
-     * 1. `typeof Worker === 'undefined'` → fallback (Node.js / no Worker API).
-     * 2. `browserConfig.useWebWorker === false` → fallback (explicit opt-out).
-     * 3. `workerFailed === true` → fallback (previous Worker creation error).
-     * 4. Otherwise → attempt to run in a Web Worker.
-     *
-     * If the Worker is created but fails to post a result within the
-     * classification request, the error is propagated as a rejected promise
-     * (not silently swallowed) so the orchestrator can log and fall back at
-     * a higher level.
-     *
-     * @param text - The text to classify.  Must not be empty.
-     * @returns A promise that resolves with the classification result.
-     */
-    async classify(text) {
-        // Determine whether to use a Web Worker.
-        const shouldUseWorker = this.shouldUseWebWorker();
-        if (!shouldUseWorker) {
-            // Fallback: delegate directly to the wrapped classifier on this thread.
-            return this.wrapped.classify(text);
-        }
-        // Attempt to classify in a Worker.
-        return this.classifyInWorker(text);
-    }
-    // -------------------------------------------------------------------------
-    // dispose (optional IContentClassifier lifecycle hook)
-    // -------------------------------------------------------------------------
-    /**
-     * Release resources held by the wrapped classifier.
-     *
-     * Delegates to `wrapped.dispose()` if it exists.  Idempotent.
-     */
-    async dispose() {
-        if (this.wrapped.dispose) {
-            await this.wrapped.dispose();
-        }
-    }
-    // -------------------------------------------------------------------------
-    // Private helpers
-    // -------------------------------------------------------------------------
-    /**
-     * Determine whether the current environment and configuration support
-     * running inference in a Web Worker.
-     *
-     * @returns `true` when Web Worker mode should be attempted.
-     */
-    shouldUseWebWorker() {
-        // Worker API is not available (Node.js, JSDOM without worker support, etc.)
-        if (typeof Worker === 'undefined') {
-            return false;
-        }
-        // Caller explicitly opted out of Web Worker mode.
-        if (this.browserConfig?.useWebWorker === false) {
-            return false;
-        }
-        // A previous Worker creation attempt failed — stay on main thread.
-        if (this.workerFailed) {
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Run `classify(text)` inside a transient Web Worker.
-     *
-     * Each call creates a new Worker, sends a single `classify` message,
-     * awaits the `result` or `error` response, then terminates the Worker.
-     *
-     * If Worker creation itself throws (e.g. CSP violation), `workerFailed`
-     * is set to `true` and the call falls back to the wrapped classifier on
-     * the main thread.
-     *
-     * @param text - The text to classify inside the Worker.
-     * @returns A promise resolving with the {@link ClassificationResult}.
-     */
-    async classifyInWorker(text) {
-        let worker;
-        try {
-            // Resolve the Worker script URL.  We use the sibling classifier-worker
-            // module.  In a bundled environment this will be a blob URL or a
-            // `new URL(...)` import; here we use a relative path that bundlers
-            // understand via the standard Worker constructor pattern.
-            worker = new Worker(new URL('../worker/classifier-worker.ts', import.meta.url), {
-                type: 'module',
-            });
-        }
-        catch (err) {
-            // Worker could not be created (CSP, missing support, etc.).
-            // Mark as failed and fall back to the main thread.
-            this.workerFailed = true;
-            console.warn(`[WorkerClassifierProxy] Worker creation failed for "${this.wrapped.id}"; ` +
-                `falling back to main-thread classification. Reason: ${err}`);
-            return this.wrapped.classify(text);
-        }
-        // Build the request message.
-        const request = {
-            type: 'classify',
-            text,
-            modelId: this.wrapped.modelId,
-            // Default to non-quantized; the wrapped classifier's config owns this,
-            // but the Worker needs it to load the right model variant.
-            quantized: false,
-            taskType: 'text-classification',
-        };
-        return new Promise((resolve, reject) => {
-            // Handle the single response message from the Worker.
-            worker.onmessage = (event) => {
-                const message = event.data;
-                if (message.type === 'result') {
-                    resolve(message.result);
-                }
-                else {
-                    reject(new Error(`Worker classification error: ${message.error}`));
-                }
-                // Terminate the Worker after receiving its response to free resources.
-                worker.terminate();
-            };
-            // Handle any uncaught errors thrown inside the Worker.
-            worker.onerror = (errorEvent) => {
-                reject(new Error(`Worker runtime error in "${this.wrapped.id}": ${errorEvent.message}`));
-                worker.terminate();
-            };
-            // Send the classify request to the Worker.
-            worker.postMessage(request);
-        });
-    }
-}
-//# sourceMappingURL=WorkerClassifierProxy.js.map

package/dist/classifiers/WorkerClassifierProxy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"WorkerClassifierProxy.js","sourceRoot":"","sources":["../../src/classifiers/WorkerClassifierProxy.ts"],"names":[],"mappings":"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"}

package/dist/worker/classifier-worker.d.ts

@@ -1,49 +0,0 @@
-/**
- * @fileoverview Web Worker entry point for ML content classification.
- *
- * This script is loaded by {@link WorkerClassifierProxy} as a dedicated Web
- * Worker.  It listens for `classify` messages from the main thread, lazily
- * loads the requested model pipeline via `@huggingface/transformers`, runs
- * inference, then posts the result (or an error) back.
- *
- * ## Message protocol
- *
- * **Incoming** (main thread → worker):
- * ```json
- * {
- *   "type": "classify",
- *   "text":      "<string>",
- *   "modelId":   "<HuggingFace model ID or local path>",
- *   "quantized": true | false,
- *   "taskType":  "<transformers.js task string>"
- * }
- * ```
- *
- * **Outgoing** (worker → main thread) on success:
- * ```json
- * { "type": "result", "result": { "bestClass": "...", "confidence": 0.92, "allScores": [...] } }
- * ```
- *
- * **Outgoing** (worker → main thread) on error:
- * ```json
- * { "type": "error", "error": "<error message>" }
- * ```
- *
- * ## Pipeline caching
- * The pipeline is loaded once per `(modelId, taskType)` key and cached in
- * a module-level `Map`.  Subsequent `classify` messages for the same model
- * reuse the cached instance, avoiding repeated expensive model downloads and
- * WASM initialisation.
- *
- * ## Raw label normalisation
- * The worker normalises the raw `@huggingface/transformers` output (an array
- * of `{ label, score }` objects when called with `topk: null`) into the
- * AgentOS {@link ClassificationResult} shape:
- *  - `bestClass`  — label with the highest score
- *  - `confidence` — score of the winning label
- *  - `allScores`  — all labels mapped to `{ classLabel, score }` pairs
- *
- * @module agentos/extensions/packs/ml-classifiers/worker/classifier-worker
- */
-export {};
-//# sourceMappingURL=classifier-worker.d.ts.map

package/dist/worker/classifier-worker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"classifier-worker.d.ts","sourceRoot":"","sources":["../../src/worker/classifier-worker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG"}

package/dist/worker/classifier-worker.js

@@ -1,180 +0,0 @@
-/**
- * @fileoverview Web Worker entry point for ML content classification.
- *
- * This script is loaded by {@link WorkerClassifierProxy} as a dedicated Web
- * Worker.  It listens for `classify` messages from the main thread, lazily
- * loads the requested model pipeline via `@huggingface/transformers`, runs
- * inference, then posts the result (or an error) back.
- *
- * ## Message protocol
- *
- * **Incoming** (main thread → worker):
- * ```json
- * {
- *   "type": "classify",
- *   "text":      "<string>",
- *   "modelId":   "<HuggingFace model ID or local path>",
- *   "quantized": true | false,
- *   "taskType":  "<transformers.js task string>"
- * }
- * ```
- *
- * **Outgoing** (worker → main thread) on success:
- * ```json
- * { "type": "result", "result": { "bestClass": "...", "confidence": 0.92, "allScores": [...] } }
- * ```
- *
- * **Outgoing** (worker → main thread) on error:
- * ```json
- * { "type": "error", "error": "<error message>" }
- * ```
- *
- * ## Pipeline caching
- * The pipeline is loaded once per `(modelId, taskType)` key and cached in
- * a module-level `Map`.  Subsequent `classify` messages for the same model
- * reuse the cached instance, avoiding repeated expensive model downloads and
- * WASM initialisation.
- *
- * ## Raw label normalisation
- * The worker normalises the raw `@huggingface/transformers` output (an array
- * of `{ label, score }` objects when called with `topk: null`) into the
- * AgentOS {@link ClassificationResult} shape:
- *  - `bestClass`  — label with the highest score
- *  - `confidence` — score of the winning label
- *  - `allScores`  — all labels mapped to `{ classLabel, score }` pairs
- *
- * @module agentos/extensions/packs/ml-classifiers/worker/classifier-worker
- */
-// ---------------------------------------------------------------------------
-// Pipeline cache
-// ---------------------------------------------------------------------------
-/**
- * Cache key composed of `modelId` and `taskType` so different task types
- * for the same model ID are kept separate.
- *
- * @param modelId  - Hugging Face model ID or local path.
- * @param taskType - transformers.js task string.
- * @returns Cache key string.
- */
-function cacheKey(modelId, taskType) {
-    return `${taskType}::${modelId}`;
-}
-/**
- * Module-level pipeline cache.
- *
- * Maps cache keys (see {@link cacheKey}) to loaded pipeline functions.
- * Populated lazily on the first `classify` message for each unique
- * `(modelId, taskType)` combination.
- */
-const pipelineCache = new Map();
-// ---------------------------------------------------------------------------
-// Classification logic
-// ---------------------------------------------------------------------------
-/**
- * Load (or retrieve from cache) the text-classification pipeline for the
- * given model and run inference on `text`.
- *
- * @param request - The incoming classify request.
- * @returns A promise resolving with the raw label array from the pipeline.
- * @throws If the pipeline fails to load or inference throws.
- */
-async function runPipeline(request) {
-    const key = cacheKey(request.modelId, request.taskType);
-    // Check the cache first to avoid re-loading on every message.
-    let pipe = pipelineCache.get(key);
-    if (!pipe) {
-        // Lazy-load the @huggingface/transformers package.
-        // Dynamic import is used so this module can be evaluated in environments
-        // where the package is optional (the Worker is only instantiated when
-        // browser runtime is active and the package is present).
-        const { pipeline: createPipeline } = await import('@huggingface/transformers');
-        // Create the pipeline with quantisation option from the request.
-        const newPipe = await createPipeline(request.taskType, request.modelId, {
-            quantized: request.quantized,
-        });
-        // Store in cache and narrow the type.
-        pipe = newPipe;
-        pipelineCache.set(key, pipe);
-    }
-    // Run inference — request all label scores (topk: null).
-    return pipe(request.text, { topk: null });
-}
-/**
- * Normalise raw pipeline output into an AgentOS {@link ClassificationResult}.
- *
- * @param raw - Array of `{ label, score }` objects from the pipeline.
- * @returns A fully-populated `ClassificationResult`.
- */
-function normaliseResult(raw) {
-    if (!raw || raw.length === 0) {
-        // No output — return a benign pass result so the orchestrator treats this
-        // as ALLOW rather than an error.
-        return { bestClass: 'benign', confidence: 0, allScores: [] };
-    }
-    // Find the label with the highest confidence score.
-    let best = raw[0];
-    for (const item of raw) {
-        if (item.score > best.score) {
-            best = item;
-        }
-    }
-    // Map every label to the AgentOS ClassificationScore shape.
-    const allScores = raw.map((item) => ({
-        classLabel: item.label,
-        score: item.score,
-    }));
-    return {
-        bestClass: best.label,
-        confidence: best.score,
-        allScores,
-    };
-}
-// ---------------------------------------------------------------------------
-// Message handler
-// ---------------------------------------------------------------------------
-/**
- * Handle a `classify` message from the main thread.
- *
- * Runs the pipeline and posts either a {@link ResultMessage} or an
- * {@link ErrorMessage} back to the main thread.
- *
- * @param request - The incoming classify request.
- */
-async function handleClassify(request) {
-    try {
-        const raw = await runPipeline(request);
-        const result = normaliseResult(raw);
-        const response = { type: 'result', result };
-        self.postMessage(response);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        const response = { type: 'error', error: message };
-        self.postMessage(response);
-    }
-}
-// ---------------------------------------------------------------------------
-// Worker bootstrap — listen for messages from the main thread
-// ---------------------------------------------------------------------------
-/**
- * The primary message listener for this Worker.
- *
- * Dispatches incoming messages to {@link handleClassify} when the message
- * type is `'classify'`.  All other message types are ignored with a warning
- * logged to the Worker console (useful for debugging unexpected messages
- * during development).
- */
-self.onmessage = (event) => {
-    const data = event.data;
-    if (data?.type === 'classify') {
-        // Kick off async classification.  Errors are caught inside handleClassify
-        // and posted back as ErrorMessage, so we do not need a top-level catch here.
-        void handleClassify(data);
-    }
-    else {
-        // Unknown message type — log and ignore.
-        console.warn('[classifier-worker] Received unexpected message type:', data?.type ?? data);
-    }
-};
-export {};
-//# sourceMappingURL=classifier-worker.js.map

package/dist/worker/classifier-worker.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"classifier-worker.js","sourceRoot":"","sources":["../../src/worker/classifier-worker.ts"],"names":[],"mappings":"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"}