qualifire 1.0.1 → 1.1.1

package/README.md

@@ -1,49 +1,95 @@
-# my-package-name
+Qualifire
 
-[![CodeQL](https://github.com/drorIvry/qualifire-typescript-sdk/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/drorIvry/qualifire-typescript-sdk/actions/workflows/codeql-analysis.yml)
-[![Release](https://github.com/drorIvry/qualifire-typescript-sdk/actions/workflows/release.yml/badge.svg)](https://github.com/drorIvry/qualifire-typescript-sdk/actions/workflows/release.yml)
+[![CodeQL](https://github.com/qualifire-dev/qualifire-typescript-sdk/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/qualifire-dev/qualifire-typescript-sdk/actions/workflows/codeql-analysis.yml)
+[![Release](https://github.com/qualifire-dev/qualifire-typescript-sdk/actions/workflows/release.yml/badge.svg)](https://github.com/qualifire-dev/qualifire-typescript-sdk/actions/workflows/release.yml)
 [![Issues][issues-img]][issues-url]
 [![Code Coverage][codecov-img]][codecov-url]
 [![Commitizen Friendly][commitizen-img]][commitizen-url]
 [![Semantic Release][semantic-release-img]][semantic-release-url]
 
-> My awesome module
+# Qualifire SDK
 
-## Install
+This is the official SDK for interacting with the Qualifire API.
+
+## Installation
 
 ```bash
-npm install my-package-name
+npm install qualifire
 ```
 
-## Usage
+## usage
 
-```ts
-import * as qualifire from 'qualifire';
+First, import the `Qualifire` class from the SDK:
 
-const qualifireClient = qualifire.getClient('#YOUR-SDK-KEY#');
+```javascript
+import { Qualifire } from 'qualifire-sdk';
+```
 
-const prompt = await qualifireClient.getValueAsync(
-  'isMyAwesomeFeatureEnabled',
-  {
-    var1: 'val1',
-    var2: 'val2',
-  }
-);
+Then, create a new instance of the Qualifire class, passing your API key and the base URL of the Qualifire API:
 
-const chatCompletion = await openai.createChatCompletion({
-  model: 'gpt-3.5-turbo',
-  messages: [{ role: 'user', content: prompt }],
+```javascript
+const qualifire = new Qualifire({
+  apiKey: 'your-api-key',
 });
 ```
 
-[build-img]: https://github.com/drorivry/develop/qualifire-typescript-sdk/actions/workflows/release.yml/badge.svg
-[build-url]: https://github.com/drorivry/qualifire-typescript-sdk/actions/workflows/release.yml
+ℹ️ There are default environment variables if you prefer to set it that way `QUALIFIRE_API_KEY`
+
+You can now use the `evaluate` method to evaluate input and output data:
+
+```javascript
+const input = {
+  model: 'gpt-3.5-turbo',
+  messages: [
+    {
+      role: 'user',
+      content: 'this is my awesome request',
+    },
+  ],
+};
+
+const output = await openai.chat.completions.create(input);
+
+const evaluationResponse = await qualifire.evaluate(input, output); // This will block until the evaluation is done
+console.log(evaluationResponse);
+```
+
+### Non-blocking execution
+
+In case you want to trigger a completely async evaluation (to view in qualifire's UI) simply add the `{async: true}` option to your call.
+
+```javascript
+const input = {
+  model: 'gpt-3.5-turbo',
+  messages: [
+    {
+      role: 'user',
+      content: 'this is my awesome request',
+    },
+  ],
+};
+
+const output = await openai.chat.completions.create(input);
+
+const evaluationResponse = await qualifire.evaluate(input, output, {
+  async: true,
+}); // This will block until the evaluation is done
+console.log(evaluationResponse);
+```
+
+Evaluates the input and output using the Qualifire API. Returns a promise that resolves to the evaluation response, or undefined if async is true.
+
+
+
+
+[build-img]: https://github.com/qualifire-dev/develop/qualifire-typescript-sdk/actions/workflows/release.yml/badge.svg
+[build-url]: https://github.com/qualifire-dev/qualifire-typescript-sdk/actions/workflows/release.yml
 [downloads-img]: https://img.shields.io/npm/dt/main/qualifire
 [npm-url]: https://www.npmjs.com/package/qualifire
-[issues-img]: https://img.shields.io/github/issues/drorivry/develop/qualifire-typescript-sdk
-[issues-url]: https://github.com/drorivry/qualifire-typescript-sdk/issues
-[codecov-img]: https://codecov.io/gh/drorivry/develop/qualifire-typescript-sdk/branch/main/graph/badge.svg
-[codecov-url]: https://codecov.io/gh/drorivry/develop/qualifire-typescript-sdk
+[issues-img]: https://img.shields.io/github/issues/qualifire-dev/develop/qualifire-typescript-sdk
+[issues-url]: https://github.com/qualifire-dev/qualifire-typescript-sdk/issues
+[codecov-img]: https://codecov.io/gh/qualifire-dev/develop/qualifire-typescript-sdk/branch/main/graph/badge.svg
+[codecov-url]: https://codecov.io/gh/qualifire-dev/develop/qualifire-typescript-sdk
 [semantic-release-img]: https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg
 [semantic-release-url]: https://github.com/semantic-release/semantic-release
 [commitizen-img]: https://img.shields.io/badge/commitizen-friendly-brightgreen.svg

package/lib/index.d.ts

@@ -1,8 +1,30 @@
-export declare function getClient(sdkKey?: string, qualifireBaseUrl?: string): QualifireClient;
-declare class QualifireClient {
+import { EvaluationResponse, Input, Output } from './types';
+/**
+ * Represents the Qualifire SDK.
+ */
+/**
+ * The Qualifire class represents the Qualifire SDK.
+ */
+export declare class Qualifire {
     sdkKey: string;
     baseUrl: string;
-    constructor(key: string, baseUrl: string);
-    getValueAsync(promptId: string, templateValues?: Record<string, string>, defaultValue?: string | null): Promise<string | null>;
+    /**
+     * Creates an instance of the Qualifire class.
+     * @param apiKey - The API key for the Qualifire SDK.
+     * @param baseUrl - The base URL for the Qualifire API.
+     */
+    constructor({ apiKey, baseUrl }: {
+        apiKey: string;
+        baseUrl: string;
+    });
+    /**
+     * Evaluates the input and output using the Qualifire API.
+     * @param input - The input data for evaluation.
+     * @param output - The expected output data for evaluation.
+     * @param options - Additional options for evaluation.
+     * @returns A promise that resolves to the evaluation response.
+     */
+    evaluate: (input: Input, output: Output, { async, }: {
+        async?: boolean | undefined;
+    }) => Promise<EvaluationResponse | undefined>;
 }
-export {};

package/lib/index.js

@@ -1,46 +1,67 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getClient = void 0;
-function getClient(sdkKey, qualifireBaseUrl) {
-    const key = sdkKey || process.env.QUALIFIRE_SDK_KEY;
-    const baseUrl = qualifireBaseUrl ||
-        process.env.QUALIFIRE_BASE_URL ||
-        'https://app.qualifire.xyz';
-    if (!key) {
-        throw new Error('Missing SDK key, please provide an arg or add the QUALIFIRE_SDK_KEY environment variable.');
-    }
-    return new QualifireClient(key, baseUrl);
-}
-exports.getClient = getClient;
-class QualifireClient {
-    constructor(key, baseUrl) {
-        this.sdkKey = key;
-        this.baseUrl = baseUrl;
-    }
-    async getValueAsync(promptId, templateValues, defaultValue = null) {
-        const qualifireResponse = await fetch(`${this.baseUrl}/api/studio/prompt?${new URLSearchParams({
-            promptId,
-        }).toString()}`, {
-            headers: new Headers({
-                Authorization: 'Bearer ' + this.sdkKey,
-            }),
-        });
-        if (!qualifireResponse.ok) {
-            console.error('error while getting the prompt', qualifireResponse.json());
-            return defaultValue;
-        }
-        const regex = /\{[a-zA-Z0-9_-]+\}/gm;
-        const { prompt } = (await qualifireResponse.json());
-        const templateVariables = prompt
-            .match(regex)
-            ?.map(v => v.replace('{', '').replace('}', ''));
-        let parsedPrompt = prompt;
-        if (templateValues && templateVariables) {
-            for (const variable of templateVariables) {
-                parsedPrompt = parsedPrompt.replaceAll(`{${variable}}`, templateValues[variable] || '');
+exports.Qualifire = void 0;
+const types_1 = require("./types");
+/**
+ * Represents the Qualifire SDK.
+ */
+/**
+ * The Qualifire class represents the Qualifire SDK.
+ */
+class Qualifire {
+    /**
+     * Creates an instance of the Qualifire class.
+     * @param apiKey - The API key for the Qualifire SDK.
+     * @param baseUrl - The base URL for the Qualifire API.
+     */
+    constructor({ apiKey, baseUrl }) {
+        /**
+         * Evaluates the input and output using the Qualifire API.
+         * @param input - The input data for evaluation.
+         * @param output - The expected output data for evaluation.
+         * @param options - Additional options for evaluation.
+         * @returns A promise that resolves to the evaluation response.
+         */
+        this.evaluate = async (input, output, { async = false, }) => {
+            const url = `${this.baseUrl}/api/evaluate/v1`;
+            const body = JSON.stringify({ async, input, output });
+            const headers = {
+                'Content-Type': 'application/json',
+                'X-qualifire-key': this.sdkKey,
+            };
+            if (async) {
+                void fetch(url, {
+                    method: 'POST',
+                    headers,
+                    body,
+                });
+            }
+            else {
+                const response = await fetch(url, {
+                    method: 'POST',
+                    headers,
+                    body,
+                });
+                if (!response.ok) {
+                    throw new Error(`Qualifire API error: ${response.statusText}`);
+                }
+                const jsonResponse = await response.json();
+                const parsed = types_1.evaluationResponseSchema.safeParse(jsonResponse);
+                if (!parsed.success) {
+                    throw new Error('Qualifire API error: Evaluation failed');
+                }
+                return parsed.data;
             }
-            return parsedPrompt;
+        };
+        const key = apiKey || process.env.QUALIFIRE_API_KEY;
+        const qualifireBaseUrl = baseUrl ||
+            process.env.QUALIFIRE_BASE_URL ||
+            'https://gateway.qualifire.ai';
+        if (!key) {
+            throw new Error('Missing SDK key, please provide an arg or add the QUALIFIRE_API_KEY environment variable.');
         }
-        return prompt || defaultValue;
+        this.sdkKey = key;
+        this.baseUrl = qualifireBaseUrl;
     }
 }
+exports.Qualifire = Qualifire;

package/lib/types.d.ts

@@ -0,0 +1,472 @@
+import { z } from 'zod';
+export declare const messageSchema: z.ZodObject<{
+    role: z.ZodString;
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    role: string;
+    content: string;
+}, {
+    role: string;
+    content: string;
+}>;
+export declare const choiceSchema: z.ZodObject<{
+    index: z.ZodNumber;
+    message: z.ZodObject<{
+        role: z.ZodString;
+        content: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        role: string;
+        content: string;
+    }, {
+        role: string;
+        content: string;
+    }>;
+    finish_reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: {
+        role: string;
+        content: string;
+    };
+    index: number;
+    finish_reason?: string | undefined;
+}, {
+    message: {
+        role: string;
+        content: string;
+    };
+    index: number;
+    finish_reason?: string | undefined;
+}>;
+export declare const usageSchema: z.ZodObject<{
+    prompt_tokens: z.ZodNumber;
+    completion_tokens: z.ZodNumber;
+    total_tokens: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+}, {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+}>;
+export declare const inputSchema: z.ZodObject<{
+    model: z.ZodString;
+    messages: z.ZodArray<z.ZodObject<{
+        role: z.ZodString;
+        content: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        role: string;
+        content: string;
+    }, {
+        role: string;
+        content: string;
+    }>, "many">;
+    caller: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    model: string;
+    messages: {
+        role: string;
+        content: string;
+    }[];
+    caller?: string | undefined;
+}, {
+    model: string;
+    messages: {
+        role: string;
+        content: string;
+    }[];
+    caller?: string | undefined;
+}>;
+export type Input = z.infer<typeof inputSchema>;
+export declare const outputSchema: z.ZodObject<{
+    id: z.ZodString;
+    created: z.ZodOptional<z.ZodNumber>;
+    model: z.ZodString;
+    choices: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        message: z.ZodObject<{
+            role: z.ZodString;
+            content: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            role: string;
+            content: string;
+        }, {
+            role: string;
+            content: string;
+        }>;
+        finish_reason: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        message: {
+            role: string;
+            content: string;
+        };
+        index: number;
+        finish_reason?: string | undefined;
+    }, {
+        message: {
+            role: string;
+            content: string;
+        };
+        index: number;
+        finish_reason?: string | undefined;
+    }>, "many">;
+    usage: z.ZodOptional<z.ZodObject<{
+        prompt_tokens: z.ZodNumber;
+        completion_tokens: z.ZodNumber;
+        total_tokens: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    }, {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    }>>;
+    system_fingerprint: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    model: string;
+    id: string;
+    choices: {
+        message: {
+            role: string;
+            content: string;
+        };
+        index: number;
+        finish_reason?: string | undefined;
+    }[];
+    created?: number | undefined;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    } | undefined;
+    system_fingerprint?: string | undefined;
+}, {
+    model: string;
+    id: string;
+    choices: {
+        message: {
+            role: string;
+            content: string;
+        };
+        index: number;
+        finish_reason?: string | undefined;
+    }[];
+    created?: number | undefined;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    } | undefined;
+    system_fingerprint?: string | undefined;
+}>;
+export type Output = z.infer<typeof outputSchema>;
+export declare const evaluationSchema: z.ZodObject<{
+    async: z.ZodBoolean;
+    input: z.ZodObject<{
+        model: z.ZodString;
+        messages: z.ZodArray<z.ZodObject<{
+            role: z.ZodString;
+            content: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            role: string;
+            content: string;
+        }, {
+            role: string;
+            content: string;
+        }>, "many">;
+        caller: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        model: string;
+        messages: {
+            role: string;
+            content: string;
+        }[];
+        caller?: string | undefined;
+    }, {
+        model: string;
+        messages: {
+            role: string;
+            content: string;
+        }[];
+        caller?: string | undefined;
+    }>;
+    output: z.ZodObject<{
+        id: z.ZodString;
+        created: z.ZodOptional<z.ZodNumber>;
+        model: z.ZodString;
+        choices: z.ZodArray<z.ZodObject<{
+            index: z.ZodNumber;
+            message: z.ZodObject<{
+                role: z.ZodString;
+                content: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                role: string;
+                content: string;
+            }, {
+                role: string;
+                content: string;
+            }>;
+            finish_reason: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            message: {
+                role: string;
+                content: string;
+            };
+            index: number;
+            finish_reason?: string | undefined;
+        }, {
+            message: {
+                role: string;
+                content: string;
+            };
+            index: number;
+            finish_reason?: string | undefined;
+        }>, "many">;
+        usage: z.ZodOptional<z.ZodObject<{
+            prompt_tokens: z.ZodNumber;
+            completion_tokens: z.ZodNumber;
+            total_tokens: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            prompt_tokens: number;
+            completion_tokens: number;
+            total_tokens: number;
+        }, {
+            prompt_tokens: number;
+            completion_tokens: number;
+            total_tokens: number;
+        }>>;
+        system_fingerprint: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        model: string;
+        id: string;
+        choices: {
+            message: {
+                role: string;
+                content: string;
+            };
+            index: number;
+            finish_reason?: string | undefined;
+        }[];
+        created?: number | undefined;
+        usage?: {
+            prompt_tokens: number;
+            completion_tokens: number;
+            total_tokens: number;
+        } | undefined;
+        system_fingerprint?: string | undefined;
+    }, {
+        model: string;
+        id: string;
+        choices: {
+            message: {
+                role: string;
+                content: string;
+            };
+            index: number;
+            finish_reason?: string | undefined;
+        }[];
+        created?: number | undefined;
+        usage?: {
+            prompt_tokens: number;
+            completion_tokens: number;
+            total_tokens: number;
+        } | undefined;
+        system_fingerprint?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    async: boolean;
+    input: {
+        model: string;
+        messages: {
+            role: string;
+            content: string;
+        }[];
+        caller?: string | undefined;
+    };
+    output: {
+        model: string;
+        id: string;
+        choices: {
+            message: {
+                role: string;
+                content: string;
+            };
+            index: number;
+            finish_reason?: string | undefined;
+        }[];
+        created?: number | undefined;
+        usage?: {
+            prompt_tokens: number;
+            completion_tokens: number;
+            total_tokens: number;
+        } | undefined;
+        system_fingerprint?: string | undefined;
+    };
+}, {
+    async: boolean;
+    input: {
+        model: string;
+        messages: {
+            role: string;
+            content: string;
+        }[];
+        caller?: string | undefined;
+    };
+    output: {
+        model: string;
+        id: string;
+        choices: {
+            message: {
+                role: string;
+                content: string;
+            };
+            index: number;
+            finish_reason?: string | undefined;
+        }[];
+        created?: number | undefined;
+        usage?: {
+            prompt_tokens: number;
+            completion_tokens: number;
+            total_tokens: number;
+        } | undefined;
+        system_fingerprint?: string | undefined;
+    };
+}>;
+export declare const evaluationResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    evaluationResults: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        results: z.ZodArray<z.ZodObject<{
+            claim: z.ZodString;
+            contradiction: z.ZodBoolean;
+            passed: z.ZodBoolean;
+            matchScore: z.ZodNumber;
+            reason: z.ZodString;
+            quote: z.ZodString;
+            includedInContent: z.ZodBoolean;
+            monitorId: z.ZodString;
+            createdAt: z.ZodString;
+            organizationId: z.ZodString;
+            callId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            claim: string;
+            contradiction: boolean;
+            passed: boolean;
+            matchScore: number;
+            reason: string;
+            quote: string;
+            includedInContent: boolean;
+            monitorId: string;
+            createdAt: string;
+            organizationId: string;
+            callId: string;
+        }, {
+            claim: string;
+            contradiction: boolean;
+            passed: boolean;
+            matchScore: number;
+            reason: string;
+            quote: string;
+            includedInContent: boolean;
+            monitorId: string;
+            createdAt: string;
+            organizationId: string;
+            callId: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        results: {
+            claim: string;
+            contradiction: boolean;
+            passed: boolean;
+            matchScore: number;
+            reason: string;
+            quote: string;
+            includedInContent: boolean;
+            monitorId: string;
+            createdAt: string;
+            organizationId: string;
+            callId: string;
+        }[];
+    }, {
+        type: string;
+        results: {
+            claim: string;
+            contradiction: boolean;
+            passed: boolean;
+            matchScore: number;
+            reason: string;
+            quote: string;
+            includedInContent: boolean;
+            monitorId: string;
+            createdAt: string;
+            organizationId: string;
+            callId: string;
+        }[];
+    }>, "many">;
+    score: z.ZodNumber;
+    status: z.ZodString;
+    scoreBreakdown: z.ZodRecord<z.ZodString, z.ZodObject<{
+        length: z.ZodNumber;
+        scoreSum: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        length: number;
+        scoreSum: number;
+    }, {
+        length: number;
+        scoreSum: number;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    status: string;
+    success: boolean;
+    evaluationResults: {
+        type: string;
+        results: {
+            claim: string;
+            contradiction: boolean;
+            passed: boolean;
+            matchScore: number;
+            reason: string;
+            quote: string;
+            includedInContent: boolean;
+            monitorId: string;
+            createdAt: string;
+            organizationId: string;
+            callId: string;
+        }[];
+    }[];
+    score: number;
+    scoreBreakdown: Record<string, {
+        length: number;
+        scoreSum: number;
+    }>;
+}, {
+    status: string;
+    success: boolean;
+    evaluationResults: {
+        type: string;
+        results: {
+            claim: string;
+            contradiction: boolean;
+            passed: boolean;
+            matchScore: number;
+            reason: string;
+            quote: string;
+            includedInContent: boolean;
+            monitorId: string;
+            createdAt: string;
+            organizationId: string;
+            callId: string;
+        }[];
+    }[];
+    score: number;
+    scoreBreakdown: Record<string, {
+        length: number;
+        scoreSum: number;
+    }>;
+}>;
+export type Evaluation = z.infer<typeof evaluationSchema>;
+export type EvaluationResponse = z.infer<typeof evaluationResponseSchema>;

package/lib/types.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluationResponseSchema = exports.evaluationSchema = exports.outputSchema = exports.inputSchema = exports.usageSchema = exports.choiceSchema = exports.messageSchema = void 0;
+const zod_1 = require("zod");
+exports.messageSchema = zod_1.z.object({
+    role: zod_1.z.string(),
+    content: zod_1.z.string(),
+});
+exports.choiceSchema = zod_1.z.object({
+    index: zod_1.z.number(),
+    message: exports.messageSchema,
+    finish_reason: zod_1.z.string().optional(),
+});
+exports.usageSchema = zod_1.z.object({
+    prompt_tokens: zod_1.z.number(),
+    completion_tokens: zod_1.z.number(),
+    total_tokens: zod_1.z.number(),
+});
+exports.inputSchema = zod_1.z.object({
+    model: zod_1.z.string(),
+    messages: zod_1.z.array(exports.messageSchema),
+    caller: zod_1.z.string().optional(),
+});
+exports.outputSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    created: zod_1.z.number().optional(),
+    model: zod_1.z.string(),
+    choices: zod_1.z.array(exports.choiceSchema),
+    usage: exports.usageSchema.optional(),
+    system_fingerprint: zod_1.z.string().optional(),
+});
+exports.evaluationSchema = zod_1.z.object({
+    async: zod_1.z.boolean(),
+    input: exports.inputSchema,
+    output: exports.outputSchema,
+});
+const resultSchema = zod_1.z.object({
+    claim: zod_1.z.string(),
+    contradiction: zod_1.z.boolean(),
+    passed: zod_1.z.boolean(),
+    matchScore: zod_1.z.number(),
+    reason: zod_1.z.string(),
+    quote: zod_1.z.string(),
+    includedInContent: zod_1.z.boolean(),
+    monitorId: zod_1.z.string(),
+    createdAt: zod_1.z.string(),
+    organizationId: zod_1.z.string(),
+    callId: zod_1.z.string(),
+});
+const evaluationResultSchema = zod_1.z.object({
+    type: zod_1.z.string(),
+    results: zod_1.z.array(resultSchema),
+});
+const scoreBreakdownItemSchema = zod_1.z.object({
+    length: zod_1.z.number(),
+    scoreSum: zod_1.z.number(),
+});
+const scoreBreakdownSchema = zod_1.z.record(scoreBreakdownItemSchema);
+exports.evaluationResponseSchema = zod_1.z.object({
+    success: zod_1.z.boolean(),
+    evaluationResults: zod_1.z.array(evaluationResultSchema),
+    score: zod_1.z.number(),
+    status: zod_1.z.string(),
+    scoreBreakdown: scoreBreakdownSchema,
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qualifire",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "Qualifire client SDK",
   "main": "./lib/index.js",
   "files": [
@@ -19,7 +19,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/drorivry/qualifire-typescript-sdk.git"
+    "url": "https://github.com/qualifire-dev/qualifire-typescript-sdk.git"
   },
   "license": "MIT",
   "author": {
@@ -36,9 +36,9 @@
     "llmops"
   ],
   "bugs": {
-    "url": "https://github.com/drorIvry/qualifire-typescript-sdk/issues"
+    "url": "https://github.com/qualifire-dev/qualifire-typescript-sdk/issues"
   },
-  "homepage": "https://github.com/drorIvry/qualifire-typescript-sdk#readme",
+  "homepage": "https://github.com/qualifire-dev/qualifire-typescript-sdk#readme",
   "devDependencies": {
     "@ryansonshine/commitizen": "^4.2.8",
     "@ryansonshine/cz-conventional-changelog": "^3.3.4",
@@ -112,5 +112,8 @@
       "@semantic-release/npm",
       "@semantic-release/github"
     ]
+  },
+  "dependencies": {
+    "zod": "^3.22.4"
   }
 }