@hatchet-dev/typescript-sdk 0.16.0-alpha.4 → 0.17.0

package/clients/worker/compute/compute-config.d.ts

@@ -1,156 +0,0 @@
-import { ManagedWorkerRegion } from '../../rest/generated/cloud/data-contracts';
-import { z } from 'zod';
-export declare const SharedCPUComputeSchema: z.ZodObject<z.objectUtil.extendShape<{
-    pool: z.ZodOptional<z.ZodDefault<z.ZodString>>;
-    numReplicas: z.ZodDefault<z.ZodNumber>;
-    regions: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof ManagedWorkerRegion>, "many">>;
-    cpus: z.ZodNumber;
-}, {
-    cpuKind: z.ZodLiteral<"shared">;
-    memoryMb: z.ZodEffects<z.ZodNumber, number, number>;
-}>, "strip", z.ZodTypeAny, {
-    numReplicas: number;
-    cpus: number;
-    cpuKind: "shared";
-    memoryMb: number;
-    pool?: string | undefined;
-    regions?: ManagedWorkerRegion[] | undefined;
-}, {
-    cpus: number;
-    cpuKind: "shared";
-    memoryMb: number;
-    pool?: string | undefined;
-    numReplicas?: number | undefined;
-    regions?: ManagedWorkerRegion[] | undefined;
-}>;
-export type SharedCPUCompute = z.infer<typeof SharedCPUComputeSchema>;
-export declare const PerformanceCPUComputeSchema: z.ZodObject<z.objectUtil.extendShape<{
-    pool: z.ZodOptional<z.ZodDefault<z.ZodString>>;
-    numReplicas: z.ZodDefault<z.ZodNumber>;
-    regions: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof ManagedWorkerRegion>, "many">>;
-    cpus: z.ZodNumber;
-}, {
-    cpuKind: z.ZodLiteral<"performance">;
-    memoryMb: z.ZodEffects<z.ZodNumber, number, number>;
-}>, "strip", z.ZodTypeAny, {
-    numReplicas: number;
-    cpus: number;
-    cpuKind: "performance";
-    memoryMb: number;
-    pool?: string | undefined;
-    regions?: ManagedWorkerRegion[] | undefined;
-}, {
-    cpus: number;
-    cpuKind: "performance";
-    memoryMb: number;
-    pool?: string | undefined;
-    numReplicas?: number | undefined;
-    regions?: ManagedWorkerRegion[] | undefined;
-}>;
-export type PerformanceCPUCompute = z.infer<typeof PerformanceCPUComputeSchema>;
-export declare const GPUComputeSchema: z.ZodObject<z.objectUtil.extendShape<{
-    pool: z.ZodOptional<z.ZodDefault<z.ZodString>>;
-    numReplicas: z.ZodDefault<z.ZodNumber>;
-    regions: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof ManagedWorkerRegion>, "many">>;
-    cpus: z.ZodNumber;
-}, {
-    cpuKind: z.ZodLiteral<"shared">;
-    gpuKind: z.ZodEnum<["a10", "l40s", "a100-40gb", "a100-80gb"]>;
-    gpus: z.ZodNumber;
-    regions: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodNativeEnum<typeof ManagedWorkerRegion>, "many">, ManagedWorkerRegion[], ManagedWorkerRegion[]>>;
-    memoryMb: z.ZodEffects<z.ZodNumber, number, number>;
-}>, "strip", z.ZodTypeAny, {
-    numReplicas: number;
-    cpus: number;
-    cpuKind: "shared";
-    memoryMb: number;
-    gpuKind: "a10" | "l40s" | "a100-40gb" | "a100-80gb";
-    gpus: number;
-    pool?: string | undefined;
-    regions?: ManagedWorkerRegion[] | undefined;
-}, {
-    cpus: number;
-    cpuKind: "shared";
-    memoryMb: number;
-    gpuKind: "a10" | "l40s" | "a100-40gb" | "a100-80gb";
-    gpus: number;
-    pool?: string | undefined;
-    numReplicas?: number | undefined;
-    regions?: ManagedWorkerRegion[] | undefined;
-}>;
-export type GPUCompute = z.infer<typeof GPUComputeSchema>;
-export declare const ComputeSchema: z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
-    pool: z.ZodOptional<z.ZodDefault<z.ZodString>>;
-    numReplicas: z.ZodDefault<z.ZodNumber>;
-    regions: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof ManagedWorkerRegion>, "many">>;
-    cpus: z.ZodNumber;
-}, {
-    cpuKind: z.ZodLiteral<"shared">;
-    memoryMb: z.ZodEffects<z.ZodNumber, number, number>;
-}>, "strip", z.ZodTypeAny, {
-    numReplicas: number;
-    cpus: number;
-    cpuKind: "shared";
-    memoryMb: number;
-    pool?: string | undefined;
-    regions?: ManagedWorkerRegion[] | undefined;
-}, {
-    cpus: number;
-    cpuKind: "shared";
-    memoryMb: number;
-    pool?: string | undefined;
-    numReplicas?: number | undefined;
-    regions?: ManagedWorkerRegion[] | undefined;
-}>, z.ZodObject<z.objectUtil.extendShape<{
-    pool: z.ZodOptional<z.ZodDefault<z.ZodString>>;
-    numReplicas: z.ZodDefault<z.ZodNumber>;
-    regions: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof ManagedWorkerRegion>, "many">>;
-    cpus: z.ZodNumber;
-}, {
-    cpuKind: z.ZodLiteral<"performance">;
-    memoryMb: z.ZodEffects<z.ZodNumber, number, number>;
-}>, "strip", z.ZodTypeAny, {
-    numReplicas: number;
-    cpus: number;
-    cpuKind: "performance";
-    memoryMb: number;
-    pool?: string | undefined;
-    regions?: ManagedWorkerRegion[] | undefined;
-}, {
-    cpus: number;
-    cpuKind: "performance";
-    memoryMb: number;
-    pool?: string | undefined;
-    numReplicas?: number | undefined;
-    regions?: ManagedWorkerRegion[] | undefined;
-}>, z.ZodObject<z.objectUtil.extendShape<{
-    pool: z.ZodOptional<z.ZodDefault<z.ZodString>>;
-    numReplicas: z.ZodDefault<z.ZodNumber>;
-    regions: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof ManagedWorkerRegion>, "many">>;
-    cpus: z.ZodNumber;
-}, {
-    cpuKind: z.ZodLiteral<"shared">;
-    gpuKind: z.ZodEnum<["a10", "l40s", "a100-40gb", "a100-80gb"]>;
-    gpus: z.ZodNumber;
-    regions: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodNativeEnum<typeof ManagedWorkerRegion>, "many">, ManagedWorkerRegion[], ManagedWorkerRegion[]>>;
-    memoryMb: z.ZodEffects<z.ZodNumber, number, number>;
-}>, "strip", z.ZodTypeAny, {
-    numReplicas: number;
-    cpus: number;
-    cpuKind: "shared";
-    memoryMb: number;
-    gpuKind: "a10" | "l40s" | "a100-40gb" | "a100-80gb";
-    gpus: number;
-    pool?: string | undefined;
-    regions?: ManagedWorkerRegion[] | undefined;
-}, {
-    cpus: number;
-    cpuKind: "shared";
-    memoryMb: number;
-    gpuKind: "a10" | "l40s" | "a100-40gb" | "a100-80gb";
-    gpus: number;
-    pool?: string | undefined;
-    numReplicas?: number | undefined;
-    regions?: ManagedWorkerRegion[] | undefined;
-}>]>;
-export declare const computeHash: (compute: z.infer<typeof ComputeSchema>) => string;

package/clients/worker/compute/compute-config.js

@@ -1,82 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.computeHash = exports.ComputeSchema = exports.GPUComputeSchema = exports.PerformanceCPUComputeSchema = exports.SharedCPUComputeSchema = void 0;
-const data_contracts_1 = require("../../rest/generated/cloud/data-contracts");
-const crypto_1 = require("crypto");
-const zod_1 = require("zod");
-const BaseComputeSchema = zod_1.z.object({
-    pool: zod_1.z.string().default('default').optional().describe('The name of the compute pool to use'),
-    numReplicas: zod_1.z
-        .number()
-        .int()
-        .min(0, { message: 'Must be at least 0' })
-        .max(1000, { message: 'Must be at most 1000' })
-        .default(1)
-        .describe('The number of replicas'),
-    regions: zod_1.z
-        .array(zod_1.z.nativeEnum(data_contracts_1.ManagedWorkerRegion))
-        .optional()
-        .describe('The regions to deploy the worker to'),
-    cpus: zod_1.z
-        .number()
-        .int()
-        .min(1, { message: 'Must be at least 1' })
-        .max(64, { message: 'Must be at most 64' })
-        .describe('The number of CPUs to use for the worker'),
-});
-exports.SharedCPUComputeSchema = BaseComputeSchema.extend({
-    cpuKind: zod_1.z.literal('shared'),
-    memoryMb: zod_1.z
-        .number()
-        .int()
-        .min(256, { message: 'Must be at least 256 MB' })
-        .max(65536, { message: 'Must be at most 65536 MB' })
-        .refine((val) => val % 256 === 0, { message: 'Must be divisible by 256 MB' })
-        .describe('The amount of memory in MB to use for the worker'),
-});
-exports.PerformanceCPUComputeSchema = BaseComputeSchema.extend({
-    cpuKind: zod_1.z.literal('performance'),
-    memoryMb: zod_1.z
-        .number()
-        .int()
-        .min(2048, { message: 'Must be at least 1024 MB' })
-        .max(65536, { message: 'Must be at most 65536 MB' })
-        .refine((val) => val % 256 === 0, { message: 'Must be divisible by 256 MB' })
-        .describe('The amount of memory in MB to use for the worker'),
-});
-// eslint-disable-next-line no-shadow
-const AllowedGPUManagedWorkerRegions = [data_contracts_1.ManagedWorkerRegion.Ord];
-exports.GPUComputeSchema = BaseComputeSchema.extend({
-    cpuKind: zod_1.z.literal('shared'),
-    gpuKind: zod_1.z.enum(['a10', 'l40s', 'a100-40gb', 'a100-80gb']),
-    gpus: zod_1.z
-        .number()
-        .int()
-        .min(1, { message: 'Must be at least 1' })
-        .max(8, { message: 'Must be at most 8' })
-        .describe('The number of GPUs to use for the worker'),
-    regions: zod_1.z
-        .array(zod_1.z.nativeEnum(data_contracts_1.ManagedWorkerRegion))
-        .refine((val) => val.every((region) => AllowedGPUManagedWorkerRegions.includes(region)), {
-        message: 'Invalid GPU region',
-    })
-        .optional()
-        .describe('The regions to deploy the worker to'),
-    memoryMb: zod_1.z
-        .number()
-        .int()
-        .min(2048, { message: 'Must be at least 1024 MB' })
-        .max(65536, { message: 'Must be at most 65536 MB' })
-        .refine((val) => val % 256 === 0, { message: 'Must be divisible by 256 MB' })
-        .describe('The amount of memory in MB to use for the worker'),
-});
-exports.ComputeSchema = zod_1.z.union([
-    exports.SharedCPUComputeSchema,
-    exports.PerformanceCPUComputeSchema,
-    exports.GPUComputeSchema,
-]);
-const computeHash = (compute) => {
-    const str = JSON.stringify(compute);
-    return (0, crypto_1.createHash)('sha256').update(str).digest('hex');
-};
-exports.computeHash = computeHash;

package/clients/worker/compute/managed-compute.d.ts

@@ -1,15 +0,0 @@
-import { HatchetClient } from '../../hatchet-client';
-import { CreateManagedWorkerRuntimeConfigRequest } from '../../rest/generated/cloud/data-contracts';
-import { Logger } from '../../../util/logger';
-import { ActionRegistry } from '../worker';
-export declare class ManagedCompute {
-    actions: ActionRegistry;
-    client: HatchetClient;
-    maxRuns: number;
-    configs: CreateManagedWorkerRuntimeConfigRequest[];
-    cloudRegisterId: string | undefined;
-    logger: Logger;
-    constructor(actions: ActionRegistry, client: HatchetClient, maxRuns?: number);
-    getComputeConfigs(actions: ActionRegistry): CreateManagedWorkerRuntimeConfigRequest[];
-    cloudRegister(): Promise<void>;
-}

package/clients/worker/compute/managed-compute.js

@@ -1,104 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ManagedCompute = void 0;
-const logger_1 = require("../../../util/logger");
-const compute_config_1 = require("./compute-config");
-class ManagedCompute {
-    constructor(actions, client, maxRuns = 1) {
-        this.actions = actions;
-        this.client = client;
-        this.maxRuns = maxRuns;
-        this.configs = this.getComputeConfigs(this.actions);
-        this.cloudRegisterId = this.client.config.cloud_register_id;
-        this.logger = new logger_1.Logger(`Compute`, this.client.config.log_level);
-        if (this.configs.length === 0) {
-            this.logger.debug('No compute configs found, skipping cloud registration and running all actions locally.');
-            return;
-        }
-        if (!this.cloudRegisterId) {
-            this.logger.warn('Managed cloud compute plan:');
-            this.configs.forEach((compute) => {
-                var _a;
-                this.logger.warn('    ----------------------------');
-                this.logger.warn(`    actions: ${(_a = compute.actions) === null || _a === void 0 ? void 0 : _a.join(', ')}`);
-                this.logger.warn(`    num replicas: ${compute.numReplicas}`);
-                this.logger.warn(`    cpu kind: ${compute.cpuKind}`);
-                this.logger.warn(`    cpus: ${compute.cpus}`);
-                this.logger.warn(`    memory mb: ${compute.memoryMb}`);
-                // this.logger.warn(`    regions: ${compute.regions?.join(', ')}`);
-            });
-            this.logger.warn('NOTICE: local mode detected, skipping cloud registration and running all actions locally.');
-        }
-    }
-    getComputeConfigs(actions) {
-        /**
-         * Builds a map of compute hashes to compute configs and lists of actions that correspond to each compute hash.
-         */
-        const computeMap = {};
-        try {
-            Object.entries(actions).forEach(([action, { compute }]) => {
-                if (!compute) {
-                    return;
-                }
-                const key = (0, compute_config_1.computeHash)(compute);
-                const gpuKind = 'gpuKind' in compute ? compute.gpuKind : undefined;
-                const gpus = 'gpus' in compute ? compute.gpus : undefined;
-                if (!computeMap[key]) {
-                    computeMap[key] = {
-                        actions: [],
-                        numReplicas: compute.numReplicas,
-                        cpuKind: compute.cpuKind,
-                        cpus: compute.cpus,
-                        memoryMb: compute.memoryMb,
-                        regions: compute.regions,
-                        slots: this.maxRuns,
-                        gpuKind,
-                        gpus,
-                    };
-                }
-                computeMap[key].actions.push(action);
-            });
-            return Object.values(computeMap);
-        }
-        catch (e) {
-            this.logger.error(`Error getting compute configs: ${e}`);
-            return [];
-        }
-    }
-    cloudRegister() {
-        return __awaiter(this, void 0, void 0, function* () {
-            /**
-             * Registers the compute plan with the cloud if the environment variable is set.
-             * Exits the process upon completion.
-             */
-            if (this.cloudRegisterId) {
-                this.logger.info(`Registering cloud compute plan with ID: ${this.cloudRegisterId}`);
-                try {
-                    if (this.configs.length === 0) {
-                        this.logger.warn('No actions to register, skipping cloud registration.');
-                        process.exit(0);
-                    }
-                    const req = {
-                        runtimeConfigs: this.configs,
-                    };
-                    yield this.client.cloudApi.infraAsCodeCreate(this.cloudRegisterId, req);
-                    process.exit(0);
-                }
-                catch (e) {
-                    this.logger.error(`ERROR: ${e}`);
-                    process.exit(1);
-                }
-            }
-        });
-    }
-}
-exports.ManagedCompute = ManagedCompute;