roe-typescript 0.1.0

package/dist/integration_test.js

@@ -0,0 +1,686 @@
+#!/usr/bin/env npx ts-node
+"use strict";
+/**
+ * Comprehensive integration tests for the Roe TypeScript SDK.
+ * Tests identical scenarios to Go and Python SDKs for cross-SDK parity verification.
+ *
+ * Run with: npx ts-node integration_test.ts
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const https = __importStar(require("https"));
+const http = __importStar(require("http"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const client_1 = require("./src/client");
+const config_1 = require("./src/config");
+const file_1 = require("./src/models/file");
+// Helper to get timeout in seconds from config
+const getTimeoutSeconds = (config) => config.timeoutMs / 1000;
+// Test configuration
+const TEST_CONFIG = {
+    apiKey: "7jmZWLJO.QvCXpF1v7IhXebQw4TLoW5YFtG89jDJo",
+    organizationId: "abfad6df-ee35-4ab0-81ab-89214e9ed900",
+    baseUrl: "https://api.test.roe-ai.com",
+    samplePdfs: [
+        "https://www.uscis.gov/sites/default/files/document/forms/i-9.pdf",
+        "https://arxiv.org/pdf/2512.09941",
+        "https://arxiv.org/pdf/2512.09933",
+        "https://arxiv.org/pdf/2512.09956",
+    ],
+    sampleUrl: "https://www.roe-ai.com/",
+};
+class TestResults {
+    constructor() {
+        this.results = {};
+        this.errors = [];
+    }
+    record(testName, result) {
+        this.results[testName] = result;
+        console.log(`  [PASS] ${testName}`);
+    }
+    recordError(testName, error) {
+        this.errors.push([testName, error.message]);
+        console.log(`  [FAIL] ${testName}: ${error.message}`);
+    }
+    toJson() {
+        return JSON.stringify({
+            results: this.results,
+            errors: this.errors,
+            passed: Object.keys(this.results).length,
+            failed: this.errors.length,
+        }, null, 2);
+    }
+}
+/**
+ * Download a PDF from URL to a temp file.
+ */
+async function downloadPdf(url, filename) {
+    return new Promise((resolve, reject) => {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "roe-test-"));
+        const filepath = path.join(tempDir, filename);
+        console.log(`    Downloading ${url}...`);
+        const protocol = url.startsWith("https") ? https : http;
+        const file = fs.createWriteStream(filepath);
+        const request = protocol.get(url, (response) => {
+            // Handle redirects
+            if (response.statusCode === 301 || response.statusCode === 302) {
+                const redirectUrl = response.headers.location;
+                if (redirectUrl) {
+                    file.close();
+                    fs.unlinkSync(filepath);
+                    fs.rmdirSync(tempDir);
+                    downloadPdf(redirectUrl, filename).then(resolve).catch(reject);
+                    return;
+                }
+            }
+            response.pipe(file);
+            file.on("finish", () => {
+                file.close();
+                resolve(filepath);
+            });
+        });
+        request.on("error", (err) => {
+            fs.unlink(filepath, () => { });
+            reject(err);
+        });
+    });
+}
+/**
+ * Cleanup temp file and directory.
+ */
+function cleanupFile(filepath) {
+    try {
+        fs.unlinkSync(filepath);
+        fs.rmdirSync(path.dirname(filepath));
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+}
+/**
+ * Test configuration edge cases - falsy values like timeout=0.
+ */
+function testConfigEdgeCases() {
+    console.log("\n=== Testing Config Edge Cases ===");
+    const results = new TestResults();
+    // Test 1: timeout=0 should work (not fall back to default)
+    try {
+        const config = config_1.RoeConfig.fromEnv({
+            apiKey: TEST_CONFIG.apiKey,
+            organizationId: TEST_CONFIG.organizationId,
+            baseUrl: TEST_CONFIG.baseUrl,
+            timeoutSeconds: 0,
+            maxRetries: 0,
+        });
+        // Verify values are actually 0, not defaults
+        if (getTimeoutSeconds(config) !== 0) {
+            throw new Error(`Expected timeout=0, got ${getTimeoutSeconds(config)}`);
+        }
+        if (config.maxRetries !== 0) {
+            throw new Error(`Expected maxRetries=0, got ${config.maxRetries}`);
+        }
+        results.record("config_falsy_timeout", {
+            timeout: getTimeoutSeconds(config),
+            maxRetries: config.maxRetries,
+        });
+    }
+    catch (e) {
+        results.recordError("config_falsy_timeout", e);
+    }
+    // Test 2: Normal config creation
+    try {
+        const config = config_1.RoeConfig.fromEnv({
+            apiKey: TEST_CONFIG.apiKey,
+            organizationId: TEST_CONFIG.organizationId,
+            baseUrl: TEST_CONFIG.baseUrl,
+        });
+        if (getTimeoutSeconds(config) !== 60) {
+            throw new Error(`Expected default timeout=60, got ${getTimeoutSeconds(config)}`);
+        }
+        if (config.maxRetries !== 3) {
+            throw new Error(`Expected default maxRetries=3, got ${config.maxRetries}`);
+        }
+        results.record("config_defaults", {
+            timeout: getTimeoutSeconds(config),
+            maxRetries: config.maxRetries,
+        });
+    }
+    catch (e) {
+        results.recordError("config_defaults", e);
+    }
+    return results;
+}
+/**
+ * Test FileUpload from URL functionality.
+ */
+async function testFileUploadFromUrl() {
+    console.log("\n=== Testing FileUpload from URL ===");
+    const results = new TestResults();
+    try {
+        const pdfPath = await downloadPdf(TEST_CONFIG.samplePdfs[1], "test_upload.pdf");
+        // Test FileUpload with file path
+        const upload = new file_1.FileUpload({ path: pdfPath });
+        if (upload.effectiveFilename !== "test_upload.pdf") {
+            throw new Error(`Expected filename 'test_upload.pdf', got '${upload.effectiveFilename}'`);
+        }
+        if (upload.effectiveMimeType !== "application/pdf") {
+            throw new Error(`Expected mimeType 'application/pdf', got '${upload.effectiveMimeType}'`);
+        }
+        results.record("file_upload_from_path", {
+            filename: upload.effectiveFilename,
+            mimeType: upload.effectiveMimeType,
+        });
+        cleanupFile(pdfPath);
+    }
+    catch (e) {
+        results.recordError("file_upload_from_path", e);
+    }
+    return results;
+}
+/**
+ * Test Document Insights (PDF Extraction) agent.
+ */
+async function testDocInsightsAgent(client) {
+    console.log("\n=== Testing Doc Insights Agent ===");
+    const results = new TestResults();
+    try {
+        // Create a Doc Insights agent
+        const agent = await client.agents.create({
+            name: "TypeScript SDK Test - Doc Insights",
+            engineClassId: "PDFExtractionEngine",
+            inputDefinitions: [
+                { key: "pdf_files", data_type: "application/pdf", description: "PDF document to analyze" },
+            ],
+            engineConfig: {
+                model: "gpt-4.1-2025-04-14",
+                pdf_files: "${pdf_files}",
+                instructions: "Extract the document title and list the main sections.",
+                output_schema: {
+                    type: "object",
+                    properties: {
+                        title: { type: "string", description: "Document title" },
+                        sections: { type: "array", items: { type: "string" }, description: "Main sections" },
+                    },
+                },
+            },
+        });
+        results.record("create_doc_insights_agent", { agent_id: agent.id, name: agent.name });
+        // Download and run with a PDF
+        const pdfPath = await downloadPdf(TEST_CONFIG.samplePdfs[0], "i9_form.pdf");
+        try {
+            // Run async job
+            const job = await client.agents.run({
+                agentId: agent.id,
+                inputs: { pdf_files: new file_1.FileUpload({ path: pdfPath }) },
+            });
+            results.record("submit_doc_insights_job", { job_id: job.id });
+            // Wait for result
+            const result = await job.wait({ timeoutSeconds: 300 });
+            results.record("doc_insights_result", {
+                agent_id: result.agent_id,
+                outputs_count: result.outputs.length,
+                has_output: result.outputs.length > 0,
+            });
+            // Parse and verify output
+            if (result.outputs.length > 0) {
+                const outputValue = result.outputs[0].value;
+                try {
+                    const parsed = JSON.parse(outputValue);
+                    results.record("doc_insights_parsed", {
+                        has_title: "title" in parsed,
+                        has_sections: "sections" in parsed,
+                    });
+                }
+                catch {
+                    results.record("doc_insights_parsed", { raw_output: outputValue.substring(0, 200) });
+                }
+            }
+        }
+        finally {
+            cleanupFile(pdfPath);
+        }
+        // Cleanup: delete the agent
+        await client.agents.delete(agent.id);
+        results.record("delete_doc_insights_agent", { deleted: true });
+    }
+    catch (e) {
+        results.recordError("doc_insights_agent", e);
+    }
+    return results;
+}
+/**
+ * Test Web Insights (URL Website Extraction) agent.
+ */
+async function testWebInsightsAgent(client) {
+    console.log("\n=== Testing Web Insights Agent ===");
+    const results = new TestResults();
+    try {
+        // Create a Web Insights agent
+        const agent = await client.agents.create({
+            name: "TypeScript SDK Test - Web Insights",
+            engineClassId: "URLWebsiteExtractionEngine",
+            inputDefinitions: [
+                { key: "url", data_type: "text/plain", description: "Website URL to analyze" },
+            ],
+            engineConfig: {
+                url: "${url}",
+                model: "gpt-4.1-2025-04-14",
+                instruction: "Extract the company name and a brief description from this website.",
+                vision_mode: false,
+                crawl_config: {
+                    save_html: true,
+                    save_markdown: true,
+                },
+                output_schema: {
+                    type: "object",
+                    properties: {
+                        company_name: { type: "string", description: "Company name" },
+                        description: { type: "string", description: "Brief company description" },
+                    },
+                },
+            },
+        });
+        results.record("create_web_insights_agent", { agent_id: agent.id, name: agent.name });
+        // Run with URL
+        const job = await client.agents.run({
+            agentId: agent.id,
+            inputs: { url: TEST_CONFIG.sampleUrl },
+        });
+        results.record("submit_web_insights_job", { job_id: job.id });
+        // Wait for result
+        const result = await job.wait({ timeoutSeconds: 300 });
+        results.record("web_insights_result", {
+            agent_id: result.agent_id,
+            outputs_count: result.outputs.length,
+            has_output: result.outputs.length > 0,
+        });
+        // Parse and verify output
+        if (result.outputs.length > 0) {
+            const outputValue = result.outputs[0].value;
+            try {
+                const parsed = JSON.parse(outputValue);
+                results.record("web_insights_parsed", {
+                    has_company_name: "company_name" in parsed,
+                    has_description: "description" in parsed,
+                    company_name: parsed.company_name ?? "N/A",
+                });
+            }
+            catch {
+                results.record("web_insights_parsed", { raw_output: outputValue.substring(0, 200) });
+            }
+        }
+        // Cleanup
+        await client.agents.delete(agent.id);
+        results.record("delete_web_insights_agent", { deleted: true });
+    }
+    catch (e) {
+        results.recordError("web_insights_agent", e);
+    }
+    return results;
+}
+/**
+ * Test batch job operations with multiple inputs.
+ */
+async function testBatchOperations(client) {
+    console.log("\n=== Testing Batch Operations ===");
+    const results = new TestResults();
+    try {
+        // Create a simple text extraction agent for batch testing
+        const agent = await client.agents.create({
+            name: "TypeScript SDK Test - Batch",
+            engineClassId: "MultimodalExtractionEngine",
+            inputDefinitions: [
+                { key: "text", data_type: "text/plain", description: "Text to analyze" },
+            ],
+            engineConfig: {
+                model: "gpt-4.1-2025-04-14",
+                text: "${text}",
+                instruction: "Count the number of words in this text.",
+                output_schema: {
+                    type: "object",
+                    properties: {
+                        word_count: { type: "integer", description: "Number of words" },
+                    },
+                },
+            },
+        });
+        results.record("create_batch_agent", { agent_id: agent.id });
+        // Run batch with multiple inputs
+        const batchInputs = [
+            { text: "Hello world" },
+            { text: "This is a longer sentence with more words" },
+            { text: "One" },
+        ];
+        const batch = await client.agents.runMany({
+            agentId: agent.id,
+            batchInputs,
+        });
+        results.record("submit_batch_jobs", { job_count: batch.jobs.length });
+        // Wait for all results
+        const batchResults = await batch.wait({ timeoutSeconds: 300 });
+        results.record("batch_results", {
+            results_count: batchResults.length,
+            all_have_outputs: batchResults.every((r) => r.outputs.length > 0),
+        });
+        // Cleanup
+        await client.agents.delete(agent.id);
+        results.record("delete_batch_agent", { deleted: true });
+    }
+    catch (e) {
+        results.recordError("batch_operations", e);
+    }
+    return results;
+}
+/**
+ * Test synchronous job execution.
+ */
+async function testSyncExecution(client) {
+    console.log("\n=== Testing Sync Execution ===");
+    const results = new TestResults();
+    try {
+        // Create agent
+        const agent = await client.agents.create({
+            name: "TypeScript SDK Test - Sync",
+            engineClassId: "MultimodalExtractionEngine",
+            inputDefinitions: [
+                { key: "text", data_type: "text/plain", description: "Text input" },
+            ],
+            engineConfig: {
+                model: "gpt-4.1-2025-04-14",
+                text: "${text}",
+                instruction: "Echo back the input text.",
+                output_schema: {
+                    type: "object",
+                    properties: {
+                        echo: { type: "string" },
+                    },
+                },
+            },
+        });
+        results.record("create_sync_agent", { agent_id: agent.id });
+        // Run synchronously
+        const outputs = await client.agents.runSync(agent.id, { text: "Test input for sync" });
+        results.record("sync_execution", {
+            outputs_count: outputs.length,
+            has_output: outputs.length > 0,
+        });
+        // Cleanup
+        await client.agents.delete(agent.id);
+        results.record("delete_sync_agent", { deleted: true });
+    }
+    catch (e) {
+        results.recordError("sync_execution", e);
+    }
+    return results;
+}
+/**
+ * Test agent version management.
+ */
+async function testVersionManagement(client) {
+    console.log("\n=== Testing Version Management ===");
+    const results = new TestResults();
+    try {
+        // Create agent
+        const agent = await client.agents.create({
+            name: "TypeScript SDK Test - Versions",
+            engineClassId: "MultimodalExtractionEngine",
+            inputDefinitions: [
+                { key: "text", data_type: "text/plain", description: "Text" },
+            ],
+            engineConfig: {
+                model: "gpt-4.1-2025-04-14",
+                text: "${text}",
+                instruction: "Version 1 instruction",
+                output_schema: { type: "object", properties: { result: { type: "string" } } },
+            },
+            versionName: "v1",
+        });
+        results.record("create_versioned_agent", { agent_id: agent.id });
+        // List versions
+        const versions = await client.agents.versions.list(agent.id);
+        results.record("list_versions", { version_count: versions.length });
+        // Get current version
+        const current = await client.agents.versions.retrieveCurrent(agent.id);
+        results.record("current_version", { version_id: current.id, version_name: current.version_name });
+        // Create new version
+        const v2 = await client.agents.versions.create({
+            agentId: agent.id,
+            versionName: "v2",
+            engineConfig: {
+                model: "gpt-4.1-2025-04-14",
+                text: "${text}",
+                instruction: "Version 2 instruction - updated",
+                output_schema: { type: "object", properties: { result: { type: "string" } } },
+            },
+        });
+        results.record("create_version_v2", { version_id: v2.id, version_name: v2.version_name });
+        // Run specific version
+        const job = await client.agents.runVersion({
+            agentId: agent.id,
+            versionId: v2.id,
+            inputs: { text: "Test" },
+        });
+        const versionResult = await job.wait({ timeoutSeconds: 120 });
+        results.record("run_specific_version", {
+            job_id: job.id,
+            has_output: versionResult.outputs.length > 0,
+        });
+        // Cleanup
+        await client.agents.delete(agent.id);
+        results.record("delete_versioned_agent", { deleted: true });
+    }
+    catch (e) {
+        results.recordError("version_management", e);
+    }
+    return results;
+}
+/**
+ * Test job status and result retrieval.
+ */
+async function testJobManagement(client) {
+    console.log("\n=== Testing Job Management ===");
+    const results = new TestResults();
+    try {
+        // Create agent
+        const agent = await client.agents.create({
+            name: "TypeScript SDK Test - Jobs",
+            engineClassId: "MultimodalExtractionEngine",
+            inputDefinitions: [
+                { key: "text", data_type: "text/plain", description: "Text" },
+            ],
+            engineConfig: {
+                model: "gpt-4.1-2025-04-14",
+                text: "${text}",
+                instruction: "Analyze this text.",
+                output_schema: { type: "object", properties: { analysis: { type: "string" } } },
+            },
+        });
+        // Submit job
+        const job = await client.agents.run({
+            agentId: agent.id,
+            inputs: { text: "Test for job management" },
+        });
+        results.record("submit_job", { job_id: job.id });
+        // Check status
+        const status = await client.agents.jobs.retrieveStatus(job.id);
+        results.record("job_status", { status: status.status });
+        // Wait and get result
+        const result = await job.wait({ timeoutSeconds: 120 });
+        results.record("job_result", {
+            agent_id: result.agent_id,
+            has_outputs: result.outputs.length > 0,
+        });
+        // Retrieve result separately
+        const retrievedResult = await client.agents.jobs.retrieveResult(job.id);
+        results.record("retrieved_result", {
+            matches: retrievedResult.agent_id === result.agent_id,
+        });
+        // Cleanup
+        await client.agents.delete(agent.id);
+    }
+    catch (e) {
+        results.recordError("job_management", e);
+    }
+    return results;
+}
+/**
+ * Test uploading multiple different PDFs.
+ */
+async function testMultiplePdfUploads(client) {
+    console.log("\n=== Testing Multiple PDF Uploads ===");
+    const results = new TestResults();
+    try {
+        // Create agent
+        const agent = await client.agents.create({
+            name: "TypeScript SDK Test - Multi PDF",
+            engineClassId: "PDFExtractionEngine",
+            inputDefinitions: [
+                { key: "pdf_files", data_type: "application/pdf", description: "PDF" },
+            ],
+            engineConfig: {
+                model: "gpt-4.1-2025-04-14",
+                pdf_files: "${pdf_files}",
+                instructions: "What is the title or main topic of this document?",
+                output_schema: {
+                    type: "object",
+                    properties: {
+                        title: { type: "string" },
+                    },
+                },
+            },
+        });
+        results.record("create_multi_pdf_agent", { agent_id: agent.id });
+        // Test with multiple PDFs (arxiv papers)
+        const pdfUrls = TEST_CONFIG.samplePdfs.slice(1, 4);
+        for (let i = 0; i < pdfUrls.length; i++) {
+            const pdfUrl = pdfUrls[i];
+            const pdfPath = await downloadPdf(pdfUrl, `arxiv_${i}.pdf`);
+            try {
+                const job = await client.agents.run({
+                    agentId: agent.id,
+                    inputs: { pdf_files: new file_1.FileUpload({ path: pdfPath }) },
+                });
+                const pdfResult = await job.wait({ timeoutSeconds: 300 });
+                results.record(`pdf_upload_${i}`, {
+                    url: pdfUrl,
+                    job_id: job.id,
+                    has_output: pdfResult.outputs.length > 0,
+                });
+            }
+            finally {
+                cleanupFile(pdfPath);
+            }
+        }
+        // Cleanup
+        await client.agents.delete(agent.id);
+        results.record("delete_multi_pdf_agent", { deleted: true });
+    }
+    catch (e) {
+        results.recordError("multiple_pdf_uploads", e);
+    }
+    return results;
+}
+/**
+ * Main test runner.
+ */
+async function main() {
+    console.log("=".repeat(60));
+    console.log("ROE TYPESCRIPT SDK INTEGRATION TESTS");
+    console.log("=".repeat(60));
+    console.log(`Base URL: ${TEST_CONFIG.baseUrl}`);
+    console.log(`Organization ID: ${TEST_CONFIG.organizationId}`);
+    // Create client
+    const client = new client_1.RoeClient({
+        apiKey: TEST_CONFIG.apiKey,
+        organizationId: TEST_CONFIG.organizationId,
+        baseUrl: TEST_CONFIG.baseUrl,
+    });
+    const allResults = {};
+    // Run all test suites
+    const testSuites = [
+        ["config_edge_cases", () => testConfigEdgeCases()],
+        ["file_upload_from_url", () => testFileUploadFromUrl()],
+        ["doc_insights_agent", () => testDocInsightsAgent(client)],
+        ["web_insights_agent", () => testWebInsightsAgent(client)],
+        ["batch_operations", () => testBatchOperations(client)],
+        ["sync_execution", () => testSyncExecution(client)],
+        ["version_management", () => testVersionManagement(client)],
+        ["job_management", () => testJobManagement(client)],
+        ["multiple_pdf_uploads", () => testMultiplePdfUploads(client)],
+    ];
+    for (const [suiteName, testFunc] of testSuites) {
+        try {
+            const result = await testFunc();
+            allResults[suiteName] = result.results;
+            if (result.errors.length > 0) {
+                allResults[`${suiteName}_errors`] = result.errors;
+            }
+        }
+        catch (e) {
+            allResults[suiteName] = { error: e.message };
+            console.log(`  [FATAL] ${suiteName}: ${e.message}`);
+        }
+    }
+    // Summary
+    console.log("\n" + "=".repeat(60));
+    console.log("TEST SUMMARY");
+    console.log("=".repeat(60));
+    let totalPassed = 0;
+    let totalFailed = 0;
+    for (const [key, value] of Object.entries(allResults)) {
+        if (!key.endsWith("_errors") && typeof value === "object" && value !== null) {
+            totalPassed += Object.keys(value).length;
+        }
+        if (key.endsWith("_errors") && Array.isArray(value)) {
+            totalFailed += value.length;
+        }
+    }
+    console.log(`Total passed: ${totalPassed}`);
+    console.log(`Total failed: ${totalFailed}`);
+    // Save results for comparison
+    const outputFile = "typescript_test_results.json";
+    fs.writeFileSync(outputFile, JSON.stringify(allResults, null, 2));
+    console.log(`\nResults saved to: ${outputFile}`);
+    return totalFailed === 0 ? 0 : 1;
+}
+// Run main
+main()
+    .then((code) => process.exit(code))
+    .catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});