Method constructor

packages/computer/src/workspace.ts:271–349

(options: WorkspaceOptions)

  declare readonly stat?: ThinkWorkspaceCompatibility["stat"];

  constructor(options: WorkspaceOptions) {
    this.#now = options.now ?? Date.now;
    this.#waitUntil = options.waitUntil;
    this.#retryScheduler = options.retryScheduler;
    this.#retryInitialDelayMs = positiveRetryOption(
      options.retry?.initialDelayMs,
      DEFAULT_RETRY_INITIAL_DELAY_MS,
      "initialDelayMs",
    );
    this.#retryMaxDelayMs = positiveRetryOption(
      options.retry?.maxDelayMs,
      DEFAULT_RETRY_MAX_DELAY_MS,
      "maxDelayMs",
    );
    this.#retryMaxAttempts = positiveRetryOption(
      options.retry?.maxAttempts,
      DEFAULT_RETRY_MAX_ATTEMPTS,
      "maxAttempts",
    );
    this.#sessionId = options.sessionId ?? "";
    this.#gitFactory = options.git;
    this.#defaultGitIdentity = options.defaultGitIdentity;
    this.#useThink = options.useThink ?? false;
    this.#artifacts = options.artifacts
      ? createArtifact(
          options.artifacts.binding,
          options.artifacts.sessionId ?? options.sessionId ?? "",
        )
      : createDisabledArtifactsClient();
    this.#db = new Database(options.storage);
    initializeSchema(this.#db, this.#now);
    this.#fs = new WorkspaceFilesystem(this.#db, { now: this.#now });
    const registered = (options.backends ?? []).slice();
    if (registered.some((backend) => isModuleBackend(backend) && backend.requiresWaitUntil)) {
      if (!options.waitUntil) {
        throw new Error(
          "Workspace module backend requires waitUntil; pass ctx.waitUntil.bind(ctx).",
        );
      }
    }
    this.#backends = registered.filter(
      (backend): backend is WorkspaceBackend => !isModuleBackend(backend),
    );
    this.#backendsById = new Map(this.#backends.map((backend) => [backend.id, backend]));
    this.#moduleBackendsById = new Map(
      registered.filter(isModuleBackend).map((backend) => [backend.id, backend]),
    );
    this.#registeredBackendIds = new Set();
    this.#callableBackendIds = new Set(
      registered.filter((backend) => backend.callable === true).map((backend) => backend.id),
    );
    for (const backend of registered) {
      if (this.#registeredBackendIds.has(backend.id)) {
        throw new Error(
          `Workspace: duplicate backend id ${JSON.stringify(backend.id)}. ` +
            "Pass an explicit `id` on each backend's constructor options to " +
            "distinguish them.",
        );