feat: policy tools (#29)

Author: drorIvry

package.json

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

src/index.ts

@@ -276,6 +276,7 @@ export class Qualifire {
       grounding_multi_turn_mode:
         evaluationProxyAPIRequest.groundingMultiTurnMode,
       policy_multi_turn_mode: evaluationProxyAPIRequest.policyMultiTurnMode,
+      policy_include_tools: evaluationProxyAPIRequest.policyIncludeTools,
       policy_target: evaluationProxyAPIRequest.policyTarget,
       allowed_topics: evaluationProxyAPIRequest.allowedTopics,
       topic_scoping_mode:
@@ -370,6 +371,10 @@ export class Qualifire {
         EvaluationRequestV2.tool_selection_quality_check,
       tuq_mode: EvaluationRequestV2.tuqMode ?? EvaluationRequestV2.tsqMode,
       assertions: EvaluationRequestV2.assertions,
+      assertions_mode: EvaluationRequestV2.assertionsMode,
+      policy_multi_turn_mode: EvaluationRequestV2.policyMultiTurnMode,
+      policy_include_tools: EvaluationRequestV2.policyIncludeTools,
+      policy_target: EvaluationRequestV2.policyTarget,
       topic_scoping_mode: EvaluationRequestV2.topicScopingMode,
       topic_scoping_multi_turn_mode:
         EvaluationRequestV2.topicScopingMultiTurnMode,

src/types.ts

@@ -133,6 +133,7 @@ export const EvaluationRequestV2Schema = z.object({
   hallucinationsMode: z.enum(ModelModeEnum).default('balanced').optional(),
   groundingMultiTurnMode: z.boolean().default(false).optional(),
   policyMultiTurnMode: z.boolean().default(false).optional(),
+  policyIncludeTools: z.boolean().default(false).optional(),
   policyTarget: z.enum(PolicyTargetEnum).optional(),
   topicScopingMode: z.enum(ModelModeEnum).default('balanced').optional(),
   topicScopingMultiTurnMode: z.boolean().default(false).optional(),
@@ -201,6 +202,7 @@ export const EvaluationProxyAPIRequestSchema = z
     hallucinationsMode: z.enum(ModelModeEnum).default('balanced').optional(),
     groundingMultiTurnMode: z.boolean().default(false).optional(),
     policyMultiTurnMode: z.boolean().default(false).optional(),
+    policyIncludeTools: 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(),

test/index.spec.ts

@@ -97,4 +97,87 @@ describe('index', () => {
       expect(body.topic_scoping_target).toBe('input');
     });
   });
+
+  describe('policy_include_tools field', () => {
+    it('should pass policy_include_tools 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,
+        policyIncludeTools: true,
+      });
+
+      expect(capturedBodies).toHaveLength(1);
+      const body = capturedBodies[0];
+      expect(body.policy_include_tools).toBe(true);
+    });
+
+    it('should pass policy_include_tools 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,
+        policyIncludeTools: true,
+      });
+
+      expect(capturedBodies).toHaveLength(1);
+      const body = capturedBodies[0];
+      expect(body.policy_include_tools).toBe(true);
+    });
+  });
 });