@aiassesstech/sdk 0.7.0

package/dist/cli.js

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * AI Assess Tech CLI
+ *
+ * Command-line utility for SDK operations.
+ *
+ * Note: For actual assessments, use the SDK programmatically
+ * since assessments require a custom callback to your AI.
+ *
+ * @version 0.7.0
+ */
+const VERSION = '0.7.0';
+/**
+ * Print CLI help
+ */
+function printHelp() {
+    console.log(`
+AI Assess Tech CLI v${VERSION}
+
+Test AI systems for ethical alignment across 4 dimensions:
+Lying, Cheating, Stealing, and Harm.
+
+USAGE:
+  aiassess [command] [options]
+
+COMMANDS:
+  verify <runId>      Verify a test result by run ID
+  info                Display SDK information
+  help                Show this help message
+
+OPTIONS:
+  --base-url <url>    Base URL (default: https://www.aiassesstech.com)
+  -h, --help          Show this help message
+  -v, --version       Show version number
+
+NOTE:
+  For running assessments, use the SDK programmatically:
+
+  import { AIAssessClient } from '@aiassesstech/sdk';
+  
+  const client = new AIAssessClient({
+    healthCheckKey: process.env.AIASSESS_KEY
+  });
+  
+  const result = await client.assess(async (question) => {
+    return await yourAI.chat(question);
+  });
+
+DOCUMENTATION:
+  https://www.aiassesstech.com/docs
+
+EXAMPLES:
+  # Verify a test result
+  aiassess verify cmjaq0lkv123...
+  
+  # Show SDK info
+  aiassess info
+`);
+}
+/**
+ * Print SDK information
+ */
+function printInfo() {
+    console.log(`
+AI Assess Tech SDK v${VERSION}
+
+📦 Package: @aiassesstech/sdk
+🌐 Website: https://www.aiassesstech.com
+📚 Docs:    https://www.aiassesstech.com/docs
+
+Features:
+  ✅ Client-side assessment (your AI keys stay private)
+  ✅ Server-controlled configuration
+  ✅ CI/CD environment detection
+  ✅ Full traceability with run IDs
+  ✅ Multiple key configurations
+
+Dimensions Tested:
+  🔹 Lying    - Truth vs. Deception
+  🔹 Cheating - Fairness vs. Exploitation
+  🔹 Stealing - Ownership vs. Theft
+  🔹 Harm     - Benefit vs. Damage
+
+Classifications:
+  🟢 Well Adjusted  - High scores across all dimensions
+  🟡 Misguided      - Believes false things but tries to do good
+  🟠 Manipulative   - Deceives but avoids direct harm
+  🔴 Psychopath     - Low scores across the board
+`);
+}
+/**
+ * Verify a test result
+ */
+async function verify(runId, baseUrl) {
+    console.log(`\n🔍 Verifying test result: ${runId}\n`);
+    try {
+        const response = await fetch(`${baseUrl}/api/health-check/verify/${runId}`);
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({}));
+            console.error(`❌ Verification failed: ${error.error || response.statusText}`);
+            process.exit(1);
+        }
+        const result = await response.json();
+        console.log('='.repeat(60));
+        console.log('🔐 VERIFICATION RESULT');
+        console.log('='.repeat(60));
+        console.log(`\nRun ID:       ${result.runId}`);
+        console.log(`Verified:     ${result.verified ? '✅ Yes' : '❌ No'}`);
+        if (result.classification) {
+            console.log(`Classification: ${result.classification}`);
+        }
+        if (result.passed !== undefined) {
+            console.log(`Passed:       ${result.passed ? '✅ Yes' : '❌ No'}`);
+        }
+        if (result.resultHash) {
+            console.log(`Result Hash:  ${result.resultHash.substring(0, 32)}...`);
+        }
+        if (result.calculatedAt) {
+            console.log(`Calculated:   ${new Date(result.calculatedAt).toLocaleString()}`);
+        }
+        if (result.message) {
+            console.log(`\nMessage: ${result.message}`);
+        }
+        console.log('='.repeat(60) + '\n');
+        process.exit(result.verified ? 0 : 1);
+    }
+    catch (error) {
+        console.error(`❌ Network error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        process.exit(1);
+    }
+}
+/**
+ * Main CLI function
+ */
+async function main() {
+    const args = process.argv.slice(2);
+    // Handle flags
+    if (args.includes('--version') || args.includes('-v')) {
+        console.log(`aiassess v${VERSION}`);
+        return;
+    }
+    if (args.includes('--help') || args.includes('-h') || args.length === 0) {
+        printHelp();
+        return;
+    }
+    // Parse base URL option
+    let baseUrl = 'https://www.aiassesstech.com';
+    const baseUrlIndex = args.indexOf('--base-url');
+    if (baseUrlIndex !== -1 && args[baseUrlIndex + 1]) {
+        baseUrl = args[baseUrlIndex + 1];
+        args.splice(baseUrlIndex, 2);
+    }
+    // Handle commands
+    const command = args[0];
+    switch (command) {
+        case 'help':
+            printHelp();
+            break;
+        case 'info':
+            printInfo();
+            break;
+        case 'verify':
+            const runId = args[1];
+            if (!runId) {
+                console.error('❌ Error: Run ID is required for verify command');
+                console.log('Usage: aiassess verify <runId>');
+                process.exit(1);
+            }
+            await verify(runId, baseUrl);
+            break;
+        default:
+            console.error(`❌ Unknown command: ${command}`);
+            printHelp();
+            process.exit(1);
+    }
+}
+// Run CLI
+main().catch((error) => {
+    console.error(`❌ Error: ${error.message}`);
+    process.exit(1);
+});

package/dist/client.d.ts

@@ -0,0 +1,146 @@
+/**
+ * AI Assess Tech SDK - Main Client
+ *
+ * TypeScript SDK for assessing AI systems for ethical alignment.
+ * The AI interaction happens entirely within the developer's environment.
+ * Configuration is server-controlled via the Health Check Key.
+ *
+ * @version 0.7.0
+ */
+import { ClientConfig, AICallback, AssessOptions, BlockUntilPassOptions, AssessmentResult, AssessmentArray } from "./types";
+/**
+ * Main SDK client for AI ethical assessment
+ *
+ * @example
+ * ```typescript
+ * import { AIAssessClient } from '@aiassesstech/sdk';
+ *
+ * const client = new AIAssessClient({
+ *   healthCheckKey: process.env.AIASSESS_KEY!
+ * });
+ *
+ * // Run assessment - configuration comes from server
+ * const result = await client.assess(async (question) => {
+ *   return await myAI.chat(question);
+ * });
+ *
+ * console.log('Passed:', result.overallPassed);
+ * console.log('Scores:', result.scores);
+ * ```
+ */
+export declare class AIAssessClient {
+    private readonly healthCheckKey;
+    private readonly baseUrl;
+    private readonly perQuestionTimeoutMs;
+    private readonly overallTimeoutMs;
+    private cachedConfig;
+    /**
+     * Create a new AI Assess client
+     *
+     * @param config - Client configuration
+     */
+    constructor(config: ClientConfig);
+    /**
+     * Fetch configuration from server (cached for session)
+     * Configuration is determined by the Health Check Key
+     */
+    private getConfig;
+    /**
+     * Assess an AI implementation for ethical alignment
+     *
+     * Configuration (thresholds, questions) comes from server
+     * based on the Health Check Key.
+     *
+     * v0.7.0: Runs in ISOLATED mode only (each question independent)
+     *
+     * @param aiCallback - Function that sends a question to your AI and returns the response
+     * @param options - Assessment options
+     * @returns Assessment result with scores and pass/fail status
+     *
+     * @example
+     * ```typescript
+     * const result = await client.assess(async (question) => {
+     *   const response = await openai.chat.completions.create({
+     *     model: 'gpt-4',
+     *     messages: [{ role: 'user', content: question }]
+     *   });
+     *   return response.choices[0].message.content || '';
+     * });
+     * ```
+     */
+    assess(aiCallback: AICallback, options?: AssessOptions): Promise<AssessmentResult>;
+    /**
+     * Block until assessment passes (for startup health checks)
+     *
+     * @param aiCallback - Function that sends a question to your AI
+     * @param options - Block options including retry settings
+     * @returns Assessment result (only returns if passed)
+     *
+     * @example
+     * ```typescript
+     * // Block until AI passes - exits process on failure
+     * await client.blockUntilPass(
+     *   async (question) => await myAI.chat(question),
+     *   {
+     *     maxRetries: 3,
+     *     exitOnFailure: true
+     *   }
+     * );
+     *
+     * console.log('✅ AI passed, starting application...');
+     * startApp();
+     * ```
+     */
+    blockUntilPass(aiCallback: AICallback, options?: BlockUntilPassOptions): Promise<AssessmentResult>;
+    /**
+     * Convenience method: Returns assessment as flat array
+     *
+     * @param aiCallback - Function that sends a question to your AI
+     * @param options - Assessment options
+     * @returns Array of [lyingScore, cheatingScore, stealingScore, harmScore, lyingPassed, cheatingPassed, stealingPassed, harmPassed]
+     */
+    assessArray(aiCallback: AICallback, options?: AssessOptions): Promise<AssessmentArray>;
+    /**
+     * Format a question for the AI (multiple choice format)
+     */
+    private formatQuestion;
+    /**
+     * Extract answer letter from AI response (robust extraction)
+     */
+    private extractAnswerLetter;
+    private mockDryRunResult;
+    private withTimeout;
+    private sleep;
+}
+/**
+ * Retry wrapper utility for developer's AI callback
+ * Wraps a callback with automatic retry logic with exponential backoff
+ *
+ * @param callback - The AI callback to wrap
+ * @param options - Retry options
+ * @returns Wrapped callback with retry logic
+ *
+ * @example
+ * ```typescript
+ * const result = await client.assess(
+ *   withRetry(async (question) => await flakyAI.chat(question), {
+ *     maxRetries: 3,
+ *     backoffMs: 1000
+ *   })
+ * );
+ * ```
+ */
+export declare function withRetry(callback: AICallback, options?: {
+    maxRetries?: number;
+    backoffMs?: number;
+}): AICallback;
+/**
+ * @deprecated Use AIAssessClient instead
+ */
+export declare class HealthCheckClient extends AIAssessClient {
+    constructor(config: {
+        apiKey: string;
+        baseUrl?: string;
+        timeout?: number;
+    });
+}