Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

5.7 KB
Raw Blame
import * as Deferred from "effect/Deferred";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Schema from "effect/Schema";
import type * as Scope from "effect/Scope";

/**
 * A delegated child that never reports back fails its parent's watch after this
 * long when the delegation has no deadline. Coding work can run for hours, so
 * this bounds a silent child rather than a slow one.
 */
export const AKERU_CHILD_WAIT_DEFAULT_TIMEOUT = Duration.hours(4);

/** A routine review the user never answers closes after this long. */
export const AKERU_ROUTINE_REVIEW_TIMEOUT = Duration.hours(1);

export class PendingWaiterTimeoutError extends Schema.TaggedErrorClass<PendingWaiterTimeoutError>()(
  "PendingWaiterTimeoutError",
  { key: Schema.String, message: Schema.String },
) {}

export class PendingWaiterClosedError extends Schema.TaggedErrorClass<PendingWaiterClosedError>()(
  "PendingWaiterClosedError",
  { key: Schema.String, message: Schema.String },
) {}

export class PendingWaiterExistsError extends Schema.TaggedErrorClass<PendingWaiterExistsError>()(
  "PendingWaiterExistsError",
  { key: Schema.String, message: Schema.String },
) {}

export type PendingWaiterError =
  | PendingWaiterTimeoutError
  | PendingWaiterClosedError
  | PendingWaiterExistsError;

export interface PendingWaitOptions {
  /** How long to wait. Zero or less fails immediately with the timeout error. */
  readonly timeout: Duration.Input;
  readonly timeoutMessage: string;
  readonly existsMessage?: string;
  /** Runs once the waiter is registered, before waiting starts. */
  readonly onOpen?: () => void;
}

/**
 * Keyed waiters for replies that arrive from outside the waiting fiber, such as
 * a delegated child's turn result or a user's routine review. Every wait has a
 * timeout, and closing the owning scope fails whatever is still waiting.
 *
 * `resolve`, `reject`, `claim`, `get`, and `entries` are synchronous so
 * provider callbacks can settle a waiter without running an effect.
 */
export interface PendingWaiters<Meta, A, E> {
  readonly wait: (
    key: string,
    meta: Meta,
    options: PendingWaitOptions,
  ) => Effect.Effect<A, E | PendingWaiterError>;
  readonly resolve: (key: string, value: A) => boolean;
  readonly reject: (key: string, error: E) => boolean;
  /**
   * Takes an open waiter so the caller can finish work before settling it. A
   * claimed waiter no longer times out and is hidden from `get` and `entries`;
   * settle it later with `resolve` or `reject`. Returns undefined when the
   * waiter already timed out, settled, or was claimed.
   */
  readonly claim: (key: string) => Meta | undefined;
  readonly get: (key: string) => Meta | undefined;
  readonly entries: () => ReadonlyArray<readonly [key: string, meta: Meta]>;
}

interface Entry<Meta, A, E> {
  readonly meta: Meta;
  readonly deferred: Deferred.Deferred<A, E | PendingWaiterError>;
  claimed: boolean;
}

export const makePendingWaiters = <Meta, A, E = never>(
  closedMessage: string,
): Effect.Effect<PendingWaiters<Meta, A, E>, never, Scope.Scope> =>
  Effect.gen(function* () {
    const waiters = new Map<string, Entry<Meta, A, E>>();

    const settle = (key: string, exit: Exit.Exit<A, E | PendingWaiterError>) => {
      const entry = waiters.get(key);

      if (!entry) return false;
      waiters.delete(key);

      return Deferred.doneUnsafe(entry.deferred, exit);
    };

    yield* Effect.addFinalizer(() =>
      Effect.sync(() => {
        for (const key of waiters.keys()) {
          settle(key, Exit.fail(new PendingWaiterClosedError({ key, message: closedMessage })));
        }
      }),
    );

    const wait = (
      key: string,
      meta: Meta,
      options: PendingWaitOptions,
    ): Effect.Effect<A, E | PendingWaiterError> =>
      Effect.suspend(() => {
        if (waiters.has(key)) {
          return Effect.fail(
            new PendingWaiterExistsError({
              key,
              message: options.existsMessage ?? `A waiter already exists for '${key}'.`,
            }),
          );
        }

        const timeoutError = new PendingWaiterTimeoutError({
          key,
          message: options.timeoutMessage,
        });

        if (Duration.toMillis(options.timeout) <= 0) {
          return Effect.fail(timeoutError);
        }

        const entry: Entry<Meta, A, E> = {
          meta,
          deferred: Deferred.makeUnsafe(),
          claimed: false,
        };

        waiters.set(key, entry);
        options.onOpen?.();

        return Deferred.await(entry.deferred).pipe(
          Effect.timeoutOrElse({
            duration: options.timeout,
            // A claimed waiter keeps waiting for its claimant to settle it.
            orElse: () =>
              Effect.suspend(() => {
                if (entry.claimed) return Deferred.await(entry.deferred);

                if (waiters.get(key) === entry) waiters.delete(key);

                return Effect.fail(timeoutError);
              }),
          }),
          Effect.ensuring(
            Effect.sync(() => {
              if (waiters.get(key) === entry) waiters.delete(key);
            }),
          ),
        );
      });

    return {
      wait,
      resolve: (key, value) => settle(key, Exit.succeed(value)),
      reject: (key, error) => settle(key, Exit.fail(error)),
      claim: (key) => {
        const entry = waiters.get(key);

        if (!entry || entry.claimed) return undefined;
        entry.claimed = true;

        return entry.meta;
      },
      get: (key) => {
        const entry = waiters.get(key);

        return entry && !entry.claimed ? entry.meta : undefined;
      },
      entries: () =>
        [...waiters].flatMap(([key, entry]) => (entry.claimed ? [] : [[key, entry.meta] as const])),
    };
  });