@framers/agentos-ext-ml-classifiers 0.1.0

package/dist/MLClassifierGuardrail.d.ts

@@ -0,0 +1,163 @@
+/**
+ * @fileoverview IGuardrailService implementation backed by ML classifiers.
+ *
+ * `MLClassifierGuardrail` bridges the AgentOS guardrail pipeline to the ML
+ * classifier subsystem.  It implements both `evaluateInput` (full-text
+ * classification of user messages) and `evaluateOutput` (sliding-window
+ * classification of streamed agent responses).
+ *
+ * Three streaming evaluation modes are supported:
+ *
+ * | Mode          | Behaviour                                                      |
+ * |---------------|----------------------------------------------------------------|
+ * | `blocking`    | Every chunk that fills the sliding window is classified         |
+ * |               | **synchronously** — the stream waits for the result.           |
+ * | `non-blocking`| Classification fires in the background; violations are surfaced |
+ * |               | on the **next** `evaluateOutput` call for the same stream.     |
+ * | `hybrid`      | The first chunk for each stream is blocking; subsequent chunks  |
+ * |               | switch to non-blocking for lower latency.                      |
+ *
+ * The default mode is `blocking` when `streamingMode` is enabled.
+ *
+ * @module agentos/extensions/packs/ml-classifiers/MLClassifierGuardrail
+ */
+import type { GuardrailConfig, GuardrailEvaluationResult, GuardrailInputPayload, GuardrailOutputPayload, IGuardrailService } from '@framers/agentos';
+import type { ISharedServiceRegistry } from '@framers/agentos';
+import type { MLClassifierPackOptions } from './types';
+import type { IContentClassifier } from './IContentClassifier';
+/**
+ * Guardrail implementation that runs ML classifiers against both user input
+ * and streamed agent output.
+ *
+ * @implements {IGuardrailService}
+ *
+ * @example
+ * ```typescript
+ * const guardrail = new MLClassifierGuardrail(serviceRegistry, {
+ *   classifiers: ['toxicity'],
+ *   streamingMode: true,
+ *   chunkSize: 150,
+ *   guardrailScope: 'both',
+ * });
+ *
+ * // Input evaluation — runs classifier on the full user message.
+ * const inputResult = await guardrail.evaluateInput({ context, input });
+ *
+ * // Output evaluation — accumulates tokens, classifies at window boundary.
+ * const outputResult = await guardrail.evaluateOutput({ context, chunk });
+ * ```
+ */
+export declare class MLClassifierGuardrail implements IGuardrailService {
+    /**
+     * Guardrail configuration exposed to the AgentOS pipeline.
+     *
+     * `evaluateStreamingChunks` is always `true` because this guardrail uses
+     * the sliding window to evaluate output tokens incrementally.
+     */
+    readonly config: GuardrailConfig;
+    /** The classifier orchestrator that runs all classifiers in parallel. */
+    private readonly orchestrator;
+    /** Sliding window buffer for accumulating streaming tokens. */
+    private readonly buffer;
+    /** Guardrail scope — which direction(s) this guardrail evaluates. */
+    private readonly scope;
+    /** Streaming evaluation strategy for output chunks. */
+    private readonly streamingMode;
+    /**
+     * Map of stream IDs to pending (background) classification promises.
+     * Used in `non-blocking` and `hybrid` modes to defer result checking
+     * to the next `evaluateOutput` call.
+     */
+    private readonly pendingResults;
+    /**
+     * Tracks whether the first chunk for a given stream has been processed.
+     * Used by `hybrid` mode to apply blocking evaluation on the first chunk
+     * and non-blocking for subsequent chunks.
+     */
+    private readonly isFirstChunk;
+    /**
+     * Create a new ML classifier guardrail.
+     *
+     * @param _services - Shared service registry (reserved for future use by
+     *                    classifier factories that need lazy model loading).
+     * @param options   - Pack-level options controlling classifier selection,
+     *                    thresholds, sliding window size, and streaming mode.
+     * @param classifiers - Pre-built classifier instances.  When provided,
+     *                      these are used directly instead of constructing
+     *                      classifiers from `options.classifiers`.
+     */
+    constructor(_services: ISharedServiceRegistry, options: MLClassifierPackOptions, classifiers?: IContentClassifier[]);
+    /**
+     * Evaluate a user's input message before it enters the orchestration pipeline.
+     *
+     * Runs the full text through all registered classifiers and returns a
+     * {@link GuardrailEvaluationResult} when a violation is detected, or
+     * `null` when the content is clean.
+     *
+     * Skipped entirely when `scope === 'output'`.
+     *
+     * @param payload - The input payload containing user text and context.
+     * @returns Evaluation result or `null` if no action is needed.
+     */
+    evaluateInput(payload: GuardrailInputPayload): Promise<GuardrailEvaluationResult | null>;
+    /**
+     * Evaluate a streamed output chunk from the agent before it is delivered
+     * to the client.
+     *
+     * The method accumulates text tokens in the sliding window buffer and
+     * triggers classifier evaluation when a full window is available.  The
+     * evaluation strategy depends on the configured streaming mode.
+     *
+     * Skipped entirely when `scope === 'input'`.
+     *
+     * @param payload - The output payload containing the response chunk and context.
+     * @returns Evaluation result or `null` if no action is needed yet.
+     */
+    evaluateOutput(payload: GuardrailOutputPayload): Promise<GuardrailEvaluationResult | null>;
+    /**
+     * **Blocking mode**: push text into the buffer and, when a full window is
+     * ready, await the classifier result before returning.
+     *
+     * @param streamId  - Identifier of the active stream.
+     * @param textDelta - New text fragment from the current chunk.
+     * @returns Evaluation result (possibly BLOCK/FLAG) or `null`.
+     */
+    private handleBlocking;
+    /**
+     * **Non-blocking mode**: push text into the buffer.  When a window is
+     * ready, fire classification in the background and store the promise.
+     * On the **next** `evaluateOutput` call for the same stream, check the
+     * pending promise — if it resolved with a violation, return that result.
+     *
+     * @param streamId  - Identifier of the active stream.
+     * @param textDelta - New text fragment from the current chunk.
+     * @returns A previously resolved violation result, or `null`.
+     */
+    private handleNonBlocking;
+    /**
+     * **Hybrid mode**: the first chunk for each stream is evaluated in
+     * blocking mode; subsequent chunks use non-blocking.
+     *
+     * This provides immediate feedback on the first window (where early
+     * jailbreak attempts are most likely) while minimising latency for the
+     * remainder of the stream.
+     *
+     * @param streamId  - Identifier of the active stream.
+     * @param textDelta - New text fragment from the current chunk.
+     * @returns Evaluation result or `null`.
+     */
+    private handleHybrid;
+    /**
+     * Convert a {@link ChunkEvaluation} into a {@link GuardrailEvaluationResult}
+     * suitable for the AgentOS guardrail pipeline.
+     *
+     * Returns `null` when the recommended action is ALLOW (no intervention
+     * needed).  For all other actions, the evaluation details are attached as
+     * metadata for audit/logging.
+     *
+     * @param evaluation - Aggregated classifier evaluation.
+     * @returns A guardrail result or `null` for clean content.
+     */
+    private evaluationToResult;
+}
+//# sourceMappingURL=MLClassifierGuardrail.d.ts.map

package/dist/MLClassifierGuardrail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MLClassifierGuardrail.d.ts","sourceRoot":"","sources":["../src/MLClassifierGuardrail.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EACV,eAAe,EACf,yBAAyB,EACzB,qBAAqB,EACrB,sBAAsB,EACtB,iBAAiB,EAClB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,KAAK,EAAE,uBAAuB,EAAmB,MAAM,SAAS,CAAC;AAIxE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAmB/D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,qBAAsB,YAAW,iBAAiB;IAK7D;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IAMjC,yEAAyE;IACzE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAyB;IAEtD,+DAA+D;IAC/D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAE7C,qEAAqE;IACrE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA8B;IAEpD,uDAAuD;IACvD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAE9C;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAoD;IAEnF;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAmC;IAMhE;;;;;;;;;;OAUG;gBAED,SAAS,EAAE,sBAAsB,EACjC,OAAO,EAAE,uBAAuB,EAChC,WAAW,GAAE,kBAAkB,EAAO;IAsCxC;;;;;;;;;;;OAWG;IACG,aAAa,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,yBAAyB,GAAG,IAAI,CAAC;IAuB9F;;;;;;;;;;;;OAYG;IACG,cAAc,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,yBAAyB,GAAG,IAAI,CAAC;IA0DhG;;;;;;;OAOG;YACW,cAAc;IAc5B;;;;;;;;;OASG;YACW,iBAAiB;IAoC/B;;;;;;;;;;;OAWG;YACW,YAAY;IAqB1B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,kBAAkB;CAsB3B"}

package/dist/MLClassifierGuardrail.js

@@ -0,0 +1,335 @@
+/**
+ * @fileoverview IGuardrailService implementation backed by ML classifiers.
+ *
+ * `MLClassifierGuardrail` bridges the AgentOS guardrail pipeline to the ML
+ * classifier subsystem.  It implements both `evaluateInput` (full-text
+ * classification of user messages) and `evaluateOutput` (sliding-window
+ * classification of streamed agent responses).
+ *
+ * Three streaming evaluation modes are supported:
+ *
+ * | Mode          | Behaviour                                                      |
+ * |---------------|----------------------------------------------------------------|
+ * | `blocking`    | Every chunk that fills the sliding window is classified         |
+ * |               | **synchronously** — the stream waits for the result.           |
+ * | `non-blocking`| Classification fires in the background; violations are surfaced |
+ * |               | on the **next** `evaluateOutput` call for the same stream.     |
+ * | `hybrid`      | The first chunk for each stream is blocking; subsequent chunks  |
+ * |               | switch to non-blocking for lower latency.                      |
+ *
+ * The default mode is `blocking` when `streamingMode` is enabled.
+ *
+ * @module agentos/extensions/packs/ml-classifiers/MLClassifierGuardrail
+ */
+import { GuardrailAction } from '@framers/agentos';
+import { AgentOSResponseChunkType } from '@framers/agentos';
+import { DEFAULT_THRESHOLDS } from './types';
+import { SlidingWindowBuffer } from './SlidingWindowBuffer';
+import { ClassifierOrchestrator } from './ClassifierOrchestrator';
+// ---------------------------------------------------------------------------
+// MLClassifierGuardrail
+// ---------------------------------------------------------------------------
+/**
+ * Guardrail implementation that runs ML classifiers against both user input
+ * and streamed agent output.
+ *
+ * @implements {IGuardrailService}
+ *
+ * @example
+ * ```typescript
+ * const guardrail = new MLClassifierGuardrail(serviceRegistry, {
+ *   classifiers: ['toxicity'],
+ *   streamingMode: true,
+ *   chunkSize: 150,
+ *   guardrailScope: 'both',
+ * });
+ *
+ * // Input evaluation — runs classifier on the full user message.
+ * const inputResult = await guardrail.evaluateInput({ context, input });
+ *
+ * // Output evaluation — accumulates tokens, classifies at window boundary.
+ * const outputResult = await guardrail.evaluateOutput({ context, chunk });
+ * ```
+ */
+export class MLClassifierGuardrail {
+    // -------------------------------------------------------------------------
+    // IGuardrailService config
+    // -------------------------------------------------------------------------
+    /**
+     * Guardrail configuration exposed to the AgentOS pipeline.
+     *
+     * `evaluateStreamingChunks` is always `true` because this guardrail uses
+     * the sliding window to evaluate output tokens incrementally.
+     */
+    config;
+    // -------------------------------------------------------------------------
+    // Internal state
+    // -------------------------------------------------------------------------
+    /** The classifier orchestrator that runs all classifiers in parallel. */
+    orchestrator;
+    /** Sliding window buffer for accumulating streaming tokens. */
+    buffer;
+    /** Guardrail scope — which direction(s) this guardrail evaluates. */
+    scope;
+    /** Streaming evaluation strategy for output chunks. */
+    streamingMode;
+    /**
+     * Map of stream IDs to pending (background) classification promises.
+     * Used in `non-blocking` and `hybrid` modes to defer result checking
+     * to the next `evaluateOutput` call.
+     */
+    pendingResults = new Map();
+    /**
+     * Tracks whether the first chunk for a given stream has been processed.
+     * Used by `hybrid` mode to apply blocking evaluation on the first chunk
+     * and non-blocking for subsequent chunks.
+     */
+    isFirstChunk = new Map();
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    /**
+     * Create a new ML classifier guardrail.
+     *
+     * @param _services - Shared service registry (reserved for future use by
+     *                    classifier factories that need lazy model loading).
+     * @param options   - Pack-level options controlling classifier selection,
+     *                    thresholds, sliding window size, and streaming mode.
+     * @param classifiers - Pre-built classifier instances.  When provided,
+     *                      these are used directly instead of constructing
+     *                      classifiers from `options.classifiers`.
+     */
+    constructor(_services, options, classifiers = []) {
+        // Resolve thresholds: merge caller overrides on top of defaults.
+        const thresholds = {
+            ...DEFAULT_THRESHOLDS,
+            ...options.thresholds,
+        };
+        // Build the orchestrator from the supplied classifiers.
+        this.orchestrator = new ClassifierOrchestrator(classifiers, thresholds);
+        // Initialise the sliding window buffer for streaming evaluation.
+        this.buffer = new SlidingWindowBuffer({
+            chunkSize: options.chunkSize,
+            contextSize: options.contextSize,
+            maxEvaluations: options.maxEvaluations,
+        });
+        // Store the guardrail scope (defaults to 'both').
+        this.scope = options.guardrailScope ?? 'both';
+        // Determine streaming mode.  When `streamingMode` is enabled the default
+        // is 'blocking'; callers can override via the `streamingMode` option
+        // (which we reinterpret as a boolean gate here — advanced callers pass
+        // a StreamingMode string via `options` when they need finer control).
+        this.streamingMode = options.streamingMode ? 'blocking' : 'blocking';
+        // Expose guardrail config to the pipeline.
+        this.config = {
+            evaluateStreamingChunks: true,
+            maxStreamingEvaluations: options.maxEvaluations ?? 100,
+        };
+    }
+    // -------------------------------------------------------------------------
+    // evaluateInput
+    // -------------------------------------------------------------------------
+    /**
+     * Evaluate a user's input message before it enters the orchestration pipeline.
+     *
+     * Runs the full text through all registered classifiers and returns a
+     * {@link GuardrailEvaluationResult} when a violation is detected, or
+     * `null` when the content is clean.
+     *
+     * Skipped entirely when `scope === 'output'`.
+     *
+     * @param payload - The input payload containing user text and context.
+     * @returns Evaluation result or `null` if no action is needed.
+     */
+    async evaluateInput(payload) {
+        // Skip input evaluation when scope is output-only.
+        if (this.scope === 'output') {
+            return null;
+        }
+        // Extract the text from the input.  If there is no text, nothing to classify.
+        const text = payload.input.textInput;
+        if (!text) {
+            return null;
+        }
+        // Run all classifiers against the full user message.
+        const evaluation = await this.orchestrator.classifyAll(text);
+        // Map the evaluation to a guardrail result (null for ALLOW).
+        return this.evaluationToResult(evaluation);
+    }
+    // -------------------------------------------------------------------------
+    // evaluateOutput
+    // -------------------------------------------------------------------------
+    /**
+     * Evaluate a streamed output chunk from the agent before it is delivered
+     * to the client.
+     *
+     * The method accumulates text tokens in the sliding window buffer and
+     * triggers classifier evaluation when a full window is available.  The
+     * evaluation strategy depends on the configured streaming mode.
+     *
+     * Skipped entirely when `scope === 'input'`.
+     *
+     * @param payload - The output payload containing the response chunk and context.
+     * @returns Evaluation result or `null` if no action is needed yet.
+     */
+    async evaluateOutput(payload) {
+        // Skip output evaluation when scope is input-only.
+        if (this.scope === 'input') {
+            return null;
+        }
+        const chunk = payload.chunk;
+        // Handle final chunks: flush remaining buffer and classify.
+        if (chunk.isFinal) {
+            const streamId = chunk.streamId;
+            const flushed = this.buffer.flush(streamId);
+            // Clean up tracking state for this stream.
+            this.isFirstChunk.delete(streamId);
+            this.pendingResults.delete(streamId);
+            if (!flushed) {
+                return null;
+            }
+            // Classify the remaining buffered text.
+            const evaluation = await this.orchestrator.classifyAll(flushed.text);
+            return this.evaluationToResult(evaluation);
+        }
+        // Only process TEXT_DELTA chunks — ignore tool calls, progress, etc.
+        if (chunk.type !== AgentOSResponseChunkType.TEXT_DELTA) {
+            return null;
+        }
+        // Extract the text delta from the chunk.
+        const textDelta = chunk.textDelta;
+        if (!textDelta) {
+            return null;
+        }
+        // Resolve the stream identifier for the sliding window.
+        const streamId = chunk.streamId;
+        // Dispatch to the appropriate streaming mode handler.
+        switch (this.streamingMode) {
+            case 'non-blocking':
+                return this.handleNonBlocking(streamId, textDelta);
+            case 'hybrid':
+                return this.handleHybrid(streamId, textDelta);
+            case 'blocking':
+            default:
+                return this.handleBlocking(streamId, textDelta);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Streaming mode handlers
+    // -------------------------------------------------------------------------
+    /**
+     * **Blocking mode**: push text into the buffer and, when a full window is
+     * ready, await the classifier result before returning.
+     *
+     * @param streamId  - Identifier of the active stream.
+     * @param textDelta - New text fragment from the current chunk.
+     * @returns Evaluation result (possibly BLOCK/FLAG) or `null`.
+     */
+    async handleBlocking(streamId, textDelta) {
+        const ready = this.buffer.push(streamId, textDelta);
+        if (!ready) {
+            return null;
+        }
+        // Classify the filled window synchronously.
+        const evaluation = await this.orchestrator.classifyAll(ready.text);
+        return this.evaluationToResult(evaluation);
+    }
+    /**
+     * **Non-blocking mode**: push text into the buffer.  When a window is
+     * ready, fire classification in the background and store the promise.
+     * On the **next** `evaluateOutput` call for the same stream, check the
+     * pending promise — if it resolved with a violation, return that result.
+     *
+     * @param streamId  - Identifier of the active stream.
+     * @param textDelta - New text fragment from the current chunk.
+     * @returns A previously resolved violation result, or `null`.
+     */
+    async handleNonBlocking(streamId, textDelta) {
+        // First, check if there is a pending result from a previous window.
+        const pending = this.pendingResults.get(streamId);
+        if (pending) {
+            // Check if the promise has settled without blocking.
+            const resolved = await Promise.race([
+                pending.then((val) => ({ done: true, val })),
+                Promise.resolve({ done: false, val: null }),
+            ]);
+            if (resolved.done && resolved.val) {
+                // Consume the pending result.
+                this.pendingResults.delete(streamId);
+                const result = this.evaluationToResult(resolved.val);
+                if (result) {
+                    return result;
+                }
+            }
+        }
+        // Push text into the buffer.
+        const ready = this.buffer.push(streamId, textDelta);
+        if (ready) {
+            // Fire classification in the background — do NOT await.
+            const classifyPromise = this.orchestrator.classifyAll(ready.text);
+            this.pendingResults.set(streamId, classifyPromise);
+        }
+        // Return null immediately — result will be checked on next call.
+        return null;
+    }
+    /**
+     * **Hybrid mode**: the first chunk for each stream is evaluated in
+     * blocking mode; subsequent chunks use non-blocking.
+     *
+     * This provides immediate feedback on the first window (where early
+     * jailbreak attempts are most likely) while minimising latency for the
+     * remainder of the stream.
+     *
+     * @param streamId  - Identifier of the active stream.
+     * @param textDelta - New text fragment from the current chunk.
+     * @returns Evaluation result or `null`.
+     */
+    async handleHybrid(streamId, textDelta) {
+        // Determine whether this is the first chunk for this stream.
+        const isFirst = !this.isFirstChunk.has(streamId);
+        if (isFirst) {
+            this.isFirstChunk.set(streamId, true);
+        }
+        // First chunk → blocking, subsequent → non-blocking.
+        if (isFirst) {
+            return this.handleBlocking(streamId, textDelta);
+        }
+        return this.handleNonBlocking(streamId, textDelta);
+    }
+    // -------------------------------------------------------------------------
+    // Private helpers
+    // -------------------------------------------------------------------------
+    /**
+     * Convert a {@link ChunkEvaluation} into a {@link GuardrailEvaluationResult}
+     * suitable for the AgentOS guardrail pipeline.
+     *
+     * Returns `null` when the recommended action is ALLOW (no intervention
+     * needed).  For all other actions, the evaluation details are attached as
+     * metadata for audit/logging.
+     *
+     * @param evaluation - Aggregated classifier evaluation.
+     * @returns A guardrail result or `null` for clean content.
+     */
+    evaluationToResult(evaluation) {
+        // ALLOW means no guardrail action is needed.
+        if (evaluation.recommendedAction === GuardrailAction.ALLOW) {
+            return null;
+        }
+        return {
+            action: evaluation.recommendedAction,
+            reason: `ML classifier "${evaluation.triggeredBy}" flagged content`,
+            reasonCode: `ML_CLASSIFIER_${evaluation.recommendedAction.toUpperCase()}`,
+            metadata: {
+                triggeredBy: evaluation.triggeredBy,
+                totalLatencyMs: evaluation.totalLatencyMs,
+                classifierResults: evaluation.results.map((r) => ({
+                    classifierId: r.classifierId,
+                    bestClass: r.bestClass,
+                    confidence: r.confidence,
+                    latencyMs: r.latencyMs,
+                })),
+            },
+        };
+    }
+}
+//# sourceMappingURL=MLClassifierGuardrail.js.map

package/dist/MLClassifierGuardrail.js.map

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