@hatchet-dev/typescript-sdk 1.3.2 → 1.4.0-alpha.2

package/step.js

@@ -45,7 +45,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DurableContext = exports.Context = exports.ContextWorker = exports.CreateStepSchema = exports.DesiredWorkerLabelSchema = exports.CreateRateLimitSchema = void 0;
+exports.V0DurableContext = exports.V0Context = exports.ContextWorker = exports.CreateStepSchema = exports.DesiredWorkerLabelSchema = exports.CreateRateLimitSchema = void 0;
 exports.mapRateLimit = mapRateLimit;
 /* eslint-disable no-underscore-dangle */
 /* eslint-disable max-classes-per-file */
@@ -131,7 +131,7 @@ class ContextWorker {
     }
 }
 exports.ContextWorker = ContextWorker;
-class Context {
+class V0Context {
     constructor(action, client, worker) {
         // @deprecated use ctx.abortController instead
         this.controller = new AbortController();
@@ -141,7 +141,7 @@ class Context {
             const data = (0, parse_1.parseJSON)(action.actionPayload);
             this.data = data;
             this.action = action;
-            this.client = client;
+            this.v0 = client;
             this.worker = new ContextWorker(worker);
             this.logger = client.config.logger(`Context Logger`, client.config.log_level);
             // if this is a getGroupKeyRunId, the data is the workflow input
@@ -301,7 +301,7 @@ class Context {
             this.logger.warn('cannot log from context without stepRunId');
             return;
         }
-        this.client.event.putLog(stepRunId, message, level);
+        this.v0.event.putLog(stepRunId, message, level);
     }
     /**
      * Refreshes the timeout for the current task.
@@ -316,7 +316,7 @@ class Context {
                 this.logger.warn('cannot refresh timeout from context without stepRunId');
                 return;
             }
-            yield this.client.dispatcher.refreshTimeout(incrementBy, stepRunId);
+            yield this.v0.dispatcher.refreshTimeout(incrementBy, stepRunId);
         });
     }
     /**
@@ -326,7 +326,7 @@ class Context {
      */
     releaseSlot() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.client.dispatcher.client.releaseSlot({
+            yield this.v0.dispatcher.client.releaseSlot({
                 stepRunId: this.action.stepRunId,
             });
         });
@@ -344,7 +344,7 @@ class Context {
                 this.logger.warn('cannot log from context without stepRunId');
                 return;
             }
-            yield this.client.event.putStream(stepRunId, data);
+            yield this.v0.event.putStream(stepRunId, data);
         });
     }
     /**
@@ -386,7 +386,7 @@ class Context {
                 else {
                     workflowName = workflow.id;
                 }
-                const name = this.client.config.namespace + workflowName;
+                const name = this.v0.config.namespace + workflowName;
                 const opts = options || {};
                 const { sticky } = opts;
                 if (sticky && !this.worker.hasWorkflow(name)) {
@@ -401,11 +401,11 @@ class Context {
                 return resp;
             });
             try {
-                const batchSize = 1000;
+                const batchSize = 100;
                 let resp = [];
                 for (let i = 0; i < workflowRuns.length; i += batchSize) {
                     const batch = workflowRuns.slice(i, i + batchSize);
-                    const batchResp = yield this.client.admin.runWorkflows(batch);
+                    const batchResp = yield this.v0.admin.runWorkflows(batch);
                     resp = resp.concat(batchResp);
                 }
                 const res = [];
@@ -447,7 +447,9 @@ class Context {
      * @returns A reference to the spawned workflow run.
      */
     runNoWaitChild(workflow, input, options) {
-        return this.spawnWorkflow(workflow, input, options);
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.spawnWorkflow(workflow, input, options);
+        });
     }
     /**
      * Spawns a new workflow.
@@ -459,31 +461,33 @@ class Context {
      * @deprecated Use runChild or runNoWaitChild instead.
      */
     spawnWorkflow(workflow, input, options) {
-        const { workflowRunId, stepRunId } = this.action;
-        let workflowName = '';
-        if (typeof workflow === 'string') {
-            workflowName = workflow;
-        }
-        else {
-            workflowName = workflow.id;
-        }
-        const name = this.client.config.namespace + workflowName;
-        const opts = options || {};
-        const { sticky } = opts;
-        if (sticky && !this.worker.hasWorkflow(name)) {
-            throw new hatchet_error_1.default(`cannot run with sticky: workflow ${name} is not registered on the worker`);
-        }
-        try {
-            const resp = this.client.admin.runWorkflow(name, input, Object.assign({ parentId: workflowRunId, parentStepRunId: stepRunId, childIndex: this.spawnIndex, desiredWorkerId: sticky ? this.worker.id() : undefined }, opts));
-            this.spawnIndex += 1;
-            if (workflow instanceof declaration_1.TaskWorkflowDeclaration) {
-                resp._standalone_task_name = workflow._standalone_task_name;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { workflowRunId, stepRunId } = this.action;
+            let workflowName = '';
+            if (typeof workflow === 'string') {
+                workflowName = workflow;
             }
-            return resp;
-        }
-        catch (e) {
-            throw new hatchet_error_1.default(e.message);
-        }
+            else {
+                workflowName = workflow.id;
+            }
+            const name = this.v0.config.namespace + workflowName;
+            const opts = options || {};
+            const { sticky } = opts;
+            if (sticky && !this.worker.hasWorkflow(name)) {
+                throw new hatchet_error_1.default(`cannot run with sticky: workflow ${name} is not registered on the worker`);
+            }
+            try {
+                const resp = yield this.v0.admin.runWorkflow(name, input, Object.assign({ parentId: workflowRunId, parentStepRunId: stepRunId, childIndex: this.spawnIndex, desiredWorkerId: sticky ? this.worker.id() : undefined }, opts));
+                this.spawnIndex += 1;
+                if (workflow instanceof declaration_1.TaskWorkflowDeclaration) {
+                    resp._standalone_task_name = workflow._standalone_task_name;
+                }
+                return resp;
+            }
+            catch (e) {
+                throw new hatchet_error_1.default(e.message);
+            }
+        });
     }
     /**
      * Retrieves additional metadata associated with the current workflow run.
@@ -531,8 +535,8 @@ class Context {
         }
     }
 }
-exports.Context = Context;
-class DurableContext extends Context {
+exports.V0Context = V0Context;
+class V0DurableContext extends V0Context {
     constructor() {
         super(...arguments);
         this.waitKey = 0;
@@ -559,13 +563,13 @@ class DurableContext extends Context {
             const pbConditions = (0, transformer_1.conditionsToPb)((0, conditions_1.Render)(condition_1.Action.CREATE, conditions));
             // eslint-disable-next-line no-plusplus
             const key = `waitFor-${this.waitKey++}`;
-            yield this.client.durableListener.registerDurableEvent({
+            yield this.v0.durableListener.registerDurableEvent({
                 taskId: this.action.stepRunId,
                 signalKey: key,
                 sleepConditions: pbConditions.sleepConditions,
                 userEventConditions: pbConditions.userEventConditions,
             });
-            const listener = this.client.durableListener.subscribe({
+            const listener = this.v0.durableListener.subscribe({
                 taskId: this.action.stepRunId,
                 signalKey: key,
             });
@@ -577,7 +581,7 @@ class DurableContext extends Context {
         });
     }
 }
-exports.DurableContext = DurableContext;
+exports.V0DurableContext = V0DurableContext;
 function mapRateLimit(limits) {
     if (!limits)
         return [];

package/util/grpc-helpers.d.ts

@@ -0,0 +1,10 @@
+import { ClientConfig } from '../clients/hatchet-client';
+import { ChannelCredentials, CompatServiceDefinition } from 'nice-grpc';
+import { ClientMiddlewareCall, CallOptions } from 'nice-grpc-common';
+export declare const channelFactory: (config: ClientConfig, credentials: ChannelCredentials) => import("nice-grpc").Channel;
+export declare const addTokenMiddleware: (token: string) => <Request, Response>(call: ClientMiddlewareCall<Request, Response>, options: CallOptions) => AsyncGenerator<Awaited<Response>, Awaited<Response> | undefined, undefined>;
+export declare const createGrpcClient: <T extends CompatServiceDefinition>(config: ClientConfig, serviceDefinition: T) => {
+    factory: import("nice-grpc").ClientFactory<{}>;
+    channel: import("nice-grpc").Channel;
+    client: import("nice-grpc").RawClient<import("nice-grpc").NormalizedServiceDefinition<T>, {}>;
+};

package/util/grpc-helpers.js

@@ -0,0 +1,79 @@
+"use strict";
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
+};
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGrpcClient = exports.addTokenMiddleware = exports.channelFactory = void 0;
+const nice_grpc_1 = require("nice-grpc");
+const nice_grpc_common_1 = require("nice-grpc-common");
+const config_loader_1 = require("./config-loader");
+const channelFactory = (config, credentials) => (0, nice_grpc_1.createChannel)(config.host_port, credentials, {
+    'grpc.ssl_target_name_override': config.tls_config.server_name,
+    'grpc.keepalive_timeout_ms': 60 * 1000,
+    'grpc.client_idle_timeout_ms': 60 * 1000,
+    // Send keepalive pings every 10 seconds, default is 2 hours.
+    'grpc.keepalive_time_ms': 10 * 1000,
+    // Allow keepalive pings when there are no gRPC calls.
+    'grpc.keepalive_permit_without_calls': 1,
+});
+exports.channelFactory = channelFactory;
+const addTokenMiddleware = (token) => function _(call, options) {
+    return __asyncGenerator(this, arguments, function* _1() {
+        var _a, e_1, _b, _c;
+        const optionsWithAuth = Object.assign(Object.assign({}, options), { metadata: new nice_grpc_common_1.Metadata({ authorization: `bearer ${token}` }) });
+        if (!call.responseStream) {
+            const response = yield __await(yield* __asyncDelegator(__asyncValues(call.next(call.request, optionsWithAuth))));
+            return yield __await(response);
+        }
+        try {
+            for (var _d = true, _e = __asyncValues(call.next(call.request, optionsWithAuth)), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
+                _c = _f.value;
+                _d = false;
+                const response = _c;
+                yield yield __await(response);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return yield __await(undefined);
+    });
+};
+exports.addTokenMiddleware = addTokenMiddleware;
+const createGrpcClient = (config, serviceDefinition) => {
+    const credentials = config_loader_1.ConfigLoader.createCredentials(config.tls_config);
+    const clientFactory = (0, nice_grpc_1.createClientFactory)().use((0, exports.addTokenMiddleware)(config.token));
+    const channel = (0, exports.channelFactory)(config, credentials);
+    return {
+        factory: clientFactory,
+        channel,
+        client: clientFactory.create(serviceDefinition, channel),
+    };
+};
+exports.createGrpcClient = createGrpcClient;

package/v1/client/admin.d.ts

@@ -0,0 +1,64 @@
+import { ClientConfig } from '../../clients/hatchet-client/client-config';
+import WorkflowRunRef from '../../util/workflow-run-ref';
+import { Priority, RateLimitDuration, RunsClient } from './..';
+import { RunListenerClient } from '../../clients/listeners/run-listener/child-listener-client';
+import { Api } from '../../clients/rest/generated/Api';
+import { WorkflowServiceClient } from '../../protoc/workflows';
+import { Logger } from '../../util/logger';
+export type WorkflowRun<T = object> = {
+    workflowName: string;
+    input: T;
+    options?: {
+        parentId?: string | undefined;
+        parentStepRunId?: string | undefined;
+        childIndex?: number | undefined;
+        childKey?: string | undefined;
+        additionalMetadata?: Record<string, string> | undefined;
+    };
+};
+export declare class AdminClient {
+    config: ClientConfig;
+    grpc: WorkflowServiceClient;
+    listenerClient: RunListenerClient;
+    runs: RunsClient;
+    logger: Logger;
+    constructor(config: ClientConfig, api: Api, runs: RunsClient);
+    /**
+     * Run a new instance of a workflow with the given input. This will create a new workflow run and return the ID of the
+     * new run.
+     * @param workflowName the name of the workflow to run
+     * @param input an object containing the input to the workflow
+     * @param options an object containing the options to run the workflow
+     * @returns the ID of the new workflow run
+     */
+    runWorkflow<Q = object, P = object>(workflowName: string, input: Q, options?: {
+        parentId?: string | undefined;
+        parentStepRunId?: string | undefined;
+        childIndex?: number | undefined;
+        childKey?: string | undefined;
+        additionalMetadata?: Record<string, string> | undefined;
+        desiredWorkerId?: string | undefined;
+        priority?: Priority;
+    }): Promise<WorkflowRunRef<P>>;
+    /**
+     * Run multiple workflows runs with the given input and options. This will create new workflow runs and return their IDs.
+     * Order is preserved in the response.
+     * @param workflowRuns an array of objects containing the workflow name, input, and options for each workflow run
+     * @returns an array of workflow run references
+     */
+    runWorkflows<Q = object, P = object>(workflowRuns: Array<{
+        workflowName: string;
+        input: Q;
+        options?: {
+            parentId?: string | undefined;
+            parentStepRunId?: string | undefined;
+            childIndex?: number | undefined;
+            childKey?: string | undefined;
+            additionalMetadata?: Record<string, string> | undefined;
+            desiredWorkerId?: string | undefined;
+            priority?: Priority;
+        };
+    }>, batchSize?: number): Promise<WorkflowRunRef<P>[]>;
+    private batchWorkflows;
+    putRateLimit(key: string, limit: number, duration?: RateLimitDuration): Promise<void>;
+}

package/v1/client/admin.js

@@ -0,0 +1,155 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminClient = void 0;
+const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
+const workflow_run_ref_1 = __importDefault(require("../../util/workflow-run-ref"));
+const grpc_helpers_1 = require("../../util/grpc-helpers");
+const child_listener_client_1 = require("../../clients/listeners/run-listener/child-listener-client");
+const workflows_1 = require("../../protoc/workflows");
+class AdminClient {
+    constructor(config, api, runs) {
+        this.config = config;
+        this.logger = config.logger(`Admin`, config.log_level);
+        const { client, channel, factory } = (0, grpc_helpers_1.createGrpcClient)(config, workflows_1.WorkflowServiceDefinition);
+        this.grpc = client;
+        this.listenerClient = new child_listener_client_1.RunListenerClient(config, channel, factory, api);
+        this.runs = runs;
+    }
+    /**
+     * Run a new instance of a workflow with the given input. This will create a new workflow run and return the ID of the
+     * new run.
+     * @param workflowName the name of the workflow to run
+     * @param input an object containing the input to the workflow
+     * @param options an object containing the options to run the workflow
+     * @returns the ID of the new workflow run
+     */
+    runWorkflow(workflowName, input, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let computedName = workflowName;
+            try {
+                if (this.config.namespace && !workflowName.startsWith(this.config.namespace)) {
+                    computedName = this.config.namespace + workflowName;
+                }
+                const inputStr = JSON.stringify(input);
+                const resp = yield this.grpc.triggerWorkflow(Object.assign(Object.assign({ name: computedName, input: inputStr }, options), { additionalMetadata: (options === null || options === void 0 ? void 0 : options.additionalMetadata)
+                        ? JSON.stringify(options === null || options === void 0 ? void 0 : options.additionalMetadata)
+                        : undefined, priority: options === null || options === void 0 ? void 0 : options.priority }));
+                const id = resp.workflowRunId;
+                const ref = new workflow_run_ref_1.default(id, this.listenerClient, this.runs, options === null || options === void 0 ? void 0 : options.parentId);
+                yield ref.getWorkflowRunId();
+                return ref;
+            }
+            catch (e) {
+                throw new hatchet_error_1.default(e.message);
+            }
+        });
+    }
+    /**
+     * Run multiple workflows runs with the given input and options. This will create new workflow runs and return their IDs.
+     * Order is preserved in the response.
+     * @param workflowRuns an array of objects containing the workflow name, input, and options for each workflow run
+     * @returns an array of workflow run references
+     */
+    runWorkflows(workflowRuns_1) {
+        return __awaiter(this, arguments, void 0, function* (workflowRuns, batchSize = 500) {
+            // Prepare workflows to be triggered in bulk
+            const workflowRequests = workflowRuns.map(({ workflowName, input, options }) => {
+                let computedName = workflowName;
+                if (this.config.namespace && !workflowName.startsWith(this.config.namespace)) {
+                    computedName = this.config.namespace + workflowName;
+                }
+                const inputStr = JSON.stringify(input);
+                return Object.assign(Object.assign({ name: computedName, input: inputStr }, options), { additionalMetadata: (options === null || options === void 0 ? void 0 : options.additionalMetadata)
+                        ? JSON.stringify(options.additionalMetadata)
+                        : undefined });
+            });
+            const batches = this.batchWorkflows(workflowRequests, batchSize);
+            this.logger.debug(`batching ${batches.length} batches`);
+            try {
+                const allResults = [];
+                // Process each batch
+                for (let batchIndex = 0; batchIndex < batches.length; batchIndex += 1) {
+                    const batch = batches[batchIndex];
+                    const { requests, originalIndices } = batch;
+                    // Call the bulk trigger workflow method for this batch
+                    const bulkTriggerWorkflowResponse = yield this.grpc.bulkTriggerWorkflow(workflows_1.BulkTriggerWorkflowRequest.create({
+                        workflows: requests,
+                    }));
+                    this.logger.debug(`batch ${batchIndex + 1} of ${batches.length}`);
+                    // Map the results back to their original indices
+                    const batchResults = bulkTriggerWorkflowResponse.workflowRunIds.map((resp, index) => {
+                        const originalIndex = originalIndices[index];
+                        const { options } = workflowRuns[originalIndex];
+                        return new workflow_run_ref_1.default(resp, this.listenerClient, this.runs, options === null || options === void 0 ? void 0 : options.parentId);
+                    });
+                    allResults.push(...batchResults);
+                }
+                return allResults;
+            }
+            catch (e) {
+                throw new hatchet_error_1.default(e.message);
+            }
+        });
+    }
+    batchWorkflows(workflowRequests, batchSize) {
+        const payloadLimit = 4 * 1024 * 1024; // 4MB limit
+        const batches = [];
+        let currentBatch = [];
+        let currentBatchIndices = [];
+        let currentBatchSize = 0;
+        for (let i = 0; i < workflowRequests.length; i += 1) {
+            const request = workflowRequests[i];
+            const requestSize = Buffer.byteLength(JSON.stringify(request), 'utf8');
+            // Check if adding this request would exceed either the payload limit or batch size
+            if (currentBatchSize + requestSize > payloadLimit || currentBatch.length >= batchSize) {
+                // If we have a batch, add it to batches
+                if (currentBatch.length > 0) {
+                    batches.push({
+                        requests: currentBatch,
+                        originalIndices: currentBatchIndices,
+                    });
+                }
+                // Start a new batch
+                currentBatch = [request];
+                currentBatchIndices = [i];
+                currentBatchSize = requestSize;
+            }
+            else {
+                // Add to current batch
+                currentBatch.push(request);
+                currentBatchIndices.push(i);
+                currentBatchSize += requestSize;
+            }
+        }
+        // Add the last batch if it exists
+        if (currentBatch.length > 0) {
+            batches.push({
+                requests: currentBatch,
+                originalIndices: currentBatchIndices,
+            });
+        }
+        return batches;
+    }
+    putRateLimit(key, limit, duration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.grpc.putRateLimit({
+                key,
+                limit,
+                duration,
+            });
+        });
+    }
+}
+exports.AdminClient = AdminClient;

package/v1/client/client.d.ts

@@ -1,30 +1,31 @@
-import { ClientConfig, InternalHatchetClient, HatchetClientOptions } from '../../clients/hatchet-client';
+import { ClientConfig, HatchetClientOptions, LegacyHatchetClient } from '../../clients/hatchet-client';
 import { AxiosRequestConfig } from 'axios';
 import WorkflowRunRef from '../../util/workflow-run-ref';
 import { Workflow as V0Workflow } from '../../workflow';
-import { DurableContext } from '../../step';
+import { V0DurableContext } from '../../step';
 import { Api } from '../../clients/rest';
 import { CreateTaskWorkflowOpts, CreateWorkflowOpts, RunOpts, BaseWorkflowDeclaration, WorkflowDeclaration, TaskWorkflowDeclaration, CreateDurableTaskWorkflowOpts } from '../declaration';
 import { IHatchetClient } from './client.interface';
-import { CreateWorkerOpts, Worker } from './worker';
+import { CreateWorkerOpts, Worker } from './worker/worker';
 import { MetricsClient } from './features/metrics';
 import { WorkersClient } from './features/workers';
 import { WorkflowsClient } from './features/workflows';
 import { RunsClient } from './features/runs';
 import { InputType, OutputType, UnknownInputType, StrictWorkflowOutputType } from '../types';
 import { RatelimitsClient } from './features';
+import { AdminClient } from './admin';
 /**
  * HatchetV1 implements the main client interface for interacting with the Hatchet workflow engine.
  * It provides methods for creating and executing workflows, as well as managing workers.
  */
 export declare class HatchetClient implements IHatchetClient {
     /** The underlying v0 client instance */
-    _v0: InternalHatchetClient;
+    _v0: LegacyHatchetClient;
     _api: Api;
     /**
      * @deprecated v0 client will be removed in a future release, please upgrade to v1
      */
-    get v0(): InternalHatchetClient;
+    get v0(): LegacyHatchetClient;
     /** The tenant ID for the Hatchet client */
     tenantId: string;
     _isV1: boolean | undefined;
@@ -44,6 +45,8 @@ export declare class HatchetClient implements IHatchetClient {
      * @returns A new Hatchet client instance
      */
     static init(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): HatchetClient;
+    private _config;
+    get config(): ClientConfig;
     /**
      * Creates a new workflow definition.
      * @template I - The input type for the workflow
@@ -86,7 +89,7 @@ export declare class HatchetClient implements IHatchetClient {
      * @param options Durable task configuration options with function that defines types
      * @returns A TaskWorkflowDeclaration instance with inferred types
      */
-    durableTask<Fn extends (input: I, ctx: DurableContext<I>) => O | Promise<O>, I extends InputType = Parameters<Fn>[0], O extends OutputType = ReturnType<Fn> extends Promise<infer P> ? P extends OutputType ? P : void : ReturnType<Fn> extends OutputType ? ReturnType<Fn> : void>(options: {
+    durableTask<Fn extends (input: I, ctx: V0DurableContext<I>) => O | Promise<O>, I extends InputType = Parameters<Fn>[0], O extends OutputType = ReturnType<Fn> extends Promise<infer P> ? P extends OutputType ? P : void : ReturnType<Fn> extends OutputType ? ReturnType<Fn> : void>(options: {
         fn: Fn;
     } & Omit<CreateDurableTaskWorkflowOpts<I, O>, 'fn'>): TaskWorkflowDeclaration<I, O>;
     /**
@@ -98,7 +101,7 @@ export declare class HatchetClient implements IHatchetClient {
      * @param options - Configuration options for the workflow run
      * @returns A WorkflowRunRef containing the run ID and methods to interact with the run
      */
-    runNoWait<I extends InputType = UnknownInputType, O extends OutputType = void>(workflow: BaseWorkflowDeclaration<I, O> | string | V0Workflow, input: I, options: RunOpts): WorkflowRunRef<O>;
+    runNoWait<I extends InputType = UnknownInputType, O extends OutputType = void>(workflow: BaseWorkflowDeclaration<I, O> | string | V0Workflow, input: I, options: RunOpts): Promise<WorkflowRunRef<O>>;
     /**
      * @alias run
      * Triggers a workflow run and waits for the result.
@@ -194,10 +197,12 @@ export declare class HatchetClient implements IHatchetClient {
      * @returns A API client instance
      */
     get api(): Api<unknown>;
+    _admin: AdminClient | undefined;
     /**
-     * @deprecated use workflow.run, client.run, or client.* feature methods instead
+     * Get the admin client for creating and managing workflows
+     * @returns A admin client instance
      */
-    get admin(): import("../..").AdminClient;
+    get admin(): AdminClient;
     /**
      * Creates a new worker instance for processing workflow tasks.
      * @param options - Configuration options for creating the worker

package/v1/client/client.interface.d.ts

@@ -1,12 +1,14 @@
-import { InternalHatchetClient } from '../../clients/hatchet-client';
+import { LegacyHatchetClient } from '../../clients/hatchet-client';
 import { MetricsClient } from './features/metrics';
 import { RunsClient } from './features/runs';
 import { WorkersClient } from './features/workers';
 import { WorkflowsClient } from './features/workflows';
+import { AdminClient } from './admin';
 export interface IHatchetClient {
-    _v0: InternalHatchetClient;
+    _v0: LegacyHatchetClient;
     metrics: MetricsClient;
     runs: RunsClient;
     workflows: WorkflowsClient;
     workers: WorkersClient;
+    admin: AdminClient;
 }