Feature/topic scoping

.gitignore

@@ -5,7 +5,7 @@ npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
 lerna-debug.log*
-
+.DS_Store
 # Diagnostic reports (https://nodejs.org/api/report.html)
 report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "qualifire",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "description": "Qualifire client SDK",
   "main": "./lib/index.js",
   "files": [

src/index.ts

@@ -266,6 +266,15 @@ export class Qualifire {
       tuq_mode:
         evaluationProxyAPIRequest.tuqMode ?? evaluationProxyAPIRequest.tsqMode,
       assertions: evaluationProxyAPIRequest.assertions,
+      topic_scoping_mode:
+        evaluationProxyAPIRequest.topicScopingMode ??
+        evaluationProxyAPIRequest.topic_scoping_mode,
+      topic_scoping_multi_turn_mode:
+        evaluationProxyAPIRequest.topicScopingMultiTurnMode ??
+        evaluationProxyAPIRequest.topic_scoping_multi_turn_mode,
+      topic_scoping_target:
+        evaluationProxyAPIRequest.topicScopingTarget ??
+        evaluationProxyAPIRequest.topic_scoping_target,
     };
 
     const headers = {
@@ -348,6 +357,10 @@ export class Qualifire {
         EvaluationRequestV2.tool_selection_quality_check,
       tuq_mode: EvaluationRequestV2.tuqMode ?? EvaluationRequestV2.tsqMode,
       assertions: EvaluationRequestV2.assertions,
+      topic_scoping_mode: EvaluationRequestV2.topicScopingMode,
+      topic_scoping_multi_turn_mode:
+        EvaluationRequestV2.topicScopingMultiTurnMode,
+      topic_scoping_target: EvaluationRequestV2.topicScopingTarget,
     };
 
     const headers = {

src/types.ts

@@ -134,6 +134,9 @@ export const EvaluationRequestV2Schema = z.object({
   groundingMultiTurnMode: z.boolean().default(false).optional(),
   policyMultiTurnMode: z.boolean().default(false).optional(),
   policyTarget: z.enum(PolicyTargetEnum).optional(),
+  topicScopingMode: z.enum(ModelModeEnum).default('balanced').optional(),
+  topicScopingMultiTurnMode: z.boolean().default(false).optional(),
+  topicScopingTarget: z.enum(PolicyTargetEnum).optional(),
 });
 
 export const EvaluationProxyAPIRequestSchema = z
@@ -197,6 +200,12 @@ export const EvaluationProxyAPIRequestSchema = z
     groundingMultiTurnMode: z.boolean().default(false).optional(),
     policyMultiTurnMode: z.boolean().default(false).optional(),
     policyTarget: z.enum(PolicyTargetEnum).optional(),
+    topic_scoping_mode: z.enum(ModelModeEnum).default('balanced').optional(),
+    topic_scoping_multi_turn_mode: z.boolean().default(false).optional(),
+    topic_scoping_target: z.enum(PolicyTargetEnum).optional(),
+    topicScopingMode: z.enum(ModelModeEnum).default('balanced').optional(),
+    topicScopingMultiTurnMode: z.boolean().default(false).optional(),
+    topicScopingTarget: z.enum(PolicyTargetEnum).optional(),
   })
   .superRefine((data, ctx) => {
     const hasMessages =

test/index.spec.ts

@@ -6,4 +6,95 @@ describe('index', () => {
       console.log('later');
     });
   });
+
+  describe('topic scoping fields', () => {
+    it('should pass topic scoping fields in the API request (direct mode)', async () => {
+      const capturedBodies: Record<string, unknown>[] = [];
+      global.fetch = jest
+        .fn()
+        .mockImplementation((_url: string, options: { body: string }) => {
+          capturedBodies.push(
+            JSON.parse(options.body) as Record<string, unknown>
+          );
+          return Promise.resolve({
+            ok: true,
+            json: () =>
+              Promise.resolve({
+                status: 'passed',
+                score: 100,
+                evaluationResults: [],
+              }),
+          });
+        }) as typeof fetch;
+
+      const client = new qualifire.Qualifire({ apiKey: 'test-key' });
+      await client.evaluate({
+        input: 'What is AI?',
+        output: 'Artificial Intelligence',
+        groundingCheck: true,
+        topicScopingMode: 'quality',
+        topicScopingMultiTurnMode: true,
+        topicScopingTarget: 'both',
+      });
+
+      expect(capturedBodies).toHaveLength(1);
+      const body = capturedBodies[0];
+      expect(body.topic_scoping_mode).toBe('quality');
+      expect(body.topic_scoping_multi_turn_mode).toBe(true);
+      expect(body.topic_scoping_target).toBe('both');
+    });
+
+    it('should pass topic scoping fields in the API request (framework mode)', async () => {
+      const capturedBodies: Record<string, unknown>[] = [];
+      global.fetch = jest
+        .fn()
+        .mockImplementation((_url: string, options: { body: string }) => {
+          capturedBodies.push(
+            JSON.parse(options.body) as Record<string, unknown>
+          );
+          return Promise.resolve({
+            ok: true,
+            json: () =>
+              Promise.resolve({
+                status: 'passed',
+                score: 100,
+                evaluationResults: [],
+              }),
+          });
+        }) as typeof fetch;
+
+      const client = new qualifire.Qualifire({ apiKey: 'test-key' });
+      await client.evaluate({
+        framework: 'openai',
+        request: {
+          model: 'gpt-4o',
+          messages: [{ role: 'user', content: 'Hello' }],
+        },
+        response: {
+          id: 'test',
+          object: 'chat.completion',
+          created: 123,
+          model: 'gpt-4o',
+          choices: [
+            {
+              index: 0,
+              message: { role: 'assistant', content: 'Hi' },
+              finish_reason: 'stop',
+            },
+          ],
+          usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
+        },
+        groundingCheck: true,
+        topicScopingMode: 'speed',
+        topicScopingMultiTurnMode: false,
+        topicScopingTarget: 'input',
+      });
+
+      expect(capturedBodies).toHaveLength(1);
+      const body = capturedBodies[0];
+      expect(body.topic_scoping_mode).toBe('speed');
+      expect(body.topic_scoping_multi_turn_mode).toBe(false);
+      expect(body.topic_scoping_target).toBe('input');
+    });
+  });
 });