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 * as Match from "effect/Match";
import { mapCodexRequestEvents } from "./CodexRequestEvents.ts";
import { mapCodexTelemetryEvents } from "./CodexTelemetryEvents.ts";
import { type ProviderEvent, type ProviderRuntimeEvent, ThreadId } from "@akeru/contracts";
import * as EffectCodexSchema from "effect-codex-app-server/schema";
import {
readPayload,
trimText,
normalizeCodexTokenUsage,
toTurnStatus,
toCanonicalItemType,
itemDetail,
toRequestTypeFromKind,
toCanonicalUserInputAnswers,
toThreadState,
contentStreamKindFromMethod,
} from "./CodexCanonicalMapping.ts";
import { type CodexTurnTokenUsage } from "./CodexAdapterState.ts";
import { runtimeEventBase } from "./CodexEventIdentity.ts";
import { mapItemLifecycle } from "./CodexItemEvents.ts";
import { mapCollabAgentEvent } from "./CodexCollaborationEvents.ts";
export function mapToRuntimeEvents(
event: ProviderEvent,
canonicalThreadId: ThreadId,
tokenUsageByTurnId?: Map<string, CodexTurnTokenUsage>,
): ReadonlyArray<ProviderRuntimeEvent> {
if (event.kind === "notification" && event.method.startsWith("collabAgent/")) {
return mapCollabAgentEvent(event, canonicalThreadId);
}
const requestEvents = mapCodexRequestEvents(event, canonicalThreadId);
if (requestEvents !== undefined) return requestEvents;
if (event.method === "session/connecting") {
return [
{
...runtimeEventBase(event, canonicalThreadId),
type: "session.state.changed",
payload: {
state: "starting",
...(event.message ? { reason: event.message } : {}),
},
},
];
}
if (event.method === "session/ready") {
return [
{
...runtimeEventBase(event, canonicalThreadId),
type: "session.state.changed",
payload: {
state: "ready",
...(event.message ? { reason: event.message } : {}),
},
},
];
}
if (event.method === "session/started") {
return [
{
...runtimeEventBase(event, canonicalThreadId),
type: "session.started",
payload: {
...(event.message ? { message: event.message } : {}),
...(event.payload !== undefined ? { resume: event.payload } : {}),
},
},
];
}
if (event.method === "session/exited" || event.method === "session/closed") {
return [
{
...runtimeEventBase(event, canonicalThreadId),
type: "session.exited",
payload: {
...(event.message ? { reason: event.message } : {}),
...(event.method === "session/closed" ? { exitKind: "graceful" } : {}),
},
},
];
}
if (event.method === "thread/started") {
const payload = readPayload(EffectCodexSchema.V2ThreadStartedNotification, event.payload);
if (!payload) {
return [];
}
return [
{
...runtimeEventBase(event, canonicalThreadId),
type: "thread.started",
payload: {
providerThreadId: payload.thread.id,
},
},
];
}
if (
event.method === "thread/status/changed" ||
event.method === "thread/archived" ||
event.method === "thread/unarchived" ||
event.method === "thread/closed" ||
event.method === "thread/compacted"
) {
const payload =
event.method === "thread/status/changed"
? readPayload(EffectCodexSchema.V2ThreadStatusChangedNotification, event.payload)
: undefined;
return [
{
type: "thread.state.changed",
...runtimeEventBase(event, canonicalThreadId),
payload: {
state: Match.value(event.method).pipe(
Match.when("thread/archived", () => "archived" as const),
Match.when("thread/closed", () => "closed" as const),
Match.when("thread/compacted", () => "compacted" as const),
Match.orElse(() => (payload ? toThreadState(payload.status) : "active")),
),
...(event.payload !== undefined ? { detail: event.payload } : {}),
},
},
];
}
if (event.method === "thread/name/updated") {
const payload = readPayload(EffectCodexSchema.V2ThreadNameUpdatedNotification, event.payload);
return [
{
type: "thread.metadata.updated",
...runtimeEventBase(event, canonicalThreadId),
payload: {
...(trimText(payload?.threadName) ? { name: trimText(payload?.threadName) } : {}),
...(payload
? {
metadata: {
threadId: payload.threadId,
...(payload.threadName !== undefined && payload.threadName !== null
? { threadName: payload.threadName }
: {}),
},
}
: {}),
},
},
];
}
if (event.method === "thread/tokenUsage/updated") {
const payload = readPayload(
EffectCodexSchema.V2ThreadTokenUsageUpdatedNotification,
event.payload,
);
if (!payload) {
return [];
}
const normalizedUsage = normalizeCodexTokenUsage(
payload.tokenUsage,
tokenUsageByTurnId?.get(payload.turnId),
);
if (!normalizedUsage) return [];
tokenUsageByTurnId?.set(payload.turnId, normalizedUsage.total);
return [
{
type: "thread.token-usage.updated",
...runtimeEventBase(event, canonicalThreadId),
payload: {
usage: normalizedUsage.snapshot,
},
},
];
}
if (event.method === "turn/started") {
const turnId = event.turnId;
if (!turnId) {
return [];
}
tokenUsageByTurnId?.delete(turnId);
return [
{
...runtimeEventBase(event, canonicalThreadId),
turnId,
type: "turn.started",
payload: {},
},
];
}
if (event.method === "turn/completed") {
const payload = readPayload(EffectCodexSchema.V2TurnCompletedNotification, event.payload);
if (!payload) {
return [];
}
if (event.turnId) tokenUsageByTurnId?.delete(event.turnId);
const errorMessage = trimText(payload.turn.error?.message);
return [
{
...runtimeEventBase(event, canonicalThreadId),
type: "turn.completed",
payload: {
state: toTurnStatus(payload.turn.status),
...(errorMessage ? { errorMessage } : {}),
},
},
];
}
if (event.method === "turn/aborted") {
if (event.turnId) tokenUsageByTurnId?.delete(event.turnId);
return [
{
...runtimeEventBase(event, canonicalThreadId),
type: "turn.aborted",
payload: {
reason: event.message ?? "Turn aborted",
},
},
];
}
if (event.method === "turn/plan/updated") {
const payload = readPayload(EffectCodexSchema.V2TurnPlanUpdatedNotification, event.payload);
if (!payload) {
return [];
}
return [
{
...runtimeEventBase(event, canonicalThreadId),
type: "turn.plan.updated",
payload: {
...(trimText(payload.explanation) ? { explanation: trimText(payload.explanation) } : {}),
plan: payload.plan.map((step) => ({
step: trimText(step.step) ?? "step",
status:
step.status === "completed" || step.status === "inProgress" ? step.status : "pending",
})),
},
},
];
}
if (event.method === "turn/diff/updated") {
const payload = readPayload(EffectCodexSchema.V2TurnDiffUpdatedNotification, event.payload);
if (!payload) {
return [];
}
return [
{
...runtimeEventBase(event, canonicalThreadId),
type: "turn.diff.updated",
payload: {
unifiedDiff: payload.diff,
},
},
];
}
if (event.method === "item/started") {
const started = mapItemLifecycle(event, canonicalThreadId, "item.started");
return started ? [started] : [];
}
if (event.method === "item/completed") {
const payload = readPayload(EffectCodexSchema.V2ItemCompletedNotification, event.payload);
const item = payload?.item;
if (!item) {
return [];
}
const itemType = toCanonicalItemType(item.type);
if (itemType === "plan") {
const detail = itemDetail(itemType, item);
if (!detail) {
return [];
}
return [
{
...runtimeEventBase(event, canonicalThreadId),
type: "turn.proposed.completed",
payload: {
planMarkdown: detail,
},
},
];
}
const completed = mapItemLifecycle(event, canonicalThreadId, "item.completed");
return completed ? [completed] : [];
}
if (
event.method === "item/reasoning/summaryPartAdded" ||
event.method === "item/commandExecution/terminalInteraction"
) {
return [
{
...runtimeEventBase(event, canonicalThreadId),
type: "item.updated",
payload: {
itemType:
event.method === "item/reasoning/summaryPartAdded" ? "reasoning" : "command_execution",
...(event.payload !== undefined ? { data: event.payload } : {}),
},
},
];
}
if (event.method === "item/plan/delta") {
const payload = readPayload(EffectCodexSchema.V2PlanDeltaNotification, event.payload);
const delta = event.textDelta ?? payload?.delta;
if (!delta || delta.length === 0) {
return [];
}
return [
{
...runtimeEventBase(event, canonicalThreadId),
type: "turn.proposed.delta",
payload: {
delta,
},
},
];
}
if (event.method === "item/agentMessage/delta") {
const payload = readPayload(EffectCodexSchema.V2AgentMessageDeltaNotification, event.payload);
const delta = event.textDelta ?? payload?.delta;
if (!delta || delta.length === 0) {
return [];
}
return [
{
...runtimeEventBase(event, canonicalThreadId),
type: "content.delta",
payload: {
streamKind: contentStreamKindFromMethod(event.method),
delta,
},
},
];
}
if (event.method === "item/commandExecution/outputDelta") {
const payload = readPayload(
EffectCodexSchema.V2CommandExecutionOutputDeltaNotification,
event.payload,
);
const delta = event.textDelta ?? payload?.delta;
if (!delta || delta.length === 0) {
return [];
}
return [
{
...runtimeEventBase(event, canonicalThreadId),
type: "content.delta",
payload: {
streamKind: "command_output",
delta,
},
},
];
}
if (event.method === "item/fileChange/outputDelta") {
const payload = readPayload(
EffectCodexSchema.V2FileChangeOutputDeltaNotification,
event.payload,
);
const delta = event.textDelta ?? payload?.delta;
if (!delta || delta.length === 0) {
return [];
}
return [
{
...runtimeEventBase(event, canonicalThreadId),
type: "content.delta",
payload: {
streamKind: "file_change_output",
delta,
},
},
];
}
if (event.method === "item/reasoning/summaryTextDelta") {
const payload = readPayload(
EffectCodexSchema.V2ReasoningSummaryTextDeltaNotification,
event.payload,
);
const delta = event.textDelta ?? payload?.delta;
if (!delta || delta.length === 0) {
return [];
}
return [
{
...runtimeEventBase(event, canonicalThreadId),
type: "content.delta",
payload: {
streamKind: "reasoning_summary_text",
delta,
...(payload ? { summaryIndex: payload.summaryIndex } : {}),
},
},
];
}
if (event.method === "item/reasoning/textDelta") {
const payload = readPayload(EffectCodexSchema.V2ReasoningTextDeltaNotification, event.payload);
const delta = event.textDelta ?? payload?.delta;
if (!delta || delta.length === 0) {
return [];
}
return [
{
...runtimeEventBase(event, canonicalThreadId),
type: "content.delta",
payload: {
streamKind: "reasoning_text",
delta,
...(payload ? { contentIndex: payload.contentIndex } : {}),
},
},
];
}
if (event.method === "item/mcpToolCall/progress") {
const payload = readPayload(EffectCodexSchema.V2McpToolCallProgressNotification, event.payload);
if (!payload) {
return [];
}
return [
{
...runtimeEventBase(event, canonicalThreadId),
type: "tool.progress",
payload: {
summary: payload.message,
},
},
];
}
if (event.method === "serverRequest/resolved") {
const payload = readPayload(
EffectCodexSchema.V2ServerRequestResolvedNotification,
event.payload,
);
if (!payload) {
return [];
}
const requestType = toRequestTypeFromKind(event.requestKind);
return [
{
...runtimeEventBase(event, canonicalThreadId),
type: "request.resolved",
payload: {
requestType,
...(event.payload !== undefined ? { resolution: event.payload } : {}),
},
},
];
}
if (event.method === "item/tool/requestUserInput/answered") {
const payload = readPayload(EffectCodexSchema.ToolRequestUserInputResponse, event.payload);
if (!payload) {
return [];
}
return [
{
...runtimeEventBase(event, canonicalThreadId),
type: "user-input.resolved",
payload: {
answers: toCanonicalUserInputAnswers(payload.answers),
},
},
];
}
return mapCodexTelemetryEvents(event, canonicalThreadId) ?? [];
}