[BUG] eliminate redundant gRPC engine version fetch in Worker.start()

[chandan-1427]

Describe the issue
When Worker.start() is called on the non-legacy path, it makes two separate gRPC calls to fetch the engine version — one inside isLegacyEngine() and a second explicit call to fetchEngineVersion() immediately after. Both calls fetch identical data. The result from the first call is discarded, and the second call is used for eviction support checking and setting _internal.engineVersion.

Environment

• SDK: TypeScript (v1 worker, client/worker/worker.ts)
• Engine: Cloud or Self-hosted (any version that supports GetVersion)

Expected behavior
The engine version should be fetched once per Worker.start() invocation and the result reused across both the legacy engine check and eviction support check.

Code to Reproduce, Logs, or Screenshots

In client/worker/worker.ts:

async start() {
  // Call 1: fetchEngineVersion is called internally inside isLegacyEngine
  if (await isLegacyEngine(this._v1)) {
    ...
    return this._legacyWorker.start();
  }

  // Call 2: fetchEngineVersion called again immediately after
  const engineVersion = await fetchEngineVersion(this._v1).catch(() => undefined);
  this._checkEvictionSupport(engineVersion);
  this._internal.engineVersion = engineVersion;

  return this._internal.start();
}

In client/worker/deprecated/legacy-worker.ts, isLegacyEngine internally calls fetchEngineVersion:

export async function isLegacyEngine(v1: HatchetClient): Promise<boolean> {
  const version = await fetchEngineVersion(v1).catch(...);
  if (!version || semverLessThan(version, MinEngineVersion.SLOT_CONFIG)) {
    ...
    return true;
  }
  return false;
}

The fix is to fetch once in start(), inline the legacy check, and delete isLegacyEngine:

async start() {
  const engineVersion = await fetchEngineVersion(this._v1).catch(() => undefined);

  if (!engineVersion || semverLessThan(engineVersion, MinEngineVersion.SLOT_CONFIG)) {
    const legacyConfig: CreateWorkerOpts = { ...this.config, ... };
    this._legacyWorker = await LegacyDualWorker.create(this._v1, this.name, legacyConfig);
    return this._legacyWorker.start();
  }

  this._checkEvictionSupport(engineVersion);
  this._internal.engineVersion = engineVersion;
  return this._internal.start();
}

Additional context
Three files need to change: client/worker/worker.ts (inline the fetch + legacy check), client/worker/deprecated/legacy-worker.ts and client/worker/deprecated/index.ts (delete isLegacyEngine as it becomes dead code). fetchEngineVersion itself remains unchanged.

---

🤖 AI Disclosure

• I acknowledge that an LLM was used in the creation of this Issue, in accordance with Hatchet's AI_POLICY.md.
• Details: Bug identified and diagnosed via Claude (Anthropic) during a code review of worker.ts and deprecated/index.ts. Fix verified manually by tracing the call chain across both files.

[gregfurman]

@Amresh-01 Shall I assign this to you?

[chandan-1427]

@Amresh-01 Shall I assign this to you?

@gregfurman actually I opened the issue. If possible assign to me

[gregfurman]

I suppose since we didn't explicitly accept this issue, the PR goes against our contributing guidelines.

I'll close the currently opened PR and triage this issue. If accepted, I'll assign it to you @chandan-1427

[Amresh-01]

Understood @gregfurman! I'll look for another good first issue.
Thanks for the guidance!

[gregfurman]

@chandan-1427 OK have given this a look. Seems more like a small optimisation/refactor than a bug.

I'm not really in favour of removing functionality in the SDK for now since removing isLegacyEngine could potentially be a breaking change, and IMO we'd want to keep the deprecation warning in isLegacyEngine being emitted.

If you can think of a neat solution that adheres to all of the above, then I'm happy to accept. WDYT?

[gregfurman]

@Amresh-01 Thanks for understanding 🙂 Feel free to tag me in an issue that you'd like to work on (if accepted and no other PRs are open) and I'm happy to assign you.

[chandan-1427]

I suppose since we didn't explicitly accept this issue, the PR goes against our contributing guidelines.

I'll close the currently opened PR and triage this issue. If accepted, I'll assign it to you @chandan-1427

How about making version an optional parameter on isLegacyEngine so it can accept a pre-fetched value instead of always fetching internally? When a version is passed in it skips the fetch, when it isn't it falls back to the existing behavior — so it's fully backwards compatible.

export async function isLegacyEngine(v1: HatchetClient, version?: string): Promise<boolean> {
  const resolvedVersion = version ?? await fetchEngineVersion(v1).catch((e) => {
    if (getGrpcErrorCode(e) === Status.UNIMPLEMENTED) return undefined;
    throw e;
  });

  if (!resolvedVersion || semverLessThan(resolvedVersion, MinEngineVersion.SLOT_CONFIG)) {
    const logger = v1.config.logger('Worker', v1.config.log_level);
    emitDeprecationNotice('legacy-engine', LEGACY_ENGINE_MESSAGE, LEGACY_ENGINE_START, logger, {
      errorDays: 180,
    });
    return true;
  }

  return false;
}

Then worker.ts fetches once and passes the result to both isLegacyEngine and _checkEvictionSupport:

async start() {
  const engineVersion = await fetchEngineVersion(this._v1).catch(() => undefined);

  if (await isLegacyEngine(this._v1, engineVersion)) {
    ...
    return this._legacyWorker.start();
  }

  this._checkEvictionSupport(engineVersion);
  this._internal.engineVersion = engineVersion;
  return this._internal.start();
}

• isLegacyEngine stays public and unchanged in signature for existing callers
• Deprecation warning still lives inside it
• Single gRPC fetch, version reused across both paths