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 { MessageId, ThreadId, TurnId, type ProviderRuntimeEvent } from "@akeru/contracts";
import * as Cache from "effect/Cache";
import * as Effect from "effect/Effect";
import * as Option from "effect/Option";
import {
TURN_MESSAGE_IDS_BY_TURN_CACHE_CAPACITY,
TURN_MESSAGE_IDS_BY_TURN_TTL,
BUFFERED_MESSAGE_TEXT_BY_MESSAGE_ID_CACHE_CAPACITY,
BUFFERED_MESSAGE_TEXT_BY_MESSAGE_ID_TTL,
type AssistantSegmentState,
providerTurnKey,
assistantSegmentMessageId,
assistantSegmentBaseKeyFromEvent,
MAX_BUFFERED_ASSISTANT_CHARS,
hasRenderableAssistantText,
} from "./EventFields.ts";
import type { createDependencies } from "./Dependencies.ts";
import type { createContext } from "./Context.ts";
export const createMessages = Effect.fn("makeRuntimeMessages")(function* ({
orchestrationEngine,
providerCommandId,
}: Pick<
Effect.Success<ReturnType<typeof createDependencies>> & ReturnType<typeof createContext>,
"orchestrationEngine" | "providerCommandId"
>) {
const turnMessageIdsByTurnKey = yield* Cache.make<string, Set<MessageId>>({
capacity: TURN_MESSAGE_IDS_BY_TURN_CACHE_CAPACITY,
timeToLive: TURN_MESSAGE_IDS_BY_TURN_TTL,
lookup: () => Effect.succeed(new Set<MessageId>()),
});
const bufferedAssistantTextByMessageId = yield* Cache.make<MessageId, string>({
capacity: BUFFERED_MESSAGE_TEXT_BY_MESSAGE_ID_CACHE_CAPACITY,
timeToLive: BUFFERED_MESSAGE_TEXT_BY_MESSAGE_ID_TTL,
lookup: () => Effect.succeed(""),
});
const assistantSegmentStateByTurnKey = yield* Cache.make<string, AssistantSegmentState>({
capacity: TURN_MESSAGE_IDS_BY_TURN_CACHE_CAPACITY,
timeToLive: TURN_MESSAGE_IDS_BY_TURN_TTL,
lookup: () =>
Effect.die(
new Error("assistant segment state should be read through getOption before initialization"),
),
});
const rememberAssistantMessageId = (threadId: ThreadId, turnId: TurnId, messageId: MessageId) =>
Cache.getOption(turnMessageIdsByTurnKey, providerTurnKey(threadId, turnId)).pipe(
Effect.flatMap((existingIds) =>
Cache.set(
turnMessageIdsByTurnKey,
providerTurnKey(threadId, turnId),
Option.match(existingIds, {
onNone: () => new Set([messageId]),
onSome: (ids) => {
const nextIds = new Set(ids);
nextIds.add(messageId);
return nextIds;
},
}),
),
),
);
const forgetAssistantMessageId = (threadId: ThreadId, turnId: TurnId, messageId: MessageId) =>
Cache.getOption(turnMessageIdsByTurnKey, providerTurnKey(threadId, turnId)).pipe(
Effect.flatMap((existingIds) =>
Option.match(existingIds, {
onNone: () => Effect.void,
onSome: (ids) => {
const nextIds = new Set(ids);
nextIds.delete(messageId);
if (nextIds.size === 0) {
return Cache.invalidate(turnMessageIdsByTurnKey, providerTurnKey(threadId, turnId));
}
return Cache.set(turnMessageIdsByTurnKey, providerTurnKey(threadId, turnId), nextIds);
},
}),
),
);
const getAssistantMessageIdsForTurn = (threadId: ThreadId, turnId: TurnId) =>
Cache.getOption(turnMessageIdsByTurnKey, providerTurnKey(threadId, turnId)).pipe(
Effect.map((existingIds) =>
Option.getOrElse(existingIds, (): Set<MessageId> => new Set<MessageId>()),
),
);
const clearAssistantMessageIdsForTurn = (threadId: ThreadId, turnId: TurnId) =>
Cache.invalidate(turnMessageIdsByTurnKey, providerTurnKey(threadId, turnId));
const getAssistantSegmentStateForTurn = (threadId: ThreadId, turnId: TurnId) =>
Cache.getOption(assistantSegmentStateByTurnKey, providerTurnKey(threadId, turnId));
const setAssistantSegmentStateForTurn = (
threadId: ThreadId,
turnId: TurnId,
state: AssistantSegmentState,
) => Cache.set(assistantSegmentStateByTurnKey, providerTurnKey(threadId, turnId), state);
const clearAssistantSegmentStateForTurn = (threadId: ThreadId, turnId: TurnId) =>
Cache.invalidate(assistantSegmentStateByTurnKey, providerTurnKey(threadId, turnId));
const getActiveAssistantMessageIdForTurn = (threadId: ThreadId, turnId: TurnId) =>
getAssistantSegmentStateForTurn(threadId, turnId).pipe(
Effect.map((state) =>
Option.flatMap(state, (entry) =>
entry.activeMessageId ? Option.some(entry.activeMessageId) : Option.none(),
),
),
);
const startAssistantSegmentForTurn = (input: {
threadId: ThreadId;
turnId: TurnId;
baseKey: string;
}) =>
getAssistantSegmentStateForTurn(input.threadId, input.turnId).pipe(
Effect.flatMap((existingState) =>
Effect.gen(function* () {
const nextState = Option.match(existingState, {
onNone: () => ({
baseKey: input.baseKey,
nextSegmentIndex: 1,
activeMessageId: assistantSegmentMessageId(input.baseKey, 0),
}),
onSome: (state) => {
const segmentIndex = state.baseKey === input.baseKey ? state.nextSegmentIndex : 0;
const messageId = assistantSegmentMessageId(input.baseKey, segmentIndex);
return {
baseKey: input.baseKey,
nextSegmentIndex: state.baseKey === input.baseKey ? state.nextSegmentIndex + 1 : 1,
activeMessageId: messageId,
} satisfies AssistantSegmentState;
},
});
yield* setAssistantSegmentStateForTurn(input.threadId, input.turnId, nextState);
return nextState.activeMessageId!;
}),
),
);
const getOrCreateAssistantMessageId = (input: {
threadId: ThreadId;
event: ProviderRuntimeEvent;
turnId?: TurnId;
}) =>
Effect.gen(function* () {
if (!input.turnId) {
return assistantSegmentMessageId(assistantSegmentBaseKeyFromEvent(input.event), 0);
}
const activeMessageId = yield* getActiveAssistantMessageIdForTurn(
input.threadId,
input.turnId,
);
if (Option.isSome(activeMessageId)) {
return activeMessageId.value;
}
return yield* startAssistantSegmentForTurn({
threadId: input.threadId,
turnId: input.turnId,
baseKey: assistantSegmentBaseKeyFromEvent(input.event),
});
});
const appendBufferedAssistantText = (messageId: MessageId, delta: string) =>
Cache.getOption(bufferedAssistantTextByMessageId, messageId).pipe(
Effect.flatMap((existingText) =>
Effect.gen(function* () {
const nextText = Option.match(existingText, {
onNone: () => delta,
onSome: (text) => `${text}${delta}`,
});
if (nextText.length <= MAX_BUFFERED_ASSISTANT_CHARS) {
yield* Cache.set(bufferedAssistantTextByMessageId, messageId, nextText);
return "";
}
// Safety valve: flush full buffered text as an assistant delta to cap memory.
yield* Cache.invalidate(bufferedAssistantTextByMessageId, messageId);
return nextText;
}),
),
);
const takeBufferedAssistantText = (messageId: MessageId) =>
Cache.getOption(bufferedAssistantTextByMessageId, messageId).pipe(
Effect.flatMap((existingText) =>
Cache.invalidate(bufferedAssistantTextByMessageId, messageId).pipe(
Effect.as(Option.getOrElse(existingText, () => "")),
),
),
);
const clearBufferedAssistantText = (messageId: MessageId) =>
Cache.invalidate(bufferedAssistantTextByMessageId, messageId);
const clearAssistantMessageState = (messageId: MessageId) =>
clearBufferedAssistantText(messageId);
const flushBufferedAssistantMessage = (input: {
event: ProviderRuntimeEvent;
threadId: ThreadId;
messageId: MessageId;
turnId?: TurnId;
createdAt: string;
commandTag: string;
}) =>
Effect.gen(function* () {
const bufferedText = yield* takeBufferedAssistantText(input.messageId);
if (!hasRenderableAssistantText(bufferedText)) {
return false;
}
yield* orchestrationEngine.dispatch({
type: "thread.message.assistant.delta",
commandId: yield* providerCommandId(input.event, input.commandTag),
threadId: input.threadId,
messageId: input.messageId,
delta: bufferedText,
...(input.turnId ? { turnId: input.turnId } : {}),
createdAt: input.createdAt,
});
return true;
});
const flushBufferedAssistantMessagesForTurn = (input: {
event: ProviderRuntimeEvent;
threadId: ThreadId;
turnId: TurnId;
createdAt: string;
commandTag: string;
}) =>
Effect.gen(function* () {
const assistantMessageIds = yield* getAssistantMessageIdsForTurn(
input.threadId,
input.turnId,
);
const flushedMessageIds = new Set<MessageId>();
yield* Effect.forEach(
assistantMessageIds,
(messageId) =>
flushBufferedAssistantMessage({
event: input.event,
threadId: input.threadId,
messageId,
turnId: input.turnId,
createdAt: input.createdAt,
commandTag: input.commandTag,
}).pipe(
Effect.tap((flushed) =>
flushed ? Effect.sync(() => flushedMessageIds.add(messageId)) : Effect.void,
),
),
{ concurrency: 1 },
).pipe(Effect.asVoid);
return flushedMessageIds;
});
const finalizeAssistantMessage = (input: {
event: ProviderRuntimeEvent;
threadId: ThreadId;
messageId: MessageId;
turnId?: TurnId;
createdAt: string;
commandTag: string;
finalDeltaCommandTag: string;
fallbackText?: string;
hasProjectedMessage?: boolean;
}) =>
Effect.gen(function* () {
const bufferedText = yield* takeBufferedAssistantText(input.messageId);
const text =
bufferedText.length > 0
? bufferedText
: (input.fallbackText?.trim().length ?? 0) > 0
? input.fallbackText!
: "";
const hasRenderableText = hasRenderableAssistantText(text);
if (hasRenderableText) {
yield* orchestrationEngine.dispatch({
type: "thread.message.assistant.delta",
commandId: yield* providerCommandId(input.event, input.finalDeltaCommandTag),
threadId: input.threadId,
messageId: input.messageId,
delta: text,
...(input.turnId ? { turnId: input.turnId } : {}),
createdAt: input.createdAt,
});
}
if (input.hasProjectedMessage || hasRenderableText) {
yield* orchestrationEngine.dispatch({
type: "thread.message.assistant.complete",
commandId: yield* providerCommandId(input.event, input.commandTag),
threadId: input.threadId,
messageId: input.messageId,
...(input.turnId ? { turnId: input.turnId } : {}),
createdAt: input.createdAt,
});
}
yield* clearAssistantMessageState(input.messageId);
return Boolean(input.hasProjectedMessage || hasRenderableText);
});
const finalizeActiveAssistantSegmentForTurn = (input: {
event: ProviderRuntimeEvent;
threadId: ThreadId;
turnId: TurnId;
createdAt: string;
commandTag: string;
finalDeltaCommandTag: string;
hasProjectedMessage: boolean;
flushedMessageIds?: ReadonlySet<MessageId>;
}) =>
Effect.gen(function* () {
const activeMessageId = yield* getActiveAssistantMessageIdForTurn(
input.threadId,
input.turnId,
);
if (Option.isNone(activeMessageId)) {
return;
}
yield* finalizeAssistantMessage({
event: input.event,
threadId: input.threadId,
messageId: activeMessageId.value,
turnId: input.turnId,
createdAt: input.createdAt,
commandTag: input.commandTag,
finalDeltaCommandTag: input.finalDeltaCommandTag,
hasProjectedMessage:
input.hasProjectedMessage ||
(input.flushedMessageIds?.has(activeMessageId.value) ?? false),
});
yield* forgetAssistantMessageId(input.threadId, input.turnId, activeMessageId.value);
const state = yield* getAssistantSegmentStateForTurn(input.threadId, input.turnId);
if (Option.isSome(state)) {
yield* setAssistantSegmentStateForTurn(input.threadId, input.turnId, {
...state.value,
activeMessageId: null,
});
}
});
return {
turnMessageIdsByTurnKey,
bufferedAssistantTextByMessageId,
assistantSegmentStateByTurnKey,
rememberAssistantMessageId,
forgetAssistantMessageId,
getAssistantMessageIdsForTurn,
clearAssistantMessageIdsForTurn,
getAssistantSegmentStateForTurn,
setAssistantSegmentStateForTurn,
clearAssistantSegmentStateForTurn,
getActiveAssistantMessageIdForTurn,
startAssistantSegmentForTurn,
getOrCreateAssistantMessageId,
appendBufferedAssistantText,
takeBufferedAssistantText,
clearBufferedAssistantText,
clearAssistantMessageState,
flushBufferedAssistantMessage,
flushBufferedAssistantMessagesForTurn,
finalizeAssistantMessage,
finalizeActiveAssistantSegmentForTurn,
};
});