@juggernautlabs/cloud 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Juggernaut Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/build/CloudDatabaseManager.d.ts

@@ -0,0 +1,15 @@
+export declare class DatabaseSchema {
+    schemaId: string;
+    name?: string;
+    constructor(schemaId: string, name?: string);
+    getRecord(id: string): Record<string, any>;
+    query(queryString: string, parameters?: Record<string, any>): Promise<any>;
+    insert(record: Record<string, any>): Promise<any>;
+    insertMany(data: Record<string, any>[]): Promise<any>;
+    update(id: string, data: Record<string, any>): Promise<any>;
+    updateMany(query: Record<string, any>, data: Record<string, any>): Promise<any>;
+    delete(id: string): Promise<any>;
+    bulkDelete(query: string): Promise<any>;
+    count(query: string): Promise<any>;
+    exists(query: string): Promise<any>;
+}

package/build/CloudDatabaseManager.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseSchema = void 0;
+const CloudResourceAPI_1 = __importDefault(require("./CloudResourceAPI"));
+class CloudDatabaseManager {
+    static async handleDatabaseOperation(schema, operation, data = {}) {
+        if (!schema) {
+            throw new Error('Schema or database connection is not provided');
+        }
+        const request = {
+            schema: schema,
+            data
+        };
+        return CloudResourceAPI_1.default.executeDatabaseOperation(operation, request);
+    }
+}
+class DatabaseSchema {
+    constructor(schemaId, name) {
+        this.schemaId = schemaId;
+        this.name = name;
+    }
+    getRecord(id) {
+        if (!id) {
+            throw new Error('Record ID is required to fetch a record.');
+        }
+        return CloudDatabaseManager.handleDatabaseOperation(this.schemaId, 'record', {
+            id
+        });
+    }
+    query(queryString, parameters) {
+        if (!queryString) {
+            throw new Error('Query string is required to perform a query.');
+        }
+        return CloudDatabaseManager.handleDatabaseOperation(this.schemaId, 'query', {
+            query: queryString
+        });
+    }
+    insert(record) {
+        if (!record || typeof record !== 'object') {
+            throw new Error('Valid record data is required to insert a record.');
+        }
+        return CloudDatabaseManager.handleDatabaseOperation(this.schemaId, 'insert', record);
+    }
+    insertMany(data) {
+        if (!Array.isArray(data) || data.length === 0) {
+            throw new Error('An array of record data is required to insert multiple records.');
+        }
+        return CloudDatabaseManager.handleDatabaseOperation(this.schemaId, 'bulk:insert', {
+            data
+        });
+    }
+    update(id, data) {
+        if (!id) {
+            throw new Error('Record ID is required to update a record.');
+        }
+        if (!data || typeof data !== 'object') {
+            throw new Error('Valid record data is required to update a record.');
+        }
+        return CloudDatabaseManager.handleDatabaseOperation(this.schemaId, 'update', {
+            id,
+            data
+        });
+    }
+    updateMany(query, data) {
+        if (!query || typeof query !== 'object') {
+            throw new Error('Valid query object is required to bulk update records.');
+        }
+        if (!data || typeof data !== 'object') {
+            throw new Error('Valid record data is required to bulk update records.');
+        }
+        return CloudDatabaseManager.handleDatabaseOperation(this.schemaId, 'bulk:update', {
+            query,
+            data
+        });
+    }
+    delete(id) {
+        if (!id) {
+            throw new Error('Record ID is required to delete a record.');
+        }
+        return CloudDatabaseManager.handleDatabaseOperation(this.schemaId, 'delete', {
+            id
+        });
+    }
+    bulkDelete(query) {
+        if (!query) {
+            throw new Error('Query string is required to bulk delete records.');
+        }
+        return CloudDatabaseManager.handleDatabaseOperation(this.schemaId, 'bulk:delete', {
+            query
+        });
+    }
+    count(query) {
+        if (!query) {
+            throw new Error('Query string is required to count records.');
+        }
+        return CloudDatabaseManager.handleDatabaseOperation(this.schemaId, 'count', {
+            query
+        });
+    }
+    exists(query) {
+        if (!query) {
+            throw new Error('Query string is required to check existence of records.');
+        }
+        return CloudDatabaseManager.handleDatabaseOperation(this.schemaId, 'exists', {
+            query
+        });
+    }
+}
+exports.DatabaseSchema = DatabaseSchema;

package/build/CloudResourceAPI.d.ts

@@ -0,0 +1,22 @@
+declare const AuthKey: unique symbol;
+export default class CloudResourceManager {
+    static [AuthKey]: {};
+    static init(client: string, secret: string): void;
+    static uploadProcess(processJSON: Record<string, any>): Promise<any>;
+    static executePlugin(pluginId: string, command: string, scope: string, pluginArguments: Record<string, any>): Promise<void>;
+    static runProcess(processId: string, inputs: Record<string, any>, metadata: Record<string, any>): Promise<any>;
+    static runProcessViaAccessPoint(processId: string, inputs: Record<string, any>, accessPoint: string, metadata: Record<string, any>): Promise<any>;
+    static scheduleProcess(processId: string, schedule: Record<string, any>): Promise<any>;
+    static getPromptContent(promptId: string): Promise<any>;
+    static getReport(reportId: string): Promise<any>;
+    static createReport(schemaId: string, reportData: Record<string, any>): Promise<any>;
+    static getProcessJobEvents(referenceId: string): Promise<any>;
+    static getProcessJobEventsViaAccessPoint(referenceId: string, accessPoint: string): Promise<any>;
+    static getProcessJobResults(jobId: string): Promise<any>;
+    static getProcessJobResultsViaAccessPoint(jobId: string, accessPoint: string): Promise<any>;
+    static getJobIdByReferenceId(referenceId: string): Promise<any>;
+    static getJobResultsByReferenceId(referenceId: string): Promise<any>;
+    static executeDatabaseOperation(operation: string, request: Record<string, any>): Promise<any>;
+    static getJobFile(jobId: string, fileType: string, fileId: string): Promise<ReadableStream<Uint8Array<ArrayBuffer>>>;
+}
+export {};

package/build/CloudResourceAPI.js

@@ -0,0 +1,357 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const CloudRoutes = {
+    process: {
+        upload: '/api/resource/process/upload',
+        run: '/api/resource/process/{{id}}/run',
+        runViaAccessPoint: '/api/resource/process/public/{{id}}/run', // Handled differently
+        events: '/api/resource/process/events/{{referenceId}}',
+        eventsViaAccessPoint: '/api/resource/process/public/events/{{referenceId}}',
+        schedule: '/api/resource/process/{{id}}/schedule/create',
+        deleteSchedule: '/api/resource/process/{{id}}/schedule/delete',
+    },
+    job: {
+        results: '/api/resource/job/{{id}}/results',
+        resultsViaAccessPoint: '/api/resource/job/public/{{id}}/results',
+        file: '/api/resource/job/{{id}}/file/{{fileType}}/{{fileId}}',
+        getJobIdByReferenceId: '/api/resource/job/reference/{{referenceId}}/id',
+    },
+    plugin: {
+        content: '/api/resource/plugin/{{id}}/content',
+    },
+    prompt: {
+        upload: '/api/resource/prompt/upload',
+        getContent: '/api/resource/prompt/{{id}}/content',
+        list: '/api/resource/prompt/list',
+        delete: '/api/resource/prompt/delete',
+    },
+    integrations: {
+        webSearch: '/api/integrations/web/search',
+        webScrape: '/api/integrations/web/scrape',
+        database: '/api/integrations/database',
+    },
+    reporting: {
+        getReport: '/api/resource/schema/report/{{id}}',
+        createReport: '/api/resource/schema/report/{{schemaId}}',
+    }
+};
+const BasePath = 'https://core.juggernautlabs.ai';
+const buildPath = (route, variables) => {
+    if (route.includes('{{') && route.includes('}}') && variables !== undefined) {
+        let formattedRoute = route;
+        for (const key in variables) {
+            formattedRoute = formattedRoute.replace(`{{${key}}}`, variables[key]);
+        }
+        return `${BasePath}${formattedRoute}`;
+    }
+    return `${BasePath}${route}`;
+};
+const handleResponse = async (response) => {
+    if (!response.ok) {
+        const errorContent = await response.text();
+        console.error('Error Response Content:', errorContent);
+        //Error for USER to see
+        const error = new Error(`Juggernaut SDK Error: ${response.status} ${response.statusText}`);
+        throw error;
+    }
+    return response.json();
+};
+const AuthKey = Symbol('AuthKey');
+class CloudResourceManager {
+    static init(client, secret) {
+        if (secret && client) {
+            this[AuthKey] = {
+                'authorization': `Bearer ${secret}`,
+                'client-key': client
+            };
+        }
+        else {
+            console.warn('CloudResourceManager initialization missing client or secret key.');
+        }
+        if (Object.keys(this[AuthKey]).length === 0) {
+            console.warn('No cloud authentication provided, some features may not work as expected.');
+        }
+    }
+    static async uploadProcess(processJSON) {
+        const response = await fetch(buildPath(CloudRoutes.process.upload), {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...this[AuthKey]
+            },
+            body: JSON.stringify(processJSON)
+        });
+        return handleResponse(response);
+    }
+    static async executePlugin(pluginId, command, scope, pluginArguments) {
+        // const response = await fetch(buildPath(
+        //     CloudRoutes.plugin.execute,
+        //     {id: pluginId}
+        // ), {
+        //     method: 'POST',
+        //     headers: {
+        //         'Content-Type': 'application/json',
+        //...this[AuthKey]
+        //     },
+        //     body: JSON.stringify({command, data: pluginArguments, scope})
+        // });
+        // const { data, message, status } = await response.json();
+        // console.log('Plugin Results:', data);
+        // return data;
+    }
+    static async runProcess(processId, inputs, metadata) {
+        try {
+            const response = await fetch(buildPath(CloudRoutes.process.run, { id: processId }), {
+                method: 'POST',
+                headers: {
+                    //'Content-Type': 'application/json',
+                    ...this[AuthKey]
+                },
+                body: JSON.stringify({ inputs, metadata })
+            });
+            if (!response.ok) {
+                const errorContent = await response.text();
+                console.error('Error Response Content:', errorContent);
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const { data, message, status } = await response.json();
+            return data;
+        }
+        catch (error) {
+            console.error('Error running process:', error);
+            throw error;
+        }
+    }
+    static async runProcessViaAccessPoint(processId, inputs, accessPoint, metadata) {
+        const response = await fetch(buildPath(CloudRoutes.process.runViaAccessPoint, { id: processId }), {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'access-point': accessPoint,
+                // No auth headers for public access point
+            },
+            body: JSON.stringify({ inputs, metadata })
+        });
+        if (!response.ok) {
+            const errorContent = await response.text();
+            console.error('Error Response Content:', errorContent);
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const { data, message, status } = await response.json();
+        return data;
+    }
+    static async scheduleProcess(processId, schedule) {
+        const response = await fetch(buildPath(CloudRoutes.process.schedule, { id: processId }), {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...this[AuthKey]
+            },
+            body: JSON.stringify({ schedule: schedule })
+        });
+        if (!response.ok) {
+            const errorContent = await response.text();
+            console.error('Error Response Content:', errorContent);
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const { data, message, status } = await response.json();
+        return data;
+    }
+    static async getPromptContent(promptId) {
+        try {
+            const response = await fetch(buildPath(CloudRoutes.prompt.getContent, { id: promptId }), {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...this[AuthKey]
+                },
+            });
+            if (!response.ok) {
+                const errorContent = await response.text();
+                console.error('Error Response Content:', errorContent);
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const { data, message, status } = await response.json();
+            return data;
+        }
+        catch (error) {
+            console.error('Error fetching prompt content:', error);
+        }
+    }
+    static async getReport(reportId) {
+        const response = await fetch(buildPath(CloudRoutes.reporting.getReport, { id: reportId }), {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                ...this[AuthKey]
+            },
+        });
+        const { data, message, status } = await response.json();
+        return data;
+    }
+    static async createReport(schemaId, reportData) {
+        const response = await fetch(buildPath(CloudRoutes.reporting.createReport, { schemaId }), {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...this[AuthKey]
+            },
+            body: JSON.stringify(reportData)
+        });
+        if (!response.ok) {
+            const errorContent = await response.text();
+            console.error('Error Response Content:', errorContent);
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const { data, message, status } = await response.json();
+        return data;
+    }
+    static async getProcessJobEvents(referenceId) {
+        const response = await fetch(buildPath(CloudRoutes.process.events, { referenceId }), {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                ...this[AuthKey]
+            },
+        });
+        if (!response.ok) {
+            const errorContent = await response.text();
+            console.error('Error Response Content:', errorContent);
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const { data, message, status } = await response.json();
+        return data;
+    }
+    static async getProcessJobEventsViaAccessPoint(referenceId, accessPoint) {
+        const response = await fetch(buildPath(CloudRoutes.process.eventsViaAccessPoint, { referenceId }), {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                'access-point': accessPoint,
+                // No auth headers for public access point
+            },
+        });
+        if (!response.ok) {
+            const errorContent = await response.text();
+            console.error('Error Response Content:', errorContent);
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const { data, message, status } = await response.json();
+        return data;
+    }
+    static async getProcessJobResults(jobId) {
+        try {
+            const response = await fetch(buildPath(CloudRoutes.job.results, { id: jobId }), {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...this[AuthKey]
+                },
+            });
+            if (!response.ok) {
+                const errorContent = await response.text();
+                console.error('Error Response Content:', errorContent);
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const { data, message, status } = await response.json();
+            return data;
+        }
+        catch (error) {
+            console.error('Error fetching job results:', error);
+            throw error;
+        }
+    }
+    static async getProcessJobResultsViaAccessPoint(jobId, accessPoint) {
+        const response = await fetch(buildPath(CloudRoutes.job.resultsViaAccessPoint, { id: jobId }), {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                'access-point': accessPoint,
+                // No auth headers for public access point
+            },
+        });
+        if (!response.ok) {
+            const errorContent = await response.text();
+            console.error('Error Response Content:', errorContent);
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const { data, message, status } = await response.json();
+        return data;
+    }
+    static async getJobIdByReferenceId(referenceId) {
+        const response = await fetch(buildPath(CloudRoutes.job.getJobIdByReferenceId, { referenceId }), {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                ...this[AuthKey]
+            },
+        });
+        if (!response.ok) {
+            const errorContent = await response.text();
+            console.error('Error Response Content:', errorContent);
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const { data, message, status } = await response.json();
+        return data;
+    }
+    static async getJobResultsByReferenceId(referenceId) {
+        try {
+            const jobIdData = await this.getJobIdByReferenceId(referenceId);
+            if (jobIdData && jobIdData.jobId) {
+                return this.getProcessJobResults(jobIdData.jobId);
+            }
+            else {
+                throw new Error('Job ID not found for the given reference ID');
+            }
+        }
+        catch (error) {
+            console.error('Error fetching job results by reference ID:', error);
+            throw error;
+        }
+    }
+    static async executeDatabaseOperation(operation, request) {
+        //const { data } = await this.postRequest(CloudRoutes.integrations.database, { }, {operation, request});
+        const response = await fetch(buildPath(CloudRoutes.integrations.database), {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...this[AuthKey]
+            },
+            body: JSON.stringify({ operation, request })
+        });
+        if (!response.ok) {
+            const errorContent = await response.text();
+            console.error('Error Response Content:', errorContent);
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const { data, message, status } = await response.json();
+        return data?.data || data;
+    }
+    static async getJobFile(jobId, fileType, fileId) {
+        try {
+            const response = await fetch(buildPath(CloudRoutes.job.file, { id: jobId, fileType, fileId }), {
+                method: 'GET',
+                headers: {
+                    //'Content-Type': 'application/json',
+                    ...this[AuthKey]
+                },
+                //credentials: 'include',
+            });
+            // Validate response
+            //await this.validateReponse(response);
+            if (!response.ok) {
+                throw new Error(`Failed to fetch file: ${response.statusText}`);
+            }
+            // Ensure the response is of type readable stream
+            if (!response.body) {
+                throw new Error("Response body is empty, no stream available.");
+            }
+            return response.body; // Return the ReadableStream for the file
+        }
+        catch (error) {
+            console.error('Error fetching job file:', error);
+            throw error;
+        }
+    }
+}
+exports.default = CloudResourceManager;

package/build/index.d.ts

@@ -0,0 +1,9 @@
+export { DatabaseSchema } from "./CloudDatabaseManager";
+import { ProcessExecutionOptions, ProcessScheduleOptions, ProcessJobEventsRequest } from './types';
+export declare const init: (clientId: string, apiKey: string) => void;
+export declare const runProcess: (options: ProcessExecutionOptions) => Promise<any>;
+export declare const getJobResults: (jobId: string) => Promise<any>;
+export declare const getProcessJobEvents: (request: ProcessJobEventsRequest) => Promise<any>;
+export declare const scheduleProcess: (options: ProcessScheduleOptions) => Promise<any>;
+export declare const getPromptContent: (promptId: string) => Promise<any>;
+export declare const getJobFile: (jobId: string, link: string) => Promise<ReadableStream<Uint8Array<ArrayBuffer>>>;

package/build/index.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJobFile = exports.getPromptContent = exports.scheduleProcess = exports.getProcessJobEvents = exports.getJobResults = exports.runProcess = exports.init = exports.DatabaseSchema = void 0;
+const CloudResourceAPI_1 = __importDefault(require("./CloudResourceAPI"));
+const poller_1 = require("./poller");
+var CloudDatabaseManager_1 = require("./CloudDatabaseManager");
+Object.defineProperty(exports, "DatabaseSchema", { enumerable: true, get: function () { return CloudDatabaseManager_1.DatabaseSchema; } });
+const JOB_COMPLETE_STATUS = new Set([
+    'job-end',
+    'job-error',
+    'job-completed',
+    'process-completed',
+    'process-ended'
+]);
+const isJobComplete = (events = []) => {
+    return events.some((val) => JOB_COMPLETE_STATUS.has(val.eventType?.toLowerCase()));
+};
+const init = (clientId, apiKey) => {
+    CloudResourceAPI_1.default.init(clientId, apiKey);
+};
+exports.init = init;
+const runProcess = (options) => {
+    if (options.accessPoint) {
+        return CloudResourceAPI_1.default.runProcessViaAccessPoint(options.processId, options.inputs, options.accessPoint, options.metadata || {});
+    }
+    return CloudResourceAPI_1.default.runProcess(options.processId, options.inputs, options.metadata || {});
+};
+exports.runProcess = runProcess;
+const getJobResults = async (jobId) => {
+    //Polling
+    return CloudResourceAPI_1.default.getProcessJobResults(jobId);
+};
+exports.getJobResults = getJobResults;
+const getProcessJobEvents = async (request
+// referenceId: string,
+// polling?: { intervalMs: number, durationMs?: number }
+) => {
+    const { referenceId, polling, accessPoint } = request;
+    //Polling
+    if (polling) {
+        const poller = (0, poller_1.createPoller)(async () => {
+            const events = accessPoint ? await CloudResourceAPI_1.default.getProcessJobEventsViaAccessPoint(referenceId, accessPoint) : await CloudResourceAPI_1.default.getProcessJobEvents(referenceId);
+            const isComplete = isJobComplete(events);
+            let results;
+            if (isComplete) {
+                results = await CloudResourceAPI_1.default.getJobResultsByReferenceId(referenceId);
+            }
+            return {
+                data: events,
+                done: isComplete,
+                results: results || null
+            };
+        }, polling.intervalMs);
+        return poller;
+    }
+    return CloudResourceAPI_1.default.getProcessJobEvents(referenceId);
+};
+exports.getProcessJobEvents = getProcessJobEvents;
+const scheduleProcess = (options) => {
+    return CloudResourceAPI_1.default.scheduleProcess(options.processId, options);
+};
+exports.scheduleProcess = scheduleProcess;
+const getPromptContent = (promptId) => {
+    return CloudResourceAPI_1.default.getPromptContent(promptId);
+};
+exports.getPromptContent = getPromptContent;
+const JOB_FILE_PATTERN = /^file\((image|audio|text)\):([a-f\d]{24})$/;
+const getJobFileDetails = (link) => {
+    //Format is like file:audio(fileId)
+    const match = link.match(JOB_FILE_PATTERN);
+    if (!match) {
+        throw new Error('Invalid file link format');
+    }
+    const fileType = match[1];
+    const fileId = match[2];
+    return { fileType, fileId };
+};
+const getJobFile = async (jobId, link) => {
+    //Format is like file:audio(fileId)
+    const { fileType, fileId } = getJobFileDetails(link);
+    return CloudResourceAPI_1.default.getJobFile(jobId, fileType, fileId);
+};
+exports.getJobFile = getJobFile;
+console.log("Loaded Juggernaut Cloud SDK");

package/build/min.d.ts

@@ -0,0 +1,9 @@
+declare const SDK: Readonly<{
+    runProcess: (options: import("./types").ProcessExecutionOptions) => Promise<any>;
+    getProcessJobEvents: (request: import("./types").ProcessJobEventsRequest) => Promise<any>;
+    scheduleProcess: (options: import("./types").ProcessScheduleOptions) => Promise<any>;
+    getPromptContent: (promptId: string) => Promise<any>;
+    getJobFile: (jobId: string, link: string) => Promise<ReadableStream<Uint8Array<ArrayBuffer>>>;
+    getJobResults: (jobId: string) => Promise<any>;
+}>;
+export default SDK;

package/build/min.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+const SDK = Object.freeze({
+    runProcess: index_1.runProcess,
+    getProcessJobEvents: index_1.getProcessJobEvents,
+    scheduleProcess: index_1.scheduleProcess,
+    getPromptContent: index_1.getPromptContent,
+    getJobFile: index_1.getJobFile,
+    getJobResults: index_1.getJobResults
+});
+//Exporting for minified build for a browser environment
+const exportGlobals = () => {
+    if (typeof window !== "undefined") {
+        window.JuggernautCloud = SDK;
+        return;
+    }
+    if (globalThis) {
+        globalThis.JuggernautCloud = SDK;
+        return;
+    }
+};
+exportGlobals();
+exports.default = SDK;

package/build/poller.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Type for the listener callback.
+ * @param data The data returned by the polling function.
+ */
+type Listener<T> = (data: T) => void;
+/**
+ * Creates a polling mechanism that repeatedly calls an async function and
+ * emits its results to registered listeners.
+ *
+ * Supports both Node.js and Browser environments.
+ *
+ * @param pollFn The async function to execute on each poll interval.
+ * @param intervalMs The polling interval in milliseconds.
+ * @param stopCondition Optional function to determine if polling should stop based on the data.
+ * @returns An object with start/stop controls and an 'on' method for listening.
+ */
+export declare function createPoller<T>(pollFn: () => Promise<T>, intervalMs: number, stopCondition?: (data: T) => boolean): {
+    start: (listener?: Listener<T>) => void;
+    stop: () => void;
+    listen: (listener: Listener<T>) => () => void;
+};
+export {};

package/build/poller.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPoller = createPoller;
+/**
+ * Creates a polling mechanism that repeatedly calls an async function and
+ * emits its results to registered listeners.
+ *
+ * Supports both Node.js and Browser environments.
+ *
+ * @param pollFn The async function to execute on each poll interval.
+ * @param intervalMs The polling interval in milliseconds.
+ * @param stopCondition Optional function to determine if polling should stop based on the data.
+ * @returns An object with start/stop controls and an 'on' method for listening.
+ */
+function createPoller(pollFn, intervalMs, 
+// New optional parameter to check if we should stop
+stopCondition) {
+    let intervalId = null;
+    const listeners = [];
+    const listen = (listener) => {
+        listeners.push(listener);
+        // Return an unsubscribe function
+        return () => {
+            const index = listeners.indexOf(listener);
+            if (index > -1) {
+                listeners.splice(index, 1);
+            }
+        };
+    };
+    const poll = async () => {
+        try {
+            const data = await pollFn();
+            listeners.forEach(listener => listener(data));
+            if (stopCondition && stopCondition(data)) {
+                stop();
+            }
+        }
+        catch (error) {
+            console.error('Polling error:', error);
+        }
+    };
+    const start = (listener) => {
+        if (intervalId === null) {
+            // Execute once immediately
+            poll();
+            // Set the interval
+            intervalId = setInterval(poll, intervalMs);
+            if (listener) {
+                listen(listener);
+            }
+        }
+    };
+    /** Stops the polling process. */
+    const stop = () => {
+        if (intervalId !== null) {
+            clearInterval(intervalId);
+            intervalId = null;
+        }
+    };
+    return {
+        //Include start with optional listener
+        start,
+        stop,
+        listen
+    };
+}

package/build/types.d.ts

@@ -0,0 +1,22 @@
+export type ProcessExecutionOptions = {
+    processId: string;
+    inputs: Record<string, any>;
+    metadata?: Record<string, any>;
+    accessPoint?: string;
+};
+export type ProcessScheduleOptions = {
+    processId: string;
+    name: string;
+    description?: string;
+    intervals: 'once' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'custom';
+    cronExpression?: string;
+    timezone?: string;
+};
+export type ProcessJobEventsRequest = {
+    referenceId: string;
+    polling?: {
+        intervalMs: number;
+        durationMs?: number;
+    };
+    accessPoint?: string;
+};

package/build/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@juggernautlabs/cloud",
+  "version": "0.0.1",
+  "description": "",
+  "main": "build/index.js",
+  "unpkg": "build/min.js",
+  "files": [
+    "build"
+  ],
+  "scripts": {
+    "test": "jest",
+    "compile": "tsc",
+    "build": "npm run compile",
+    "prepublishOnly": "npm run compile",
+    "publish": "npm publish --access public"
+  },
+  "keywords": [
+    "juggernaut",
+    "cloud",
+    "sdk",
+    "beta"
+  ],
+  "author": "Juggernaut Labs",
+  "license": "MIT",
+  "dependencies": {
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.6"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0"
+  }
+}