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 { UserInputResolution } from "./grok/GrokAdapterState.ts";
import * as Predicate from "effect/Predicate";
import { createGrokEvents } from "./grok/GrokEvents.ts";
import { createGrokTurnLifecycle } from "./grok/GrokTurnLifecycle.ts";
import { createGrokSessionLifecycle } from "./grok/GrokSessionLifecycle.ts";
import { createGrokSendTurn } from "./grok/GrokSendTurn.ts";
import {
type GrokSettings,
EventId,
type ProviderRuntimeEvent,
ProviderInstanceId,
type ThreadId,
} from "@akeru/contracts";
import * as Crypto from "effect/Crypto";
import * as DateTime from "effect/DateTime";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Fiber from "effect/Fiber";
import * as FileSystem from "effect/FileSystem";
import * as Option from "effect/Option";
import * as Path from "effect/Path";
import * as PubSub from "effect/PubSub";
import * as Scope from "effect/Scope";
import * as Semaphore from "effect/Semaphore";
import * as Stream from "effect/Stream";
import * as SynchronizedRef from "effect/SynchronizedRef";
import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";
import * as EffectAcpErrors from "effect-acp/errors";
import { ServerConfig } from "../../config.ts";
import {
ProviderAdapterRequestError,
ProviderAdapterSessionNotFoundError,
ProviderAdapterValidationError,
} from "../Errors.ts";
import { mapAcpToAdapterError } from "../acp/AcpAdapterSupport.ts";
import { makeAcpNativeLoggerFactory } from "../acp/AcpNativeLogging.ts";
import { type GrokAdapterShape } from "../Services/GrokAdapter.ts";
import { type EventNdjsonLogger } from "./logging/EventLogTypes.ts";
import { makeEventNdjsonLogger } from "./EventNdjsonLogger.ts";
import { PROVIDER, type GrokSessionContext } from "./grok/GrokAdapterState.ts";
import {
settlePendingApprovalsAsCancelled,
settlePendingUserInputsAsCancelled,
} from "./grok/GrokProtocol.ts";
export interface GrokAdapterLiveOptions {
readonly environment?: NodeJS.ProcessEnv;
readonly nativeEventLogPath?: string;
readonly nativeEventLogger?: EventNdjsonLogger;
readonly instanceId?: ProviderInstanceId;
}
export function makeGrokAdapter(grokSettings: GrokSettings, options?: GrokAdapterLiveOptions) {
return Effect.gen(function* () {
const boundInstanceId = options?.instanceId ?? ProviderInstanceId.make("grok");
const fileSystem = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
const childProcessSpawner = yield* ChildProcessSpawner.ChildProcessSpawner;
const serverConfig = yield* Effect.service(ServerConfig);
const crypto = yield* Crypto.Crypto;
const nativeEventLogger =
options?.nativeEventLogger ??
(options?.nativeEventLogPath !== undefined
? yield* makeEventNdjsonLogger(options.nativeEventLogPath, { stream: "native" })
: undefined);
const managedNativeEventLogger =
options?.nativeEventLogger === undefined ? nativeEventLogger : undefined;
const makeAcpNativeLoggers = yield* makeAcpNativeLoggerFactory();
const sessions = new Map<ThreadId, GrokSessionContext>();
const threadLocksRef = yield* SynchronizedRef.make(new Map<string, Semaphore.Semaphore>());
const runtimeEventPubSub = yield* PubSub.unbounded<ProviderRuntimeEvent>();
const nowIso = Effect.map(DateTime.now, DateTime.formatIso);
const randomUUIDv4 = crypto.randomUUIDv4.pipe(
Effect.mapError(
(cause) =>
new ProviderAdapterRequestError({
provider: PROVIDER,
method: "crypto/randomUUIDv4",
detail: "Failed to generate Grok runtime identifier.",
cause,
}),
),
);
const nextEventId = Effect.map(randomUUIDv4, (id) => EventId.make(id));
const makeEventStamp = () => Effect.all({ eventId: nextEventId, createdAt: nowIso });
const mapAcpCallbackFailure = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
effect.pipe(
Effect.mapError(
(cause) =>
new EffectAcpErrors.AcpTransportError({
detail: "Failed to process Grok ACP callback.",
cause,
}),
),
);
const offerRuntimeEvent = (event: ProviderRuntimeEvent) =>
PubSub.publish(runtimeEventPubSub, event).pipe(Effect.asVoid);
const getThreadSemaphore = (threadId: string) =>
SynchronizedRef.modifyEffect(threadLocksRef, (current) => {
const existing: Option.Option<Semaphore.Semaphore> = Option.fromNullishOr(
current.get(threadId),
);
return Option.match(existing, {
onNone: () =>
Semaphore.make(1).pipe(
Effect.map((semaphore) => {
const next = new Map(current);
next.set(threadId, semaphore);
return [semaphore, next] as const;
}),
),
onSome: (semaphore) => Effect.succeed([semaphore, current] as const),
});
});
const withThreadLock = <A, E, R>(threadId: string, effect: Effect.Effect<A, E, R>) =>
Effect.flatMap(getThreadSemaphore(threadId), (semaphore) => semaphore.withPermit(effect));
const { settlePromptInFlight } = createGrokTurnLifecycle({
sessions,
offerRuntimeEvent,
makeEventStamp,
nowIso,
});
const { logNative, emitPlanUpdate } = createGrokEvents({
nativeEventLogger,
nowIso,
randomUUIDv4,
offerRuntimeEvent,
});
const requireSession = (
threadId: ThreadId,
): Effect.Effect<GrokSessionContext, ProviderAdapterSessionNotFoundError> => {
const ctx = sessions.get(threadId);
if (!ctx || ctx.stopped) {
return Effect.fail(
new ProviderAdapterSessionNotFoundError({ provider: PROVIDER, threadId }),
);
}
return Effect.succeed(ctx);
};
const stopSessionInternal = (ctx: GrokSessionContext) =>
Effect.gen(function* () {
if (ctx.stopped) return;
ctx.stopped = true;
yield* settlePendingApprovalsAsCancelled(ctx.pendingApprovals);
yield* settlePendingUserInputsAsCancelled(ctx.pendingUserInputs);
if (ctx.notificationFiber) {
yield* Fiber.interrupt(ctx.notificationFiber);
}
yield* Effect.ignore(Scope.close(ctx.scope, Exit.void));
sessions.delete(ctx.threadId);
yield* offerRuntimeEvent({
type: "session.exited",
...(yield* makeEventStamp()),
provider: PROVIDER,
threadId: ctx.threadId,
payload: { exitKind: "graceful" },
});
});
const { startSession } = createGrokSessionLifecycle({
nativeEventLogger,
childProcessSpawner,
withThreadLock,
path,
boundInstanceId,
sessions,
stopSessionInternal,
makeAcpNativeLoggers,
grokSettings,
serverConfig,
options,
fileSystem,
crypto,
mapAcpCallbackFailure,
logNative,
randomUUIDv4,
offerRuntimeEvent,
makeEventStamp,
nowIso,
emitPlanUpdate,
});
const sendTurn = createGrokSendTurn({
boundInstanceId,
serverConfig,
fileSystem,
sessions,
withThreadLock,
requireSession,
settlePromptInFlight,
randomUUIDv4,
offerRuntimeEvent,
makeEventStamp,
nowIso,
});
const interruptTurn: GrokAdapterShape["interruptTurn"] = (threadId, turnId) =>
Effect.gen(function* () {
const observed = yield* Effect.sync(() => {
const ctx = sessions.get(threadId);
if (!ctx || ctx.stopped) {
return {
_tag: "Proceed" as const,
acpSessionId: undefined,
interruptedTurnId: turnId,
};
}
const activeTurnId = ctx.activeTurnId ?? ctx.session.activeTurnId;
if (turnId !== undefined && activeTurnId !== undefined && activeTurnId !== turnId) {
return { _tag: "Ignore" as const };
}
const interruptedTurnId = turnId ?? activeTurnId;
if (interruptedTurnId !== undefined) {
ctx.interruptedTurnIds.add(interruptedTurnId);
}
return {
_tag: "Proceed" as const,
acpSessionId: ctx.acpSessionId,
interruptedTurnId,
};
});
if (Predicate.isTagged(observed, "Ignore")) {
return;
}
yield* withThreadLock(
threadId,
Effect.gen(function* () {
const ctx = yield* requireSession(threadId);
if (observed.acpSessionId !== undefined && ctx.acpSessionId !== observed.acpSessionId) {
return;
}
const activeTurnId = ctx.activeTurnId ?? ctx.session.activeTurnId;
if (turnId !== undefined && activeTurnId !== undefined && activeTurnId !== turnId) {
return;
}
if (
observed.interruptedTurnId !== undefined &&
activeTurnId !== undefined &&
activeTurnId !== observed.interruptedTurnId
) {
return;
}
const interruptedTurnId =
observed.interruptedTurnId ?? turnId ?? activeTurnId ?? ctx.session.activeTurnId;
yield* settlePendingApprovalsAsCancelled(ctx.pendingApprovals);
yield* settlePendingUserInputsAsCancelled(ctx.pendingUserInputs);
yield* Effect.ignore(
ctx.acp.cancel.pipe(
Effect.mapError((error) =>
mapAcpToAdapterError(PROVIDER, threadId, "session/cancel", error),
),
),
);
if (interruptedTurnId) {
ctx.interruptedTurnIds.add(interruptedTurnId);
yield* settlePromptInFlight(threadId, interruptedTurnId, ctx.acpSessionId, {
completedStopReason: "cancelled",
settleAllPrompts: true,
});
} else if (
ctx.promptsInFlight > 0 ||
ctx.session.status === "running" ||
ctx.session.status === "connecting"
) {
const updatedAt = yield* nowIso;
ctx.promptsInFlight = 0;
ctx.activeTurnId = undefined;
const { activeTurnId: _activeTurnId, ...readySession } = ctx.session;
ctx.session = {
...readySession,
status: "ready",
updatedAt,
};
}
}),
);
});
const respondToRequest: GrokAdapterShape["respondToRequest"] = (
threadId,
requestId,
decision,
) =>
Effect.gen(function* () {
const ctx = yield* requireSession(threadId);
const pending = ctx.pendingApprovals.get(requestId);
if (!pending) {
return yield* new ProviderAdapterRequestError({
provider: PROVIDER,
method: "session/request_permission",
detail: `Unknown pending approval request: ${requestId}`,
});
}
yield* Deferred.succeed(pending.decision, decision);
});
const respondToUserInput: GrokAdapterShape["respondToUserInput"] = (
threadId,
requestId,
answers,
) =>
Effect.gen(function* () {
const ctx = yield* requireSession(threadId);
const pending = ctx.pendingUserInputs.get(requestId);
if (!pending) {
return yield* new ProviderAdapterRequestError({
provider: PROVIDER,
method: "_x.ai/ask_user_question",
detail: `Unknown pending user-input request: ${requestId}`,
});
}
yield* Deferred.succeed(pending.resolution, UserInputResolution.answered({ answers }));
});
const readThread: GrokAdapterShape["readThread"] = (threadId) =>
Effect.gen(function* () {
const ctx = yield* requireSession(threadId);
return { threadId, turns: ctx.turns };
});
const rollbackThread: GrokAdapterShape["rollbackThread"] = (threadId, numTurns) =>
Effect.gen(function* () {
yield* requireSession(threadId);
if (!Number.isInteger(numTurns) || numTurns < 1) {
return yield* new ProviderAdapterValidationError({
provider: PROVIDER,
operation: "rollbackThread",
issue: "numTurns must be an integer >= 1.",
});
}
return yield* new ProviderAdapterRequestError({
provider: PROVIDER,
method: "thread/rollback",
detail: "Grok ACP sessions do not support provider-side rollback yet.",
});
});
const stopSession: GrokAdapterShape["stopSession"] = (threadId) =>
withThreadLock(
threadId,
Effect.gen(function* () {
const ctx = yield* requireSession(threadId);
yield* stopSessionInternal(ctx);
}),
);
const listSessions: GrokAdapterShape["listSessions"] = () =>
Effect.sync(() => Array.from(sessions.values(), (c) => ({ ...c.session })));
const hasSession: GrokAdapterShape["hasSession"] = (threadId) =>
Effect.sync(() => {
const c = sessions.get(threadId);
return c !== undefined && !c.stopped;
});
const stopAll: GrokAdapterShape["stopAll"] = () =>
Effect.forEach(Array.from(sessions.values()), stopSessionInternal, { discard: true });
yield* Effect.addFinalizer(() =>
Effect.ignore(stopAll()).pipe(
Effect.tap(() => PubSub.shutdown(runtimeEventPubSub)),
Effect.tap(() => managedNativeEventLogger?.close() ?? Effect.void),
),
);
const streamEvents = Stream.fromPubSub(runtimeEventPubSub);
return {
provider: PROVIDER,
capabilities: { sessionModelSwitch: "in-session" },
startSession,
sendTurn,
interruptTurn,
readThread,
rollbackThread,
respondToRequest,
respondToUserInput,
stopSession,
listSessions,
hasSession,
stopAll,
streamEvents,
} satisfies GrokAdapterShape;
});
}
export {
selectGrokPermissionOptionId,
grokPromptSettlementBelongsToContext,
grokTurnCompletionForPromptEpoch,
} from "./grok/GrokProtocol.ts";
export { type GrokTurnTerminal } from "./grok/GrokAdapterState.ts";