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 { ApprovalRequestId } from "@akeru/contracts";
import * as Predicate from "effect/Predicate";
import {
AKERU_MEMORY_APPROVAL_REQUESTED_ACTIVITY,
type OrchestrationCommand,
type OrchestrationEvent,
type OrchestrationReadModel,
} from "@akeru/contracts";
import * as Crypto from "effect/Crypto";
import * as Effect from "effect/Effect";
import type * as PlatformError from "effect/PlatformError";
import { OrchestrationCommandInvariantError } from "../Errors.ts";
import type { OrchestrationDispatchActor } from "../Services/OrchestrationEngine.ts";
import { requireThread } from "../commandInvariants.ts";
import {
withEventBase,
threadHasQueuedTurnStart,
type DecideOrchestrationCommandResult,
} from "./eventBase.ts";
export const decideThreadObservations = Effect.fn("decideThreadObservations")(function* ({
command,
readModel,
}: {
readonly command: Extract<
OrchestrationCommand,
{
type:
| "thread.checkpoint.revert"
| "thread.session.stop"
| "thread.session.set"
| "thread.revert.complete"
| "thread.activity.append";
}
>;
readonly readModel: OrchestrationReadModel;
readonly actor?: OrchestrationDispatchActor;
}): Effect.fn.Return<
DecideOrchestrationCommandResult,
OrchestrationCommandInvariantError | PlatformError.PlatformError,
Crypto.Crypto
> {
switch (command.type) {
case "thread.checkpoint.revert": {
yield* requireThread({
readModel,
command,
threadId: command.threadId,
});
return {
...(yield* withEventBase({
aggregateKind: "thread",
aggregateId: command.threadId,
occurredAt: command.createdAt,
commandId: command.commandId,
})),
type: "thread.checkpoint-revert-requested",
payload: {
threadId: command.threadId,
turnCount: command.turnCount,
createdAt: command.createdAt,
},
};
}
case "thread.session.stop": {
const thread = yield* requireThread({
readModel,
command,
threadId: command.threadId,
});
// Settle-cleanup stops are conditional: between the settle landing and
// this command, another client may have re-engaged the thread (a turn
// start unsettles it and brings the session alive). Commands are
// decided serially against this read model, so checking here — not in
// the dispatcher's pre-settle snapshot — closes that race.
if (command.onlyIfSettled === true) {
const sessionComingAlive =
thread.session?.status === "starting" || thread.session?.status === "running";
if (
thread.settledOverride !== "settled" ||
sessionComingAlive ||
threadHasQueuedTurnStart(thread, command.createdAt)
) {
return yield* new OrchestrationCommandInvariantError({
commandType: command.type,
detail: `thread ${command.threadId} was re-engaged after settle; skipping session stop`,
});
}
}
return {
...(yield* withEventBase({
aggregateKind: "thread",
aggregateId: command.threadId,
occurredAt: command.createdAt,
commandId: command.commandId,
})),
type: "thread.session-stop-requested",
payload: {
threadId: command.threadId,
createdAt: command.createdAt,
},
};
}
case "thread.session.set": {
const thread = yield* requireThread({
readModel,
command,
threadId: command.threadId,
});
const sessionSetEvent: Omit<OrchestrationEvent, "sequence"> = {
...(yield* withEventBase({
aggregateKind: "thread",
aggregateId: command.threadId,
occurredAt: command.createdAt,
commandId: command.commandId,
metadata: {},
})),
type: "thread.session-set",
payload: {
threadId: command.threadId,
session: command.session,
},
};
// Only a session coming alive is activity worth waking a settled thread
// for — status writes like ready/stopped/error arrive after the fact and
// must not fight a user's explicit settle. Snooze is deliberately NOT
// cleared here: snooze never pauses the agent, so its session starting
// or erroring is not the user re-engaging. Blocked/failed work still
// surfaces immediately — effectiveSnoozed refuses to classify a thread
// with a raised hand (approval / input / failure / fresh completion)
// as snoozed, without spending the return ticket.
const isSessionActivity =
command.session.status === "starting" || command.session.status === "running";
// Real activity resets ANY override (settled wakes, active unpins).
if (thread.settledOverride === null || !isSessionActivity) {
return sessionSetEvent;
}
const unsettledEvent: Omit<OrchestrationEvent, "sequence"> = {
...(yield* withEventBase({
aggregateKind: "thread",
aggregateId: command.threadId,
occurredAt: command.createdAt,
commandId: command.commandId,
})),
type: "thread.unsettled",
payload: {
threadId: command.threadId,
reason: "activity",
updatedAt: command.createdAt,
},
};
return [unsettledEvent, sessionSetEvent];
}
case "thread.revert.complete": {
yield* requireThread({
readModel,
command,
threadId: command.threadId,
});
return {
...(yield* withEventBase({
aggregateKind: "thread",
aggregateId: command.threadId,
occurredAt: command.createdAt,
commandId: command.commandId,
})),
type: "thread.reverted",
payload: {
threadId: command.threadId,
turnCount: command.turnCount,
},
};
}
case "thread.activity.append": {
const thread = yield* requireThread({
readModel,
command,
threadId: command.threadId,
});
const requestPayload = command.activity.payload;
const requestId =
Predicate.isObjectOrArray(requestPayload) &&
"requestId" in requestPayload &&
Predicate.isString(requestPayload.requestId)
? ApprovalRequestId.make(requestPayload.requestId)
: undefined;
const activityAppendedEvent: Omit<OrchestrationEvent, "sequence"> = {
...(yield* withEventBase({
aggregateKind: "thread",
aggregateId: command.threadId,
occurredAt: command.createdAt,
commandId: command.commandId,
...(requestId !== undefined ? { metadata: { requestId } } : {}),
})),
type: "thread.activity-appended",
payload: {
threadId: command.threadId,
activity: command.activity,
},
};
// An approval or user-input request is blocked-on-you work — it must
// never stay hidden inside a settled slim row.
const wakesSettledThread =
command.activity.kind === "approval.requested" ||
command.activity.kind === "user-input.requested" ||
command.activity.kind === AKERU_MEMORY_APPROVAL_REQUESTED_ACTIVITY;
// Real activity resets ANY override (settled wakes, active unpins).
if (thread.settledOverride === null || !wakesSettledThread) {
return activityAppendedEvent;
}
const unsettledEvent: Omit<OrchestrationEvent, "sequence"> = {
...(yield* withEventBase({
aggregateKind: "thread",
aggregateId: command.threadId,
occurredAt: command.createdAt,
commandId: command.commandId,
})),
type: "thread.unsettled",
payload: {
threadId: command.threadId,
reason: "activity",
updatedAt: command.createdAt,
},
};
return [unsettledEvent, activityAppendedEvent];
}
}
});