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.
import { type EnvironmentId as EnvironmentIdType } from "@akeru/contracts";
import * as Cause from "effect/Cause";
import * as Effect from "effect/Effect";
import * as Stream from "effect/Stream";
import { Atom, AtomRegistry } from "effect/unstable/reactivity";
import { EnvironmentRegistry } from "../connection/registry.ts";
import {
type EnvironmentRpcInput,
type EnvironmentRpcStreamFailure,
type EnvironmentRpcStreamValue,
type EnvironmentStreamCommandRpcTag,
type EnvironmentSubscriptionRpcTag,
type EnvironmentUnaryRpcTag,
request,
runStream,
subscribe,
} from "../rpc/client.ts";
import { EnvironmentSupervisor } from "../connection/supervisor.ts";
import { type EnvironmentCommandAtomOptions, type AtomCommand } from "./atomRuntimeTypes.ts";
import {
runInEnvironment,
runStreamInEnvironment,
createEnvironmentQueryAtomFamily,
createEnvironmentSubscriptionAtomFamily,
} from "./environmentQueries.ts";
import { settleAtomCommandResult, executeAtomQuery } from "./atomCommandResult.ts";
import {
type AtomCommandConcurrency,
type AtomCommandScheduler,
createAtomCommandScheduler,
} from "./atomCommandScheduler.ts";
export function createRuntimeCommand<R, ER, W, A, E>(
runtime: Atom.AtomRuntime<R, ER>,
options: {
readonly label: string;
readonly execute: (input: W, registry: AtomRegistry.AtomRegistry) => Effect.Effect<A, E, R>;
readonly scheduler?: AtomCommandScheduler;
readonly concurrency?: AtomCommandConcurrency<W>;
},
): AtomCommand<W, A, E | ER> {
const scheduler = options.scheduler ?? createAtomCommandScheduler();
const concurrency = options.concurrency ?? { mode: "parallel" as const };
return {
label: options.label,
run: (registry, input) =>
settleAtomCommandResult(() =>
scheduler.schedule(registry, concurrency, input, () => {
const atom = runtime
.atom(options.execute(input, registry))
.pipe(Atom.withLabel(options.label));
return executeAtomQuery(registry, atom, { reportDefect: false, reportFailure: false });
}),
),
};
}
export function createRuntimeStreamCommand<R, ER, W, A, E>(
runtime: Atom.AtomRuntime<R, ER>,
options: {
readonly label: string;
readonly execute: (input: W, registry: AtomRegistry.AtomRegistry) => Stream.Stream<A, E, R>;
readonly scheduler?: AtomCommandScheduler;
readonly concurrency?: AtomCommandConcurrency<W>;
},
): AtomCommand<W, A, E | ER | Cause.NoSuchElementError> {
const scheduler = options.scheduler ?? createAtomCommandScheduler();
const concurrency = options.concurrency ?? { mode: "parallel" as const };
return {
label: options.label,
run: (registry, input) =>
settleAtomCommandResult(() =>
scheduler.schedule(registry, concurrency, input, () => {
const atom = runtime
.atom(options.execute(input, registry))
.pipe(Atom.withLabel(options.label));
return executeAtomQuery(registry, atom, { reportDefect: false, reportFailure: false });
}),
),
};
}
export function createEnvironmentCommand<R, ER, Input, A, E>(
runtime: Atom.AtomRuntime<EnvironmentRegistry | R, ER>,
options: EnvironmentCommandAtomOptions<Input, A, E, EnvironmentSupervisor | R>,
) {
return createRuntimeCommand(runtime, {
label: options.label,
...(options.scheduler === undefined ? {} : { scheduler: options.scheduler }),
...(options.concurrency === undefined ? {} : { concurrency: options.concurrency }),
execute: (target, registry) =>
runInEnvironment(
target.environmentId,
options.execute(target.input, registry, target.environmentId),
),
});
}
function createEnvironmentStreamCommand<R, ER, Input, A, E>(
runtime: Atom.AtomRuntime<EnvironmentRegistry | R, ER>,
options: {
readonly label: string;
readonly execute: (input: Input) => Stream.Stream<A, E, EnvironmentSupervisor | R>;
readonly scheduler?: AtomCommandScheduler;
readonly concurrency?: AtomCommandConcurrency<{
readonly environmentId: EnvironmentIdType;
readonly input: Input;
}>;
},
) {
return createRuntimeStreamCommand(runtime, {
label: options.label,
...(options.scheduler === undefined ? {} : { scheduler: options.scheduler }),
...(options.concurrency === undefined ? {} : { concurrency: options.concurrency }),
execute: (target) =>
runStreamInEnvironment(target.environmentId, options.execute(target.input)).pipe(
Stream.withSpan(options.label),
),
});
}
export function createEnvironmentRpcQueryAtomFamily<R, ER, TTag extends EnvironmentUnaryRpcTag>(
runtime: Atom.AtomRuntime<EnvironmentRegistry | R, ER>,
options: {
readonly label: string;
readonly tag: TTag;
readonly staleTimeMs?: number;
readonly idleTtlMs?: number;
readonly refreshIntervalMs?: number;
readonly revalidateOnFocus?: boolean | "always";
readonly focusSignal?: Atom.Atom<unknown>;
},
) {
return createEnvironmentQueryAtomFamily(runtime, {
label: options.label,
...(options.staleTimeMs === undefined ? {} : { staleTimeMs: options.staleTimeMs }),
...(options.idleTtlMs === undefined ? {} : { idleTtlMs: options.idleTtlMs }),
...(options.refreshIntervalMs === undefined
? {}
: { refreshIntervalMs: options.refreshIntervalMs }),
...(options.revalidateOnFocus === undefined
? {}
: { revalidateOnFocus: options.revalidateOnFocus }),
...(options.focusSignal === undefined ? {} : { focusSignal: options.focusSignal }),
execute: (input: EnvironmentRpcInput<TTag>) => request(options.tag, input),
});
}
export function createEnvironmentRpcSubscriptionAtomFamily<
R,
ER,
TTag extends EnvironmentSubscriptionRpcTag,
B = EnvironmentRpcStreamValue<TTag>,
>(
runtime: Atom.AtomRuntime<EnvironmentRegistry | R, ER>,
options: {
readonly label: string;
readonly tag: TTag;
readonly idleTtlMs?: number;
readonly transform?: (
stream: Stream.Stream<
EnvironmentRpcStreamValue<TTag>,
EnvironmentRpcStreamFailure<TTag>,
EnvironmentSupervisor | R
>,
) => Stream.Stream<B, EnvironmentRpcStreamFailure<TTag>, EnvironmentSupervisor | R>;
},
) {
return createEnvironmentSubscriptionAtomFamily(runtime, {
label: options.label,
...(options.idleTtlMs === undefined ? {} : { idleTtlMs: options.idleTtlMs }),
subscribe: (input: EnvironmentRpcInput<TTag>) => {
const stream = subscribe(options.tag, input);
// SAFETY: Without a transform, B defaults to the RPC stream value; callers choosing another B supply its transform.
return options.transform === undefined
? (stream as Stream.Stream<B, EnvironmentRpcStreamFailure<TTag>, EnvironmentSupervisor | R>)
: options.transform(stream);
},
});
}
export function createEnvironmentRpcCommand<R, ER, TTag extends EnvironmentUnaryRpcTag>(
runtime: Atom.AtomRuntime<EnvironmentRegistry | R, ER>,
options: {
readonly label: string;
readonly tag: TTag;
readonly scheduler?: AtomCommandScheduler;
readonly concurrency?: AtomCommandConcurrency<{
readonly environmentId: EnvironmentIdType;
readonly input: EnvironmentRpcInput<TTag>;
}>;
readonly onSuccess?: (
target: {
readonly environmentId: EnvironmentIdType;
readonly input: EnvironmentRpcInput<TTag>;
},
registry: AtomRegistry.AtomRegistry,
) => Effect.Effect<void, never, R>;
readonly onSettled?: (
target: {
readonly environmentId: EnvironmentIdType;
readonly input: EnvironmentRpcInput<TTag>;
},
registry: AtomRegistry.AtomRegistry,
) => Effect.Effect<void, never, R>;
},
) {
return createEnvironmentCommand(runtime, {
label: options.label,
...(options.scheduler === undefined ? {} : { scheduler: options.scheduler }),
...(options.concurrency === undefined ? {} : { concurrency: options.concurrency }),
execute: (input: EnvironmentRpcInput<TTag>, registry, environmentId) => {
const target = {
environmentId,
input,
};
return request(options.tag, input).pipe(
Effect.tap(() => options.onSuccess?.(target, registry) ?? Effect.void),
Effect.ensuring(options.onSettled?.(target, registry) ?? Effect.void),
);
},
});
}
export function createEnvironmentRpcStreamCommand<
R,
ER,
TTag extends EnvironmentStreamCommandRpcTag,
>(
runtime: Atom.AtomRuntime<EnvironmentRegistry | R, ER>,
options: {
readonly label: string;
readonly tag: TTag;
readonly scheduler?: AtomCommandScheduler;
readonly concurrency?: AtomCommandConcurrency<{
readonly environmentId: EnvironmentIdType;
readonly input: EnvironmentRpcInput<TTag>;
}>;
},
) {
return createEnvironmentStreamCommand(runtime, {
label: options.label,
...(options.scheduler === undefined ? {} : { scheduler: options.scheduler }),
...(options.concurrency === undefined ? {} : { concurrency: options.concurrency }),
execute: (input: EnvironmentRpcInput<TTag>) => runStream(options.tag, input),
});
}
export {
type AtomCommandOptions,
type AtomCommandReporter,
type AtomCommand,
} from "./atomRuntimeTypes.ts";
export {
environmentRpcKey,
runInEnvironment,
runStreamInEnvironment,
followStreamInEnvironment,
createEnvironmentQueryAtomFamily,
createEnvironmentSubscriptionAtomFamily,
} from "./environmentQueries.ts";
export {
type SettledAsyncResult,
type AtomCommandResult,
type AtomCommandSuccess,
type AtomCommandFailure,
runAtomCommand,
mapAtomCommandResult,
isAtomCommandInterrupted,
squashAtomCommandFailure,
settleAsyncResult,
executeAtomCommand,
executeAtomQuery,
reportAtomCommandResult,
settlePromise,
} from "./atomCommandResult.ts";
export {
type AtomCommandConcurrency,
type AtomCommandScheduler,
createAtomCommandScheduler,
scheduleAtomCommandEffect,
} from "./atomCommandScheduler.ts";