@hatchet-dev/typescript-sdk 0.16.0-alpha.1 → 0.16.0-alpha.3

package/clients/rest/generated/cloud/Api.d.ts

@@ -236,6 +236,19 @@ export declare class Api<SecurityDataType = unknown> extends HttpClient<Security
         /** The direction to sort the logs */
         direction?: "forward" | "backward";
     }, params?: RequestParams) => Promise<import("axios").AxiosResponse<LogLineList, any>>;
+    /**
+     * @description Get the build logs for a specific build of a managed worker
+     *
+     * @tags Log
+     * @name IacLogsList
+     * @summary Get IaC Logs
+     * @request GET:/api/v1/cloud/managed-worker/{managed-worker}/iac-logs
+     * @secure
+     */
+    iacLogsList: (managedWorker: string, query: {
+        /** The deploy key */
+        deployKey: string;
+    }, params?: RequestParams) => Promise<import("axios").AxiosResponse<LogLineList, any>>;
     /**
      * @description Get all instances for a managed worker
      *

package/clients/rest/generated/cloud/Api.js

@@ -202,6 +202,16 @@ class Api extends http_client_1.HttpClient {
          * @secure
          */
         this.logList = (managedWorker, query, params = {}) => this.request(Object.assign({ path: `/api/v1/cloud/managed-worker/${managedWorker}/logs`, method: 'GET', query: query, secure: true, format: 'json' }, params));
+        /**
+         * @description Get the build logs for a specific build of a managed worker
+         *
+         * @tags Log
+         * @name IacLogsList
+         * @summary Get IaC Logs
+         * @request GET:/api/v1/cloud/managed-worker/{managed-worker}/iac-logs
+         * @secure
+         */
+        this.iacLogsList = (managedWorker, query, params = {}) => this.request(Object.assign({ path: `/api/v1/cloud/managed-worker/${managedWorker}/iac-logs`, method: 'GET', query: query, secure: true, format: 'json' }, params));
         /**
          * @description Get all instances for a managed worker
          *

package/clients/rest/generated/cloud/data-contracts.d.ts

@@ -268,6 +268,14 @@ export interface CreateManagedWorkerRuntimeConfigRequest {
      * @max 65536
      */
     memoryMb: number;
+    /** The kind of GPU to use for the worker */
+    gpuKind?: 'a10' | 'l40s' | 'a100-40gb' | 'a100-80gb';
+    /**
+     * The number of GPUs to use for the worker
+     * @min 1
+     * @max 8
+     */
+    gpus?: number;
     actions?: string[];
     /**
      * @min 1

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

@@ -24,30 +24,58 @@ export declare const SharedCPUComputeSchema: z.ZodObject<z.objectUtil.extendShap
     regions?: ManagedWorkerRegion[] | undefined;
 }>;
 export type SharedCPUCompute = z.infer<typeof SharedCPUComputeSchema>;
-export declare const DedicatedCPUComputeSchema: z.ZodObject<z.objectUtil.extendShape<{
+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<"dedicated">;
+    cpuKind: z.ZodLiteral<"performance">;
     memoryMb: z.ZodEffects<z.ZodNumber, number, number>;
 }>, "strip", z.ZodTypeAny, {
     numReplicas: number;
     cpus: number;
-    cpuKind: "dedicated";
+    cpuKind: "performance";
     memoryMb: number;
     pool?: string | undefined;
     regions?: ManagedWorkerRegion[] | undefined;
 }, {
     cpus: number;
-    cpuKind: "dedicated";
+    cpuKind: "performance";
     memoryMb: number;
     pool?: string | undefined;
     numReplicas?: number | undefined;
     regions?: ManagedWorkerRegion[] | undefined;
 }>;
-export type DedicatedCPUCompute = z.infer<typeof DedicatedCPUComputeSchema>;
+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"]>;
+    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";
+    pool?: string | undefined;
+    regions?: ManagedWorkerRegion[] | undefined;
+}, {
+    cpus: number;
+    cpuKind: "shared";
+    memoryMb: number;
+    gpuKind: "a10" | "l40s" | "a100-40gb" | "a100-80gb";
+    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>;
@@ -76,19 +104,45 @@ export declare const ComputeSchema: z.ZodUnion<[z.ZodObject<z.objectUtil.extendS
     regions: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof ManagedWorkerRegion>, "many">>;
     cpus: z.ZodNumber;
 }, {
-    cpuKind: z.ZodLiteral<"dedicated">;
+    cpuKind: z.ZodLiteral<"performance">;
     memoryMb: z.ZodEffects<z.ZodNumber, number, number>;
 }>, "strip", z.ZodTypeAny, {
     numReplicas: number;
     cpus: number;
-    cpuKind: "dedicated";
+    cpuKind: "performance";
     memoryMb: number;
     pool?: string | undefined;
     regions?: ManagedWorkerRegion[] | undefined;
 }, {
     cpus: number;
-    cpuKind: "dedicated";
+    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"]>;
+    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";
+    pool?: string | undefined;
+    regions?: ManagedWorkerRegion[] | undefined;
+}, {
+    cpus: number;
+    cpuKind: "shared";
     memoryMb: number;
+    gpuKind: "a10" | "l40s" | "a100-40gb" | "a100-80gb";
     pool?: string | undefined;
     numReplicas?: number | undefined;
     regions?: ManagedWorkerRegion[] | undefined;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.computeHash = exports.ComputeSchema = exports.DedicatedCPUComputeSchema = exports.SharedCPUComputeSchema = void 0;
+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");
@@ -34,8 +34,8 @@ exports.SharedCPUComputeSchema = BaseComputeSchema.extend({
         .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.DedicatedCPUComputeSchema = BaseComputeSchema.extend({
-    cpuKind: zod_1.z.literal('dedicated'),
+exports.PerformanceCPUComputeSchema = BaseComputeSchema.extend({
+    cpuKind: zod_1.z.literal('performance'),
     memoryMb: zod_1.z
         .number()
         .int()
@@ -44,7 +44,31 @@ exports.DedicatedCPUComputeSchema = BaseComputeSchema.extend({
         .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.DedicatedCPUComputeSchema]);
+// 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']),
+    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');

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

@@ -50,6 +50,7 @@ class ManagedCompute {
                     return;
                 }
                 const key = (0, compute_config_1.computeHash)(compute);
+                const gpuKind = 'gpuKind' in compute ? compute.gpuKind : undefined;
                 if (!computeMap[key]) {
                     computeMap[key] = {
                         actions: [],
@@ -59,6 +60,7 @@ class ManagedCompute {
                         memoryMb: compute.memoryMb,
                         regions: compute.regions,
                         slots: this.maxRuns,
+                        gpuKind,
                     };
                 }
                 computeMap[key].actions.push(action);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "0.16.0-alpha.1",
+  "version": "0.16.0-alpha.3",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [

package/protoc/dispatcher/dispatcher.d.ts

@@ -1,6 +1,15 @@
 import { BinaryReader, BinaryWriter } from '@bufbuild/protobuf/wire';
 import { type CallContext, type CallOptions } from 'nice-grpc-common';
 export declare const protobufPackage = "";
+export declare enum SDKS {
+    UNKNOWN = 0,
+    GO = 1,
+    PYTHON = 2,
+    TYPESCRIPT = 3,
+    UNRECOGNIZED = -1
+}
+export declare function sDKSFromJSON(object: any): SDKS;
+export declare function sDKSToJSON(object: SDKS): string;
 export declare enum ActionType {
     START_STEP_RUN = 0,
     CANCEL_STEP_RUN = 1,
@@ -59,6 +68,13 @@ export interface WorkerLabels {
     strValue?: string | undefined;
     intValue?: number | undefined;
 }
+export interface RuntimeInfo {
+    sdkVersion?: string | undefined;
+    language?: SDKS | undefined;
+    languageVersion?: string | undefined;
+    os?: string | undefined;
+    extra?: string | undefined;
+}
 export interface WorkerRegisterRequest {
     /** the name of the worker */
     workerName: string;
@@ -74,6 +90,8 @@ export interface WorkerRegisterRequest {
     };
     /** (optional) webhookId is the id of the webhook that the worker is associated with (if any) */
     webhookId?: string | undefined;
+    /** (optional) information regarding the runtime environment of the worker */
+    runtimeInfo?: RuntimeInfo | undefined;
 }
 export interface WorkerRegisterRequest_LabelsEntry {
     key: string;
@@ -274,6 +292,7 @@ export interface ReleaseSlotRequest {
 export interface ReleaseSlotResponse {
 }
 export declare const WorkerLabels: MessageFns<WorkerLabels>;
+export declare const RuntimeInfo: MessageFns<RuntimeInfo>;
 export declare const WorkerRegisterRequest: MessageFns<WorkerRegisterRequest>;
 export declare const WorkerRegisterRequest_LabelsEntry: MessageFns<WorkerRegisterRequest_LabelsEntry>;
 export declare const WorkerRegisterResponse: MessageFns<WorkerRegisterResponse>;