@artemiskit/cli 0.2.3 → 0.3.0

package/dist/src/adapters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adapters.d.ts","sourceRoot":"","sources":["../../src/adapters.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAuBtD"}
+{"version":3,"file":"adapters.d.ts","sourceRoot":"","sources":["../../src/adapters.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAqDtD"}

package/dist/src/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAYpC,wBAAgB,SAAS,IAAI,OAAO,CAwCnC"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC,wBAAgB,SAAS,IAAI,OAAO,CAyCnC"}

package/dist/src/commands/redteam.d.ts

@@ -1,5 +1,10 @@
 /**
  * Redteam command - Run red-team adversarial tests
+ *
+ * Supports OWASP LLM Top 10 2025 security testing with new flags:
+ * --owasp: Test specific OWASP categories (e.g., --owasp LLM01,LLM05)
+ * --owasp-full: Full OWASP compliance scan
+ * --min-severity: Filter attacks by minimum severity level
  */
 import { Command } from 'commander';
 export declare function redteamCommand(): Command;

package/dist/src/commands/redteam.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"redteam.d.ts","sourceRoot":"","sources":["../../../src/commands/redteam.ts"],"names":[],"mappings":"AAAA;;GAEG;AAsCH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAoCpC,wBAAgB,cAAc,IAAI,OAAO,CAycxC"}
+{"version":3,"file":"redteam.d.ts","sourceRoot":"","sources":["../../../src/commands/redteam.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAgDH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAwCpC,wBAAgB,cAAc,IAAI,OAAO,CA8exC"}

package/dist/src/commands/run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../src/commands/run.ts"],"names":[],"mappings":"AAAA;;GAEG;AAiBH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAyiBpC,wBAAgB,UAAU,IAAI,OAAO,CAggBpC"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../src/commands/run.ts"],"names":[],"mappings":"AAAA;;GAEG;AAiBH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA0iBpC,wBAAgB,UAAU,IAAI,OAAO,CAwgBpC"}

package/dist/src/commands/validate.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Validate command - Validate scenarios without running them
+ */
+import { Command } from 'commander';
+export declare function validateCommand(): Command;
+//# sourceMappingURL=validate.d.ts.map

package/dist/src/commands/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../src/commands/validate.ts"],"names":[],"mappings":"AAAA;;GAEG;AASH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAWpC,wBAAgB,eAAe,IAAI,OAAO,CAkHzC"}

package/dist/src/config/schema.d.ts

@@ -15,6 +15,10 @@ declare const ProviderConfigSchema: z.ZodObject<{
     embeddingDeploymentName: z.ZodOptional<z.ZodString>;
     modelFamily: z.ZodOptional<z.ZodString>;
     underlyingProvider: z.ZodOptional<z.ZodEnum<["openai", "azure", "anthropic", "google", "mistral"]>>;
+    name: z.ZodOptional<z.ZodString>;
+    runnableType: z.ZodOptional<z.ZodEnum<["chain", "agent", "llm", "runnable"]>>;
+    captureTraces: z.ZodOptional<z.ZodBoolean>;
+    captureMessages: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     apiKey?: string | undefined;
     baseUrl?: string | undefined;
@@ -28,6 +32,10 @@ declare const ProviderConfigSchema: z.ZodObject<{
     embeddingDeploymentName?: string | undefined;
     modelFamily?: string | undefined;
     underlyingProvider?: "openai" | "anthropic" | "google" | "mistral" | "azure" | undefined;
+    name?: string | undefined;
+    runnableType?: "chain" | "agent" | "llm" | "runnable" | undefined;
+    captureTraces?: boolean | undefined;
+    captureMessages?: boolean | undefined;
 }, {
     apiKey?: string | undefined;
     baseUrl?: string | undefined;
@@ -41,6 +49,10 @@ declare const ProviderConfigSchema: z.ZodObject<{
     embeddingDeploymentName?: string | undefined;
     modelFamily?: string | undefined;
     underlyingProvider?: "openai" | "anthropic" | "google" | "mistral" | "azure" | undefined;
+    name?: string | undefined;
+    runnableType?: "chain" | "agent" | "llm" | "runnable" | undefined;
+    captureTraces?: boolean | undefined;
+    captureMessages?: boolean | undefined;
 }>;
 declare const StorageConfigSchema: z.ZodObject<{
     type: z.ZodDefault<z.ZodEnum<["supabase", "local"]>>;
@@ -78,6 +90,10 @@ export declare const ArtemisConfigSchema: z.ZodObject<{
         embeddingDeploymentName: z.ZodOptional<z.ZodString>;
         modelFamily: z.ZodOptional<z.ZodString>;
         underlyingProvider: z.ZodOptional<z.ZodEnum<["openai", "azure", "anthropic", "google", "mistral"]>>;
+        name: z.ZodOptional<z.ZodString>;
+        runnableType: z.ZodOptional<z.ZodEnum<["chain", "agent", "llm", "runnable"]>>;
+        captureTraces: z.ZodOptional<z.ZodBoolean>;
+        captureMessages: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         apiKey?: string | undefined;
         baseUrl?: string | undefined;
@@ -91,6 +107,10 @@ export declare const ArtemisConfigSchema: z.ZodObject<{
         embeddingDeploymentName?: string | undefined;
         modelFamily?: string | undefined;
         underlyingProvider?: "openai" | "anthropic" | "google" | "mistral" | "azure" | undefined;
+        name?: string | undefined;
+        runnableType?: "chain" | "agent" | "llm" | "runnable" | undefined;
+        captureTraces?: boolean | undefined;
+        captureMessages?: boolean | undefined;
     }, {
         apiKey?: string | undefined;
         baseUrl?: string | undefined;
@@ -104,6 +124,10 @@ export declare const ArtemisConfigSchema: z.ZodObject<{
         embeddingDeploymentName?: string | undefined;
         modelFamily?: string | undefined;
         underlyingProvider?: "openai" | "anthropic" | "google" | "mistral" | "azure" | undefined;
+        name?: string | undefined;
+        runnableType?: "chain" | "agent" | "llm" | "runnable" | undefined;
+        captureTraces?: boolean | undefined;
+        captureMessages?: boolean | undefined;
     }>>>;
     storage: z.ZodOptional<z.ZodObject<{
         type: z.ZodDefault<z.ZodEnum<["supabase", "local"]>>;
@@ -169,6 +193,10 @@ export declare const ArtemisConfigSchema: z.ZodObject<{
         embeddingDeploymentName?: string | undefined;
         modelFamily?: string | undefined;
         underlyingProvider?: "openai" | "anthropic" | "google" | "mistral" | "azure" | undefined;
+        name?: string | undefined;
+        runnableType?: "chain" | "agent" | "llm" | "runnable" | undefined;
+        captureTraces?: boolean | undefined;
+        captureMessages?: boolean | undefined;
     }> | undefined;
     storage?: {
         type: "supabase" | "local";
@@ -204,6 +232,10 @@ export declare const ArtemisConfigSchema: z.ZodObject<{
         embeddingDeploymentName?: string | undefined;
         modelFamily?: string | undefined;
         underlyingProvider?: "openai" | "anthropic" | "google" | "mistral" | "azure" | undefined;
+        name?: string | undefined;
+        runnableType?: "chain" | "agent" | "llm" | "runnable" | undefined;
+        captureTraces?: boolean | undefined;
+        captureMessages?: boolean | undefined;
     }> | undefined;
     storage?: {
         type?: "supabase" | "local" | undefined;

package/dist/src/config/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/config/schema.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBxB,CAAC;AAEH,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;EAMvB,CAAC;AAcH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/config/schema.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwBxB,CAAC;AAEH,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;EAMvB,CAAC;AAcH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/src/utils/adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/utils/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACrE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,MAAM,WAAW,oBAAoB;IACnC,yCAAyC;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,2DAA2D;IAC3D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2BAA2B;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0BAA0B;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,yCAAyC;IACzC,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,sCAAsC;IACtC,UAAU,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IAClC,wCAAwC;IACxC,cAAc,CAAC,EAAE,YAAY,CAAC;IAC9B,qCAAqC;IACrC,WAAW,CAAC,EAAE,YAAY,CAAC;CAC5B;AAOD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,oDAAoD;IACpD,aAAa,EAAE,aAAa,CAAC;IAC7B,+DAA+D;IAC/D,cAAc,EAAE,cAAc,CAAC;CAChC;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,oBAAoB,GAAG,mBAAmB,CA8ErF;AAsXD;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,CAAC,EAAE,MAAM,EACpB,gBAAgB,CAAC,EAAE,MAAM,EACzB,cAAc,CAAC,EAAE,MAAM,GACtB;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAE,CAK5C;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,CAAC,EAAE,MAAM,EACjB,aAAa,CAAC,EAAE,MAAM,EACtB,WAAW,CAAC,EAAE,MAAM,GACnB;IAAE,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,MAAM,EAAE,YAAY,GAAG,SAAS,CAAA;CAAE,CAKjE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,WAAW,CAAC,EAAE,MAAM,EACpB,gBAAgB,CAAC,EAAE,MAAM,EACzB,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM,CAER;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,CAAC,EAAE,MAAM,EACjB,aAAa,CAAC,EAAE,MAAM,EACtB,WAAW,CAAC,EAAE,MAAM,GACnB,MAAM,GAAG,SAAS,CAEpB"}
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/utils/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACrE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,MAAM,WAAW,oBAAoB;IACnC,yCAAyC;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,2DAA2D;IAC3D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2BAA2B;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0BAA0B;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,yCAAyC;IACzC,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,sCAAsC;IACtC,UAAU,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IAClC,wCAAwC;IACxC,cAAc,CAAC,EAAE,YAAY,CAAC;IAC9B,qCAAqC;IACrC,WAAW,CAAC,EAAE,YAAY,CAAC;CAC5B;AAOD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,oDAAoD;IACpD,aAAa,EAAE,aAAa,CAAC;IAC7B,+DAA+D;IAC/D,cAAc,EAAE,cAAc,CAAC;CAChC;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,oBAAoB,GAAG,mBAAmB,CAsGrF;AAqgBD;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,CAAC,EAAE,MAAM,EACpB,gBAAgB,CAAC,EAAE,MAAM,EACzB,cAAc,CAAC,EAAE,MAAM,GACtB;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAE,CAK5C;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,CAAC,EAAE,MAAM,EACjB,aAAa,CAAC,EAAE,MAAM,EACtB,WAAW,CAAC,EAAE,MAAM,GACnB;IAAE,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,MAAM,EAAE,YAAY,GAAG,SAAS,CAAA;CAAE,CAKjE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,WAAW,CAAC,EAAE,MAAM,EACpB,gBAAgB,CAAC,EAAE,MAAM,EACzB,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM,CAER;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,CAAC,EAAE,MAAM,EACjB,aAAa,CAAC,EAAE,MAAM,EACtB,WAAW,CAAC,EAAE,MAAM,GACnB,MAAM,GAAG,SAAS,CAEpB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@artemiskit/cli",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "description": "Command-line interface for ArtemisKit LLM evaluation toolkit",
   "type": "module",
   "license": "Apache-2.0",
@@ -45,11 +45,13 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@artemiskit/adapter-openai": "0.1.10",
-    "@artemiskit/adapter-vercel-ai": "0.1.10",
-    "@artemiskit/core": "0.2.3",
-    "@artemiskit/redteam": "0.2.3",
-    "@artemiskit/reports": "0.2.3",
+    "@artemiskit/adapter-deepagents": "workspace:*",
+    "@artemiskit/adapter-langchain": "workspace:*",
+    "@artemiskit/adapter-openai": "0.1.12",
+    "@artemiskit/adapter-vercel-ai": "0.1.12",
+    "@artemiskit/core": "0.3.0",
+    "@artemiskit/redteam": "0.3.0",
+    "@artemiskit/reports": "0.3.0",
     "chalk": "^5.3.0",
     "cli-table3": "^0.6.3",
     "commander": "^12.0.0",

package/src/__tests__/integration/ui.test.ts

@@ -62,7 +62,7 @@ describe('UI Components', () => {
       expect(panel).toContain('TEST RESULTS');
     });
 
-    it('should use box drawing characters', () => {
+    it('should render panel with consistent formatting', () => {
       const panel = renderSummaryPanel({
         passed: 5,
         failed: 0,
@@ -71,11 +71,11 @@ describe('UI Components', () => {
         duration: 5000,
       });
 
-      expect(panel).toContain('╔');
-      expect(panel).toContain('╗');
-      expect(panel).toContain('╚');
-      expect(panel).toContain('╝');
-      expect(panel).toContain('║');
+      // Panel should contain key information regardless of formatting style
+      // (box-drawing in TTY mode, ASCII fallback in non-TTY)
+      expect(panel).toContain('Passed');
+      expect(panel).toContain('5');
+      expect(panel).toContain('100');
     });
 
     it('should support custom title', () => {
@@ -116,16 +116,17 @@ describe('UI Components', () => {
       expect(error).toContain('Suggestions');
     });
 
-    it('should use box drawing characters', () => {
+    it('should render error with consistent formatting', () => {
       const error = renderError({
         title: 'Test Error',
         reason: 'Test reason',
       });
 
-      expect(error).toContain('┌');
-      expect(error).toContain('┐');
-      expect(error).toContain('└');
-      expect(error).toContain('┘');
+      // Error should contain key information regardless of formatting style
+      // (box-drawing in TTY mode, ASCII fallback in non-TTY)
+      expect(error).toContain('ERROR');
+      expect(error).toContain('Test Error');
+      expect(error).toContain('Test reason');
     });
   });
 
@@ -138,14 +139,13 @@ describe('UI Components', () => {
       expect(box).toContain('Line 2');
     });
 
-    it('should use box drawing characters', () => {
+    it('should render info box with consistent formatting', () => {
       const box = renderInfoBox('Test', ['content']);
 
-      // Uses standard box drawing (may be rounded or square depending on implementation)
-      expect(box).toContain('┌');
-      expect(box).toContain('┐');
-      expect(box).toContain('└');
-      expect(box).toContain('┘');
+      // Info box should contain key information regardless of formatting style
+      // (box-drawing in TTY mode, ASCII fallback in non-TTY)
+      expect(box).toContain('Test');
+      expect(box).toContain('content');
     });
   });
 

package/src/adapters.ts

@@ -23,6 +23,36 @@ export async function registerAdapters(): Promise<void> {
     return new VercelAIAdapter(config);
   });
 
+  // LangChain adapter - requires runnable via metadata
+  adapterRegistry.register('langchain', async (config: AdapterConfig): Promise<ModelClient> => {
+    // Dynamic import to avoid bundling LangChain dependencies
+    // biome-ignore lint/suspicious/noExplicitAny: Runtime validation ensures valid runnable
+    const { LangChainAdapter } = (await import('@artemiskit/adapter-langchain')) as any;
+    const runnable = (config as { metadata?: { runnable?: unknown } }).metadata?.runnable;
+    if (!runnable) {
+      throw new Error(
+        'LangChain adapter requires a runnable instance. ' +
+          'Pass it via config.metadata.runnable or use createLangChainAdapter() directly.'
+      );
+    }
+    return new LangChainAdapter(config, runnable);
+  });
+
+  // DeepAgents adapter - requires system via metadata
+  adapterRegistry.register('deepagents', async (config: AdapterConfig): Promise<ModelClient> => {
+    // Dynamic import to avoid bundling DeepAgents dependencies
+    // biome-ignore lint/suspicious/noExplicitAny: Runtime validation ensures valid system
+    const { DeepAgentsAdapter } = (await import('@artemiskit/adapter-deepagents')) as any;
+    const system = (config as { metadata?: { system?: unknown } }).metadata?.system;
+    if (!system) {
+      throw new Error(
+        'DeepAgents adapter requires a system instance. ' +
+          'Pass it via config.metadata.system or use createDeepAgentsAdapter() directly.'
+      );
+    }
+    return new DeepAgentsAdapter(config, system);
+  });
+
   // Mark post-MVP adapters as unavailable
   adapterRegistry.markUnavailable('anthropic', 'Anthropic adapter coming in v0.2.0');
   adapterRegistry.markUnavailable('google', 'Google adapter coming in v0.3.0');

package/src/cli.ts

@@ -12,6 +12,7 @@ import { redteamCommand } from './commands/redteam';
 import { reportCommand } from './commands/report';
 import { runCommand } from './commands/run';
 import { stressCommand } from './commands/stress';
+import { validateCommand } from './commands/validate';
 import { checkForUpdate, formatUpdateMessage, formatVersionDisplay } from './utils/update-checker';
 
 export function createCLI(): Command {
@@ -46,6 +47,7 @@ export function createCLI(): Command {
 
   program.addCommand(initCommand());
   program.addCommand(runCommand());
+  program.addCommand(validateCommand());
   program.addCommand(baselineCommand());
   program.addCommand(compareCommand());
   program.addCommand(historyCommand());

package/src/commands/redteam.ts

@@ -1,5 +1,10 @@
 /**
  * Redteam command - Run red-team adversarial tests
+ *
+ * Supports OWASP LLM Top 10 2025 security testing with new flags:
+ * --owasp: Test specific OWASP categories (e.g., --owasp LLM01,LLM05)
+ * --owasp-full: Full OWASP compliance scan
+ * --min-severity: Filter attacks by minimum severity level
  */
 
 import { mkdir, writeFile } from 'node:fs/promises';
@@ -19,22 +24,32 @@ import {
   parseScenarioFile,
 } from '@artemiskit/core';
 import {
+  BadLikertJudgeMutation,
   type ConversationTurn,
   CotInjectionMutation,
+  CrescendoMutation,
+  DeceptiveDelightMutation,
   EncodingMutation,
+  ExcessiveAgencyMutation,
+  HallucinationTrapMutation,
   InstructionFlipMutation,
   MultiTurnMutation,
   type Mutation,
+  OWASP_CATEGORIES,
+  OutputInjectionMutation,
   RedTeamGenerator,
   RoleSpoofMutation,
   SeverityMapper,
+  SystemExtractionMutation,
   TypoMutation,
   UnsafeResponseDetector,
+  getMutationsForCategory,
   loadCustomAttacks,
 } from '@artemiskit/redteam';
 import {
   generateJSONReport,
   generateRedTeamHTMLReport,
+  generateRedTeamJUnitReport,
   generateRedTeamMarkdownReport,
 } from '@artemiskit/reports';
 import chalk from 'chalk';
@@ -70,8 +85,12 @@ interface RedteamOptions {
   config?: string;
   redact?: boolean;
   redactPatterns?: string[];
-  export?: 'markdown';
+  export?: 'markdown' | 'junit';
   exportOutput?: string;
+  // OWASP options
+  owasp?: string[];
+  owaspFull?: boolean;
+  minSeverity?: 'low' | 'medium' | 'high' | 'critical';
 }
 
 export function redteamCommand(): Command {
@@ -84,7 +103,7 @@ export function redteamCommand(): Command {
     .option('-m, --model <model>', 'Model to use')
     .option(
       '--mutations <mutations...>',
-      'Mutations to apply (typo, role-spoof, instruction-flip, cot-injection, encoding, multi-turn)'
+      'Mutations to apply (typo, role-spoof, instruction-flip, cot-injection, encoding, multi-turn, bad-likert-judge, crescendo, deceptive-delight, output-injection, excessive-agency, system-extraction, hallucination-trap)'
     )
     .option('-c, --count <number>', 'Number of mutated prompts per case', '5')
     .option('--custom-attacks <path>', 'Path to custom attacks YAML file')
@@ -97,8 +116,18 @@ export function redteamCommand(): Command {
       '--redact-patterns <patterns...>',
       'Custom redaction patterns (regex or built-in: email, phone, credit_card, ssn, api_key)'
     )
-    .option('--export <format>', 'Export results to format (markdown)')
+    .option('--export <format>', 'Export results to format (markdown or junit)')
     .option('--export-output <dir>', 'Output directory for exports (default: ./artemis-exports)')
+    // OWASP options
+    .option(
+      '--owasp <categories...>',
+      'Test specific OWASP LLM Top 10 categories (e.g., LLM01, LLM05, LLM06)'
+    )
+    .option('--owasp-full', 'Run full OWASP LLM Top 10 compliance scan (all applicable categories)')
+    .option(
+      '--min-severity <level>',
+      'Minimum severity level for attacks (low, medium, high, critical)'
+    )
     .action(async (scenarioPath: string, options: RedteamOptions) => {
       const spinner = createSpinner('Loading configuration...');
       spinner.start();
@@ -144,8 +173,15 @@ export function redteamCommand(): Command {
         const client = await createAdapter(adapterConfig);
         spinner.succeed(`Connected to ${provider}`);
 
-        // Set up mutations
-        const mutations = selectMutations(options.mutations, options.customAttacks);
+        // Set up mutations - check for OWASP flags first
+        const mutations = selectMutations({
+          names: options.mutations,
+          customAttacksPath: options.customAttacks,
+          owaspCategories: options.owasp,
+          owaspFull: options.owaspFull,
+          minSeverity: options.minSeverity,
+        });
+
         const generator = new RedTeamGenerator(mutations);
         const detector = new UnsafeResponseDetector();
         const count = Number.parseInt(String(options.count)) || 5;
@@ -157,6 +193,14 @@ export function redteamCommand(): Command {
           `Prompts per case: ${count}`,
           `Total cases: ${scenario.cases.length}`,
         ];
+        if (options.owasp || options.owaspFull) {
+          configLines.push(
+            `OWASP Mode: ${options.owaspFull ? 'Full Compliance Scan' : options.owasp?.join(', ')}`
+          );
+        }
+        if (options.minSeverity) {
+          configLines.push(`Min Severity: ${options.minSeverity}`);
+        }
         if (options.redact) {
           configLines.push(
             `Redaction: enabled${options.redactPatterns ? ` (${options.redactPatterns.join(', ')})` : ''}`
@@ -416,6 +460,10 @@ export function redteamCommand(): Command {
             model: resolvedConfig.model,
             mutations: mutations.map((m) => m.name),
             count_per_case: count,
+            // Include OWASP info in config
+            ...(options.owaspFull && { owasp_mode: 'full' }),
+            ...(options.owasp && { owasp_categories: options.owasp }),
+            ...(options.minSeverity && { min_severity: options.minSeverity }),
           },
           resolved_config: resolvedConfig,
           metrics,
@@ -503,14 +551,22 @@ export function redteamCommand(): Command {
           console.log(chalk.dim(`  JSON: ${jsonPath}`));
         }
 
-        // Export to markdown if requested
-        if (options.export === 'markdown') {
+        // Export if requested
+        if (options.export) {
           const exportDir = options.exportOutput || './artemis-exports';
           await mkdir(exportDir, { recursive: true });
-          const markdown = generateRedTeamMarkdownReport(manifest);
-          const mdPath = join(exportDir, `${runId}.md`);
-          await writeFile(mdPath, markdown);
-          console.log(chalk.dim(`Exported: ${mdPath}`));
+
+          if (options.export === 'markdown') {
+            const markdown = generateRedTeamMarkdownReport(manifest);
+            const mdPath = join(exportDir, `${runId}.md`);
+            await writeFile(mdPath, markdown);
+            console.log(chalk.dim(`Exported: ${mdPath}`));
+          } else if (options.export === 'junit') {
+            const junit = generateRedTeamJUnitReport(manifest);
+            const junitPath = join(exportDir, `${runId}.xml`);
+            await writeFile(junitPath, junit);
+            console.log(chalk.dim(`Exported: ${junitPath}`));
+          }
         }
 
         // Exit with error if there were unsafe responses
@@ -533,22 +589,123 @@ export function redteamCommand(): Command {
   return cmd;
 }
 
-function selectMutations(names?: string[], customAttacksPath?: string): Mutation[] {
-  const allMutations: Record<string, Mutation> = {
+/**
+ * All available mutations registry
+ */
+function getAllMutations(): Record<string, Mutation> {
+  return {
+    // Core mutations (v0.1.x - v0.2.x)
     typo: new TypoMutation(),
     'role-spoof': new RoleSpoofMutation(),
     'instruction-flip': new InstructionFlipMutation(),
     'cot-injection': new CotInjectionMutation(),
     encoding: new EncodingMutation(),
     'multi-turn': new MultiTurnMutation(),
+
+    // OWASP LLM Top 10 2025 mutations (v0.3.0)
+    // LLM01 - Prompt Injection
+    'bad-likert-judge': new BadLikertJudgeMutation(),
+    crescendo: new CrescendoMutation(),
+    'deceptive-delight': new DeceptiveDelightMutation(),
+
+    // LLM05 - Insecure Output Handling
+    'output-injection': new OutputInjectionMutation(),
+
+    // LLM06 - Excessive Agency
+    'excessive-agency': new ExcessiveAgencyMutation(),
+
+    // LLM07 - System Prompt Leakage
+    'system-extraction': new SystemExtractionMutation(),
+
+    // LLM09 - Misinformation
+    'hallucination-trap': new HallucinationTrapMutation(),
   };
+}
+
+/**
+ * Get OWASP mutations for specific categories
+ */
+function getOwaspMutations(categories: string[]): string[] {
+  const mutationNames = new Set<string>();
+
+  for (const category of categories) {
+    const upperCategory = category.toUpperCase();
+    if (upperCategory in OWASP_CATEGORIES) {
+      const mutations = getMutationsForCategory(upperCategory as keyof typeof OWASP_CATEGORIES);
+      for (const mutation of mutations) {
+        mutationNames.add(mutation);
+      }
+    }
+  }
 
-  let mutations: Mutation[];
+  return Array.from(mutationNames);
+}
 
-  if (!names || names.length === 0) {
-    mutations = Object.values(allMutations);
+/**
+ * Get all OWASP mutations
+ */
+function getAllOwaspMutations(): string[] {
+  return [
+    'bad-likert-judge',
+    'crescendo',
+    'deceptive-delight',
+    'output-injection',
+    'excessive-agency',
+    'system-extraction',
+    'hallucination-trap',
+  ];
+}
+
+interface SelectMutationsOptions {
+  names?: string[];
+  customAttacksPath?: string;
+  owaspCategories?: string[];
+  owaspFull?: boolean;
+  minSeverity?: 'low' | 'medium' | 'high' | 'critical';
+}
+
+function selectMutations(options: SelectMutationsOptions): Mutation[] {
+  const { names, customAttacksPath, owaspCategories, owaspFull, minSeverity } = options;
+
+  const allMutations = getAllMutations();
+  let selectedNames: string[] = [];
+
+  // Determine which mutations to use based on options
+  if (owaspFull) {
+    // Full OWASP scan - use all OWASP mutations
+    selectedNames = getAllOwaspMutations();
+  } else if (owaspCategories && owaspCategories.length > 0) {
+    // Specific OWASP categories
+    selectedNames = getOwaspMutations(owaspCategories);
+  } else if (names && names.length > 0) {
+    // Explicit mutation names
+    selectedNames = names;
   } else {
-    mutations = names.filter((name) => name in allMutations).map((name) => allMutations[name]);
+    // Default: use core mutations (not OWASP ones to maintain backward compatibility)
+    selectedNames = [
+      'typo',
+      'role-spoof',
+      'instruction-flip',
+      'cot-injection',
+      'encoding',
+      'multi-turn',
+    ];
+  }
+
+  // Filter to valid mutation names
+  let mutations = selectedNames
+    .filter((name) => name in allMutations)
+    .map((name) => allMutations[name]);
+
+  // Apply severity filter if specified
+  if (minSeverity) {
+    const severityOrder = ['low', 'medium', 'high', 'critical'];
+    const minIndex = severityOrder.indexOf(minSeverity);
+
+    mutations = mutations.filter((m) => {
+      const mutationIndex = severityOrder.indexOf(m.severity);
+      return mutationIndex >= minIndex;
+    });
   }
 
   // Load custom attacks if path provided

package/src/commands/run.ts

@@ -15,7 +15,7 @@ import {
   resolveScenarioPaths,
   runScenario,
 } from '@artemiskit/core';
-import { generateMarkdownReport } from '@artemiskit/reports';
+import { generateJUnitReport, generateMarkdownReport } from '@artemiskit/reports';
 import chalk from 'chalk';
 import { Command } from 'commander';
 import { loadConfig } from '../config/loader.js';
@@ -68,8 +68,8 @@ interface RunOptions {
   threshold?: number;
   /** Budget limit in USD - fail if cost exceeds this */
   budget?: number;
-  /** Export format: markdown */
-  export?: 'markdown';
+  /** Export format: markdown or junit */
+  export?: 'markdown' | 'junit';
   /** Output directory for exports */
   exportOutput?: string;
 }
@@ -554,7 +554,8 @@ async function runScenariosInParallel(
   while (queue.length > 0 || inProgress.size > 0) {
     // Start new tasks up to the limit
     while (queue.length > 0 && inProgress.size < parallelLimit) {
-      const path = queue.shift()!;
+      const path = queue.shift();
+      if (!path) break;
       const promise = processScenario(path).then(() => {
         inProgress.delete(promise);
       });
@@ -607,7 +608,7 @@ export function runCommand(): Command {
     .option('--baseline', 'Compare against baseline and detect regression')
     .option('--threshold <number>', 'Regression threshold (0-1), e.g., 0.05 for 5%', '0.05')
     .option('--budget <amount>', 'Maximum budget in USD - fail if estimated cost exceeds this')
-    .option('--export <format>', 'Export format: markdown')
+    .option('--export <format>', 'Export format: markdown or junit (for CI integration)')
     .option('--export-output <dir>', 'Output directory for exports (default: ./artemis-exports)')
     .action(async (scenarioPath: string | undefined, options: RunOptions) => {
       // Determine CI mode: explicit flag, environment variable, or summary format that implies CI
@@ -819,14 +820,22 @@ export function runCommand(): Command {
                 console.log(chalk.dim(`Saved: ${savedPath}`));
               }
 
-              // Export to markdown if requested
-              if (options.export === 'markdown') {
+              // Export if requested
+              if (options.export) {
                 const exportDir = options.exportOutput || './artemis-exports';
                 await mkdir(exportDir, { recursive: true });
-                const markdown = generateMarkdownReport(result.manifest);
-                const mdPath = join(exportDir, `${result.manifest.run_id}.md`);
-                await writeFile(mdPath, markdown);
-                console.log(chalk.dim(`Exported: ${mdPath}`));
+
+                if (options.export === 'markdown') {
+                  const markdown = generateMarkdownReport(result.manifest);
+                  const mdPath = join(exportDir, `${result.manifest.run_id}.md`);
+                  await writeFile(mdPath, markdown);
+                  console.log(chalk.dim(`Exported: ${mdPath}`));
+                } else if (options.export === 'junit') {
+                  const junit = generateJUnitReport(result.manifest);
+                  const junitPath = join(exportDir, `${result.manifest.run_id}.xml`);
+                  await writeFile(junitPath, junit);
+                  console.log(chalk.dim(`Exported: ${junitPath}`));
+                }
               }
             } catch (error) {
               // Record failed scenario