@provos/ironcurtain 0.9.0 → 0.10.0

package/dist/pipeline/pipeline-runner.d.ts

@@ -10,9 +10,9 @@
  * cycle, then results are merged. This enables incremental recompilation and
  * better per-server rule quality.
  */
+import type { LanguageModelV3 } from '@ai-sdk/provider';
 import type { LanguageModel } from 'ai';
 import type { MCPServerConfig } from '../config/types.js';
-import type { LlmLogContext } from './llm-logger.js';
 import type { PromptCacheStrategy } from '../session/prompt-cache.js';
 import type { CompiledPolicyFile, CompiledRule, DynamicListsFile, ListDefinition, StoredToolAnnotationsFile, TestScenario, ToolAnnotation } from './types.js';
 /**
@@ -57,16 +57,28 @@ export interface PipelineRunConfig {
     readonly preloadedStoredAnnotations?: StoredToolAnnotationsFile;
     /** Compile only these servers (default: all servers in annotations). */
     readonly serverFilter?: string[];
+    /**
+     * Text for the pre-filter to evaluate server relevance against.
+     * Caller provides the appropriate text for the compilation mode:
+     * - Constitution mode: user constitution only (without base principles)
+     * - Task-policy mode: task description
+     * - Persona mode: persona constitution
+     *
+     * When undefined, the pre-filter is skipped.
+     */
+    readonly prefilterText?: string;
 }
 /**
  * LLM model references shared across pipeline runs.
  * Thin wrapper around PipelineLlm with a renamed field for clarity.
  */
 export interface PipelineModels {
-    readonly compilationModel: LanguageModel;
+    /** The unwrapped base model for creating per-server wrapped models. */
+    readonly baseLlm: LanguageModelV3;
     readonly cacheStrategy: PromptCacheStrategy;
-    readonly logContext: LlmLogContext;
     readonly logPath: string;
+    /** Cheap model for pre-filter classification (Haiku). */
+    readonly prefilterModel: LanguageModel;
 }
 /** Creates PipelineModels from user config. Delegates to shared createPipelineLlm. */
 export declare function createPipelineModels(logDir?: string): Promise<PipelineModels>;
@@ -108,7 +120,10 @@ export declare function deduplicateListDefinitions(defs: ListDefinition[]): List
  * Rules are concatenated in alphabetical server order for determinism.
  * List definitions are deduplicated by name.
  */
-export declare function mergeServerResults(results: ServerCompilationResult[], constitutionHash: string): CompiledPolicyFile;
+export declare function mergeServerResults(results: ServerCompilationResult[], constitutionHash: string, skippedServers?: Array<{
+    serverName: string;
+    reason: string;
+}>): CompiledPolicyFile;
 /**
  * Encapsulates the full policy compilation pipeline:
  * compile rules -> generate scenarios -> verify -> repair loop.
@@ -118,9 +133,10 @@ export declare function mergeServerResults(results: ServerCompilationResult[], c
  * (broad principles) and 'task-policy' (strict whitelist) modes.
  */
 export declare class PipelineRunner {
-    private readonly model;
+    private readonly baseLlm;
     private readonly cacheStrategy;
-    private readonly logContext;
+    private readonly logPath;
+    private readonly prefilterModel;
     constructor(models: PipelineModels);
     /**
      * Runs the full pipeline. Returns the compiled policy on success.
@@ -141,15 +157,40 @@ export declare class PipelineRunner {
      */
     private runPerServer;
     /**
-     * Compiles rules for all servers sequentially.
-     * Respects serverFilter if provided (for debugging single servers).
+     * Compiles rules for all servers, in parallel when multiple servers are present.
+     * Single-server compilation uses sequential spinner-based output.
+     * Multi-server compilation uses parallel execution with a multi-line progress display.
      */
     private compileAllServers;
+    /** Creates a per-server model wrapped with LLM call throttling. */
+    private createServerModel;
+    private compileServersSequential;
+    private compileServersParallel;
+    private handleCompilationResults;
     /**
      * Compiles a single server: compile -> generate scenarios -> verify -> repair.
      * Self-contained compile-verify-repair loop per server.
+     *
+     * Each server receives its own model (with per-server logging middleware),
+     * logContext (for step labeling), and reporter (for progress/warnings).
+     * This makes the method safe for concurrent execution.
      */
     private compileServer;
+    /**
+     * Runs initial verification and the compile-verify-repair loop for a server.
+     * Returns the mutable compilation state after all repair attempts.
+     */
+    private verifyAndRepairServer;
+    /**
+     * Filters structurally conflicting scenarios and generates replacements
+     * for discarded ones via LLM repair (pre-loop, one-time).
+     */
+    private filterAndRepairDiscardedScenarios;
+    /**
+     * Compile-verify-repair loop (up to 2 repair attempts).
+     * Mutates `state` in place with updated rules, lists, and verification results.
+     */
+    private runRepairLoop;
     /**
      * Compiles policy rules for a single server (initial compilation).
      * Uses per-server schema with requireServer: true.