Files
lolympus-agent/src/skills/onboarding/runtime/trace.ts
T

170 lines
4.4 KiB
TypeScript

import { AsyncLocalStorage } from "node:async_hooks";
export type ProcessTraceStepName =
| "classify"
| "critic"
| "derive"
| "plan"
| "respond"
| "tool-call"
| "validate";
export interface ProcessTraceStep<T> {
name: ProcessTraceStepName;
startedAtMs: number;
durationMs: number;
output: T;
}
export interface ProcessTraceSnapshot {
steps: {
classify?: ProcessTraceStep<{
confidence: number;
intent: string;
source: "regex" | "llm";
}> | undefined;
derive?: ProcessTraceStep<{
phase: string;
responseMode: string;
shouldRespond: boolean;
tier: 0 | 1 | 2;
}> | undefined;
plan?: ProcessTraceStep<{
approach: string;
mustAvoid: string[];
mustInclude: string[];
suggestedTools: string[];
targetLengthChars: number;
}> | undefined;
toolCalls?: Array<
ProcessTraceStep<{
args: unknown;
name: string;
ok: boolean;
resultSummary: string;
}>
> | undefined;
respond?: ProcessTraceStep<{
draftText: string;
tokensIn: number;
tokensOut: number;
}> | undefined;
critic?: ProcessTraceStep<{
decision: "keep" | "rewrite";
rationale: string;
}> | undefined;
validate?: ProcessTraceStep<{
reasons: string[];
status: "pass" | "reject" | "soft-warn";
}> | undefined;
};
}
type ProcessTraceOutputByName = {
classify: NonNullable<ProcessTraceSnapshot["steps"]["classify"]>["output"];
critic: NonNullable<ProcessTraceSnapshot["steps"]["critic"]>["output"];
derive: NonNullable<ProcessTraceSnapshot["steps"]["derive"]>["output"];
plan: NonNullable<ProcessTraceSnapshot["steps"]["plan"]>["output"];
respond: NonNullable<ProcessTraceSnapshot["steps"]["respond"]>["output"];
"tool-call": NonNullable<
NonNullable<ProcessTraceSnapshot["steps"]["toolCalls"]>[number]
>["output"];
validate: NonNullable<ProcessTraceSnapshot["steps"]["validate"]>["output"];
};
const processTraceStorage = new AsyncLocalStorage<ProcessTraceCollector>();
export class ProcessTraceCollector {
private readonly steps: ProcessTraceSnapshot["steps"] = {};
startStep<Name extends ProcessTraceStepName>(
name: Name,
): {
finish: (output: ProcessTraceOutputByName[Name]) => void;
} {
const startedAtMs = Date.now();
let finished = false;
return {
finish: (output: ProcessTraceOutputByName[Name]): void => {
if (finished) {
return;
}
finished = true;
const step: ProcessTraceStep<ProcessTraceOutputByName[Name]> = {
name,
startedAtMs,
durationMs: Math.max(0, Date.now() - startedAtMs),
output,
};
if (name === "tool-call") {
this.steps.toolCalls = [
...(this.steps.toolCalls ?? []),
step as ProcessTraceStep<
ProcessTraceOutputByName["tool-call"]
>,
];
return;
}
switch (name) {
case "classify":
this.steps.classify = step as ProcessTraceStep<
ProcessTraceOutputByName["classify"]
>;
return;
case "critic":
this.steps.critic = step as ProcessTraceStep<
ProcessTraceOutputByName["critic"]
>;
return;
case "derive":
this.steps.derive = step as ProcessTraceStep<
ProcessTraceOutputByName["derive"]
>;
return;
case "plan":
this.steps.plan = step as ProcessTraceStep<
ProcessTraceOutputByName["plan"]
>;
return;
case "respond":
this.steps.respond = step as ProcessTraceStep<
ProcessTraceOutputByName["respond"]
>;
return;
case "validate":
this.steps.validate = step as ProcessTraceStep<
ProcessTraceOutputByName["validate"]
>;
return;
}
},
};
}
snapshot(): ProcessTraceSnapshot {
return {
steps: {
...this.steps,
toolCalls: this.steps.toolCalls
? [...this.steps.toolCalls]
: undefined,
},
};
}
}
export function runWithProcessTrace<T>(
collector: ProcessTraceCollector,
fn: () => T,
): T {
return processTraceStorage.run(collector, fn);
}
export function getActiveProcessTrace(): ProcessTraceCollector | undefined {
return processTraceStorage.getStore();
}