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 { ActivityValue, ActivityRecord } from "./ActivityPayloadBounds.ts";
import * as Predicate from "effect/Predicate";
import type {
OrchestrationEvent,
OrchestrationThreadActivity,
OrchestrationThreadDetailSnapshot,
} from "@akeru/contracts";
import { AkeruPluginSearchResult } from "@akeru/contracts";
import * as Option from "effect/Option";
import * as Schema from "effect/Schema";
import { asRecord, asTrimmedString, projectBoundedValue } from "./ActivityPayloadBounds.ts";
import {
summarizeToolTextOutput,
projectCommandData,
projectCommandValue,
collectChangedFiles,
} from "./CommandActivityPayload.ts";
import { projectMcpToolCallData } from "./McpActivityPayload.ts";
import {
dropSupersededToolUpdatedActivities,
dropStaleContextWindowActivities,
} from "./ActivityRetention.ts";
const decodePluginSearchResult = Schema.decodeUnknownOption(AkeruPluginSearchResult);
/**
* Task-list tools (Akeru's `task_write`, Claude's `TodoWrite`) carry the whole
* list in their args. Clients only show the step in progress, as a short status.
*/
function projectMemoryOperationCount(data: ActivityRecord): number | undefined {
const operations = asRecord(data.args)?.operations;
return Array.isArray(operations) ? operations.length : undefined;
}
function projectRawOutput(value: ActivityValue): ActivityRecord | undefined {
const direct = asTrimmedString(value);
if (direct) {
const summary = summarizeToolTextOutput(direct);
return summary ? { content: summary } : undefined;
}
const rawOutput = asRecord(value);
if (!rawOutput) {
return undefined;
}
if (Predicate.isNumber(rawOutput.totalFiles) && Number.isFinite(rawOutput.totalFiles)) {
return {
totalFiles: rawOutput.totalFiles,
...(rawOutput.truncated === true ? { truncated: true } : {}),
};
}
const content = asTrimmedString(rawOutput.content);
if (content) {
const summary = summarizeToolTextOutput(content);
return summary ? { content: summary } : undefined;
}
const stdout = asTrimmedString(rawOutput.stdout);
if (stdout) {
const summary = summarizeToolTextOutput(stdout);
return summary ? { content: summary } : undefined;
}
const stderr = asTrimmedString(rawOutput.stderr);
if (stderr) {
const summary = summarizeToolTextOutput(stderr);
return summary ? { content: summary } : undefined;
}
return undefined;
}
function projectAcpContent(value: ActivityValue): ActivityRecord | undefined {
if (!Array.isArray(value)) {
return undefined;
}
const text = value
.map((entryValue) => {
const entry = asRecord(entryValue);
const content = asRecord(entry?.content);
return entry?.type === "content" && content?.type === "text"
? asTrimmedString(content.text)
: null;
})
.filter((entry): entry is string => entry !== null)
.join("\n");
const summary = summarizeToolTextOutput(text);
return summary ? { content: summary } : undefined;
}
function projectPluginSearchResult(value: ActivityValue): AkeruPluginSearchResult | undefined {
const decoded = decodePluginSearchResult(value);
if (Option.isNone(decoded)) return undefined;
return {
...decoded.value,
recommendations: decoded.value.recommendations.slice(0, 6),
};
}
/**
* Removes activity payload fields that no current client reads while retaining
* the full payload in persistence and the event store.
*/
export function projectActivityPayload(
activity: OrchestrationThreadActivity,
): OrchestrationThreadActivity {
const payload = asRecord(activity.payload);
const data = asRecord(payload?.data);
if (!payload || !data) {
return activity;
}
const itemStatus = asRecord(data.item)?.status;
const projectedPayload =
payload.status === "completed" && (itemStatus === "failed" || itemStatus === "declined")
? { ...payload, status: itemStatus }
: payload;
if (payload.itemType === "mcp_tool_call") {
return {
...activity,
payload: {
...projectedPayload,
data: projectMcpToolCallData(data),
},
};
}
if (payload.itemType === "dynamic_tool_call" && activity.summary === "SearchPlugins") {
const result = projectPluginSearchResult(data.result);
if (result) {
return {
...activity,
payload: {
...projectedPayload,
data: {
result,
...(data.toolCallId !== undefined ? { toolCallId: data.toolCallId } : {}),
},
},
};
}
}
const projectedData: ActivityRecord = {};
const item = projectCommandData(data);
if (item) {
projectedData.item = item;
}
const command = projectCommandValue(data);
if (command !== undefined) {
projectedData.command = projectBoundedValue(command);
}
const changedFiles: string[] = [];
collectChangedFiles(data, changedFiles, new Set<string>(), 0);
if (changedFiles.length > 0) {
// Both clients discover file names by walking objects with path-like keys.
projectedData.files = changedFiles.map((path) => ({ path }));
}
if ("toolCallId" in data) {
projectedData.toolCallId = data.toolCallId;
}
if ("kind" in data) {
projectedData.kind = data.kind;
}
const memoryOperationCount = projectMemoryOperationCount(data);
if (memoryOperationCount !== undefined) {
projectedData.memoryOperationCount = memoryOperationCount;
}
const rawOutput = projectRawOutput(data.rawOutput) ?? projectAcpContent(data.content);
if (rawOutput) {
projectedData.rawOutput = rawOutput;
}
return {
...activity,
payload: {
...projectedPayload,
data: projectedData,
},
};
}
export function projectThreadDetailSnapshot(
snapshot: OrchestrationThreadDetailSnapshot,
): OrchestrationThreadDetailSnapshot {
return {
...snapshot,
thread: {
...snapshot.thread,
activities: dropSupersededToolUpdatedActivities(
dropStaleContextWindowActivities(snapshot.thread.activities),
).map(projectActivityPayload),
},
};
}
// Published events are immutable and shared by every live subscriber. Project
// each one once so subscribers share the projected object, which also lets the
// live stream budget reuse its serialized-size measurement.
const projectedActivityEvents = new WeakMap<OrchestrationEvent, OrchestrationEvent>();
export function projectActivityEvent(event: OrchestrationEvent): OrchestrationEvent {
if (event.type !== "thread.activity-appended") {
return event;
}
const cached = projectedActivityEvents.get(event);
if (cached !== undefined) {
return cached;
}
const projected: OrchestrationEvent = {
...event,
payload: {
...event.payload,
activity: projectActivityPayload(event.payload.activity),
},
};
projectedActivityEvents.set(event, projected);
// Mark the result as already projected so a repeat call returns it unchanged.
projectedActivityEvents.set(projected, projected);
return projected;
}