Wrong agent type info in TS REPL

[vigoo]

Only one of the 3 defined agents is printed as "available agent client type":

Generating bridge SDKs
  Skipping generating TypeScript bridge SDK for DurableWorker to golem-temp/repl/ts/bridge-sdk/durable-worker-client [UP-TO-DATE]
  Skipping generating TypeScript bridge SDK for EphemeralWorker to golem-temp/repl/ts/bridge-sdk/ephemeral-worker-client [UP-TO-DATE]
  Skipping generating TypeScript bridge SDK for ParallelTestAgent to golem-temp/repl/ts/bridge-sdk/parallel-test-agent-client [UP-TO-DATE]
Preparing TypeScript REPL
  Skipping generating TypeScript REPL package [UP-TO-DATE]

golem-ts-repl[tmp][local]>
>
> Available agent client types:
>   DurableWorker.get(name: string)
>     work: (id: number) => string
>
>
>
> To see this message again, use the `.agent-type-info` command!
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
golem-ts-repl[tmp][local]>

Source:

import { BaseAgent, agent, description } from "@golemcloud/golem-ts-sdk";

function sleep(ms: number): Promise<void> {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

// ---------------------------------------------------------------------------
// DurableWorker — durable agent, sleeps 2s then returns a message
// ---------------------------------------------------------------------------

@agent()
export class DurableWorker extends BaseAgent {
  private readonly name: string;

  constructor(name: string) {
    super();
    this.name = name;
  }

  @description("Sleep for 2 seconds then return a greeting")
  async work(id: number): Promise<string> {
    console.log(
      `[DurableWorker:${this.name}] work called — id=${id}, sleeping 2s...`,
    );
    await sleep(2000);
    console.log(`[DurableWorker:${this.name}] work done — id=${id}`);
    return `DurableWorker ${this.name} task ${id} done`;
  }
}

// ---------------------------------------------------------------------------
// EphemeralWorker — ephemeral agent, sleeps 2s then returns a message
// ---------------------------------------------------------------------------

@agent({ mode: "ephemeral" })
export class EphemeralWorker extends BaseAgent {
  @description("Sleep for 2 seconds then return a greeting")
  async work(id: number): Promise<string> {
    console.log(`[EphemeralWorker] work called — id=${id}, sleeping 2s...`);
    await sleep(2000);
    console.log(`[EphemeralWorker] work done — id=${id}`);
    return `EphemeralWorker task ${id} done`;
  }
}

// ---------------------------------------------------------------------------
// ParallelTestAgent — ephemeral, has two functions to test parallel RPC
// ---------------------------------------------------------------------------

@agent({ mode: "ephemeral" })
export class ParallelTestAgent extends BaseAgent {
  @description("Test parallel RPC to 3 DURABLE workers — should succeed (~2s)")
  async testDurable(): Promise<string[]> {
    console.log(
      `[ParallelTestAgent] testDurable — launching 3 DurableWorkers in parallel...`,
    );
    const start = Date.now();
    const promises = [1, 2, 3].map((id) => {
      const worker = DurableWorker.get(`worker-${id}`);
      return worker.work(id);
    });
    const results = await Promise.all(promises);
    const elapsed = Date.now() - start;
    console.log(
      `[ParallelTestAgent] testDurable done in ${elapsed}ms — results: ${JSON.stringify(results)}`,
    );
    return results;
  }

  @description("Test single RPC to 1 EPHEMERAL worker — should succeed")
  async testEphemeralSingle(): Promise<string> {
    console.log(
      `[ParallelTestAgent] testEphemeralSingle — calling 1 EphemeralWorker...`,
    );
    const start = Date.now();
    const worker = EphemeralWorker.newPhantom();
    const result = await worker.work(1);
    const elapsed = Date.now() - start;
    console.log(
      `[ParallelTestAgent] testEphemeralSingle done in ${elapsed}ms — result: ${result}`,
    );
    return result;
  }

  @description("Test parallel RPC to 3 EPHEMERAL workers — expected to fail")
  async testEphemeral(): Promise<string[]> {
    console.log(
      `[ParallelTestAgent] testEphemeral — launching 3 EphemeralWorkers in parallel...`,
    );
    const start = Date.now();
    const promises = [1, 2, 3].map((id) => {
      const worker = EphemeralWorker.newPhantom();
      return worker.work(id);
    });
    const results = await Promise.all(promises);
    const elapsed = Date.now() - start;
    console.log(
      `[ParallelTestAgent] testEphemeral done in ${elapsed}ms — results: ${JSON.stringify(results)}`,
    );
    return results;
  }
}