@jack200714/mafw 4.5.1

package/gateway/dist/trajectory/api.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleTrajectoryRequest = handleTrajectoryRequest;
+async function handleTrajectoryRequest(ctx) {
+    const { store, sessionID, opts } = ctx;
+    const result = store.getSessionTrajectory(sessionID, { limit: opts.limit, beforeTurn: opts.beforeTurn });
+    if (opts.rebuild && result.turns.length === 0 && result.events.length === 0 && ctx.messages) {
+        const messages = Array.isArray(ctx.messages?.data) ? ctx.messages.data : Array.isArray(ctx.messages) ? ctx.messages : [];
+        if (messages.length > 0) {
+            return rebuildFromMessages(store, sessionID, messages, ctx.projectID || '/proj');
+        }
+    }
+    return result;
+}
+function rebuildFromMessages(store, sessionID, messages, projectID) {
+    const turns = [];
+    const events = [];
+    let seq = 0;
+    const userMessages = messages.filter((m) => m?.info?.role === 'user' || m?.role === 'user');
+    if (userMessages.length === 0)
+        return { turns: [], events: [] };
+    for (let idx = 0; idx < userMessages.length; idx++) {
+        const um = userMessages[idx];
+        const info = um.info || um;
+        const turnID = idx + 1;
+        const startMs = info?.time?.created || Date.now();
+        const agent = info?.agent || null;
+        const baseModel = info?.model?.modelID || null;
+        events.push({
+            projectID,
+            sessionID,
+            turnID,
+            seq: ++seq,
+            eventType: 'turn_start',
+            timeMs: startMs,
+        });
+        const parentID = info.id || um.id;
+        const assistantMessages = messages.filter((m) => (m?.info?.role === 'assistant' && m?.info?.parentID === parentID) || (m?.role === 'assistant' && m?.parentID === parentID));
+        let toolCount = 0;
+        let toolErrorCount = 0;
+        let reasoningCount = 0;
+        const tokens = { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } };
+        let cost = 0;
+        let finish = null;
+        let model = null;
+        let endMs = null;
+        let userText = '';
+        // user text
+        const userPart = (um.parts || um?.info?.parts || []).find((p) => p.type === 'text' && typeof p.text === 'string');
+        if (userPart)
+            userText = String(userPart.text).slice(0, 300);
+        if (!userText && info?.summary?.body)
+            userText = String(info.summary.body).slice(0, 300);
+        for (const am of assistantMessages) {
+            const ai = am.info || am;
+            const parts = (am.parts || ai?.parts || []);
+            model = ai?.modelID || model;
+            if (ai?.tokens) {
+                tokens.input += ai.tokens.input || 0;
+                tokens.output += ai.tokens.output || 0;
+                tokens.reasoning += ai.tokens.reasoning || 0;
+                tokens.cache.read += ai.tokens.cache?.read || 0;
+                tokens.cache.write += ai.tokens.cache?.write || 0;
+                cost += ai.cost || 0;
+                if (ai.finish)
+                    finish = ai.finish;
+            }
+            if (ai?.time?.completed)
+                endMs = ai.time.completed;
+            for (const p of parts) {
+                if (p?.type === 'tool' && p.state) {
+                    events.push({
+                        projectID,
+                        sessionID,
+                        turnID,
+                        seq: ++seq,
+                        eventType: 'tool_start',
+                        toolName: p.tool,
+                        callID: p.callID,
+                        timeMs: p.state?.time?.start || startMs,
+                    });
+                    if (p.state.status === 'completed' || p.state.status === 'error') {
+                        toolCount++;
+                        if (p.state.status === 'error')
+                            toolErrorCount++;
+                        events.push({
+                            projectID,
+                            sessionID,
+                            turnID,
+                            seq: ++seq,
+                            eventType: 'tool_end',
+                            toolName: p.tool,
+                            callID: p.callID,
+                            toolState: p.state.status,
+                            outputSummary: truncate(p.state.output || p.state.error, 500),
+                            error: p.state.status === 'error' ? truncate(p.state.error, 500) : undefined,
+                            durationMs: p.state.time ? p.state.time.end - p.state.time.start : undefined,
+                            timeMs: p.state.time?.end || startMs,
+                        });
+                    }
+                }
+                else if (p?.type === 'reasoning') {
+                    reasoningCount++;
+                    events.push({ projectID, sessionID, turnID, seq: ++seq, eventType: 'reasoning_start', timeMs: p.time?.start || startMs });
+                    if (p.time?.end) {
+                        events.push({
+                            projectID,
+                            sessionID,
+                            turnID,
+                            seq: ++seq,
+                            eventType: 'reasoning_end',
+                            durationMs: p.time.end - (p.time.start || p.time.end),
+                            timeMs: p.time.end,
+                        });
+                    }
+                }
+            }
+        }
+        turns.push({
+            projectID,
+            sessionID,
+            turnID,
+            turnStartMs: startMs,
+            turnEndMs: endMs,
+            durationMs: endMs ? endMs - startMs : null,
+            toolCount,
+            toolErrorCount,
+            reasoningCount,
+            agentSwitchCount: 0,
+            tokens,
+            cost,
+            finish: finish || 'unknown',
+            model: model || baseModel,
+            provider: null,
+            agent,
+            userText,
+        });
+    }
+    if (turns.length > 0) {
+        // Reset seq per turn so store order is stable
+        for (const t of turns)
+            store.upsertTurn(t);
+        let nextSeq = 1;
+        for (const e of events) {
+            store.recordEvent({ ...e, seq: nextSeq++ });
+        }
+    }
+    return { turns: turns.sort((a, b) => b.turnID - a.turnID), events };
+}
+function truncate(s, n) {
+    if (!s)
+        return undefined;
+    return s.length > n ? s.slice(0, n) + '\u2026' : s;
+}

package/gateway/dist/trajectory/backfill-provider.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backfillProviderColumn = backfillProviderColumn;
+const logger_1 = require("../core/utils/logger");
+function backfillProviderColumn(db) {
+    const rawDb = db.db;
+    const rows = rawDb
+        .prepare('SELECT session_id, turn_id, model FROM trajectory_turns WHERE provider IS NULL AND model IS NOT NULL')
+        .all();
+    if (rows.length === 0) {
+        logger_1.log.info('[Backfill] No turns need provider backfill');
+        return;
+    }
+    const update = rawDb.prepare('UPDATE trajectory_turns SET provider = ? WHERE session_id = ? AND turn_id = ?');
+    let updated = 0;
+    for (const row of rows) {
+        const provider = inferProvider(row.model);
+        if (provider) {
+            update.run(provider, row.session_id, row.turn_id);
+            updated++;
+        }
+    }
+    logger_1.log.info(`[Backfill] Updated ${updated}/${rows.length} turns with provider`);
+}
+function inferProvider(model) {
+    if (model.includes('/')) {
+        return model.split('/')[0];
+    }
+    const known = {
+        'claude': 'anthropic',
+        'gpt': 'openai',
+        'deepseek': 'deepseek',
+        'mimo': 'xiaomi',
+        'qwen': 'alibaba-cn',
+    };
+    for (const [prefix, provider] of Object.entries(known)) {
+        if (model.toLowerCase().includes(prefix))
+            return provider;
+    }
+    return null;
+}

package/gateway/dist/trajectory/collector.js

@@ -0,0 +1,337 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrajectoryCollector = void 0;
+exports.resolveRetentionDays = resolveRetentionDays;
+const logger_1 = require("../core/utils/logger");
+const SUMMARY_MAX = 500;
+const USER_TEXT_MAX = 300;
+function truncate(s, n) {
+    if (!s)
+        return undefined;
+    return s.length > n ? s.slice(0, n) + '\u2026' : s;
+}
+function resolveRetentionDays(v) {
+    if (typeof v !== 'number' || !Number.isFinite(v) || v < 0)
+        return 365;
+    return Math.floor(v);
+}
+class TrajectoryCollector {
+    store;
+    db;
+    projectID;
+    getRetentionDays;
+    turns = new Map();
+    seqCounters = new Map();
+    seenUserMessageIDs = new Set();
+    opencodeClient;
+    _roleFor;
+    constructor(store, db, projectID, getRetentionDays = () => 14) {
+        this.store = store;
+        this.db = db;
+        this.projectID = projectID;
+        this.getRetentionDays = getRetentionDays;
+    }
+    setOpencodeClient(client) {
+        this.opencodeClient = client;
+    }
+    setRoleFor(fn) {
+        this._roleFor = fn;
+    }
+    seq(sessionID) {
+        const n = (this.seqCounters.get(sessionID) || 0) + 1;
+        this.seqCounters.set(sessionID, n);
+        return n;
+    }
+    stateFor(sessionID, turnID, projectID) {
+        let s = this.turns.get(sessionID);
+        if (!s) {
+            s = {
+                turnID: turnID ?? (this.store.currentTurnId(sessionID) || 1),
+                turnStartMs: Date.now(),
+                toolCount: 0,
+                toolErrorCount: 0,
+                reasoningCount: 0,
+                agentSwitchCount: 0,
+                tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+                cost: 0,
+                finish: null,
+                model: null,
+                provider: null,
+                agent: null,
+                userText: '',
+                userMessageID: null,
+                assistantText: '',
+                assistantMessageID: null,
+                stepFinishMessageIDs: new Set(),
+                toolCallIDs: new Set(),
+                reasoningPartIDs: new Set(),
+                lastModel: null,
+                projectID: projectID || this.projectID,
+            };
+            this.turns.set(sessionID, s);
+        }
+        return s;
+    }
+    emit(sessionID, s, eventType, extra = {}, projectID) {
+        const evt = {
+            projectID: projectID || this.projectID,
+            sessionID,
+            turnID: s.turnID,
+            seq: this.seq(sessionID),
+            eventType,
+            timeMs: Date.now(),
+            ...extra,
+        };
+        this.store.recordEvent(evt);
+        const days = resolveRetentionDays(this.getRetentionDays());
+        if (days > 0)
+            this.store.pruneOlderThan(days);
+        return evt;
+    }
+    handleEvent(type, props, directory) {
+        const projectID = directory || this.projectID;
+        const sessionID = props?.info?.sessionID || props?.part?.sessionID || props?.sessionID;
+        if (!sessionID)
+            return null;
+        if (type === 'message.updated') {
+            const info = props?.info;
+            if (!info)
+                return null;
+            logger_1.log.info(`[Trajectory] message.updated: sessionID=${sessionID}, role=${info.role}, id=${info.id}, projectID=${projectID}`);
+            if (info.role === 'user') {
+                if (info.id && this.seenUserMessageIDs.has(info.id)) {
+                    logger_1.log.info(`[Trajectory] user message duplicate: sessionID=${sessionID}, id=${info.id}, skipping`);
+                    return null;
+                }
+                if (info.id)
+                    this.seenUserMessageIDs.add(info.id);
+                const nextId = this.store.nextTurnId(sessionID);
+                const s = this.stateFor(sessionID, nextId, projectID);
+                s.turnStartMs = info?.time?.created || Date.now();
+                s.turnID = nextId;
+                s.userMessageID = info.id ?? null;
+                const summaryBody = info?.summary?.body || '';
+                s.userText = truncate(summaryBody, USER_TEXT_MAX) || '';
+                logger_1.log.info(`[Trajectory] user message: sessionID=${sessionID}, id=${info.id}, summaryBody.len=${summaryBody.length}`);
+                if (!s.userText && info.id && this.opencodeClient) {
+                    void this.fetchUserText(sessionID, info.id, s);
+                }
+                return this.emit(sessionID, s, 'turn_start', {}, projectID);
+            }
+            if (info.role === 'assistant') {
+                const s = this.stateFor(sessionID, undefined, projectID);
+                if (info.modelID && s.lastModel && info.modelID !== s.lastModel) {
+                    s.agentSwitchCount++;
+                    const evt = this.emit(sessionID, s, 'model_switch', { model: info.modelID }, projectID);
+                    s.lastModel = info.modelID;
+                    return evt;
+                }
+                s.lastModel = info.modelID || s.lastModel;
+                s.model = info.modelID || s.model;
+                s.provider = info.providerID || s.provider;
+                if (!s.stepFinishMessageIDs.has(info.id) && info.finish && info.tokens) {
+                    s.stepFinishMessageIDs.add(info.id);
+                    s.tokens = addTokens(s.tokens, info.tokens);
+                    s.cost += info.cost || 0;
+                    s.finish = info.finish;
+                    const evt = this.emit(sessionID, s, 'step_finish', {
+                        model: info.modelID,
+                        tokens: info.tokens,
+                        cost: info.cost,
+                        finish: info.finish,
+                    }, projectID);
+                    return evt;
+                }
+                return null;
+            }
+            return null;
+        }
+        if (type === 'message.part.updated') {
+            const part = props?.part;
+            if (!part)
+                return null;
+            const s = this.stateFor(sessionID, undefined, projectID);
+            if (part.type === 'text') {
+                const textLen = typeof part.text === 'string' ? part.text.length : 0;
+                logger_1.log.info(`[Trajectory] text part: sessionID=${sessionID}, messageID=${part.messageID}, userMessageID=${s.userMessageID}, userText.len=${s.userText.length}, part.text.len=${textLen}`);
+                if (textLen > 0 && !s.userText && (!s.userMessageID || s.userMessageID === part.messageID)) {
+                    s.userText = truncate(part.text, USER_TEXT_MAX) || '';
+                    logger_1.log.info(`[Trajectory] captured userText from part: sessionID=${sessionID}, len=${textLen}`);
+                }
+                else if (textLen > 0 && s.userMessageID && s.userMessageID !== part.messageID) {
+                    s.assistantText = truncate(part.text, SUMMARY_MAX) || '';
+                    s.assistantMessageID = part.messageID;
+                    logger_1.log.info(`[Trajectory] captured assistantText from part: sessionID=${sessionID}, len=${textLen}`);
+                }
+                return null;
+            }
+            if (part.type === 'tool') {
+                const st = part.state;
+                if (!st)
+                    return null;
+                if (st.status === 'running' || st.status === 'pending') {
+                    if (s.toolCallIDs.has(part.callID))
+                        return null;
+                    s.toolCallIDs.add(part.callID);
+                    const evt = this.emit(sessionID, s, 'tool_start', {
+                        toolName: part.tool,
+                        callID: part.callID,
+                        inputSummary: truncate(summarizeInput(st.input), SUMMARY_MAX),
+                    }, projectID);
+                    return evt;
+                }
+                if (st.status === 'completed' || st.status === 'error') {
+                    s.toolCount++;
+                    if (st.status === 'error')
+                        s.toolErrorCount++;
+                    const duration = st.time ? st.time.end - st.time.start : undefined;
+                    const evt = this.emit(sessionID, s, 'tool_end', {
+                        toolName: part.tool,
+                        callID: part.callID,
+                        toolState: st.status,
+                        outputSummary: truncate(st.output || st.error, SUMMARY_MAX),
+                        error: st.status === 'error' ? truncate(st.error, SUMMARY_MAX) : undefined,
+                        durationMs: duration,
+                    }, projectID);
+                    return evt;
+                }
+                return null;
+            }
+            if (part.type === 'step-finish') {
+                if (s.stepFinishMessageIDs.has(part.messageID))
+                    return null;
+                s.stepFinishMessageIDs.add(part.messageID);
+                s.tokens = addTokens(s.tokens, part.tokens);
+                s.cost += part.cost || 0;
+                s.finish = part.reason;
+                const evt = this.emit(sessionID, s, 'step_finish', {
+                    tokens: part.tokens,
+                    cost: part.cost,
+                    finish: part.reason,
+                }, projectID);
+                return evt;
+            }
+            if (part.type === 'reasoning') {
+                if (!s.reasoningPartIDs.has(part.id)) {
+                    s.reasoningPartIDs.add(part.id);
+                    s.reasoningCount++;
+                    const evt = this.emit(sessionID, s, 'reasoning_start', {}, projectID);
+                    if (part.time?.end) {
+                        const end = this.emit(sessionID, s, 'reasoning_end', {
+                            durationMs: part.time.end - (part.time.start || part.time.end),
+                        }, projectID);
+                        return end;
+                    }
+                    return evt;
+                }
+                else {
+                    const evt = this.emit(sessionID, s, 'reasoning_end', {
+                        durationMs: part.time?.end ? part.time.end - (part.time.start || part.time.end) : undefined,
+                    }, projectID);
+                    return evt;
+                }
+            }
+            return null;
+        }
+        return null;
+    }
+    onIdle(sessionID) {
+        const s = this.turns.get(sessionID);
+        logger_1.log.info(`[Trajectory] onIdle: sessionID=${sessionID}, hasState=${!!s}`);
+        if (!s)
+            return null;
+        s.finish = s.finish || 'idle';
+        const workerRole = this._roleFor?.(sessionID) ?? undefined;
+        const turn = {
+            projectID: s.projectID,
+            sessionID,
+            turnID: s.turnID,
+            turnStartMs: s.turnStartMs,
+            turnEndMs: Date.now(),
+            durationMs: Date.now() - s.turnStartMs,
+            toolCount: s.toolCount,
+            toolErrorCount: s.toolErrorCount,
+            reasoningCount: s.reasoningCount,
+            agentSwitchCount: s.agentSwitchCount,
+            tokens: s.tokens,
+            cost: s.cost,
+            finish: s.finish,
+            model: s.model,
+            provider: s.provider,
+            agent: s.agent,
+            userText: s.userText,
+            assistantText: s.assistantText,
+            workerRole,
+        };
+        this.store.upsertTurn(turn);
+        this.emit(sessionID, s, 'turn_end', {}, s.projectID);
+        this.turns.delete(sessionID);
+        return turn;
+    }
+    async fetchUserText(sessionID, messageID, s) {
+        try {
+            const result = await this.opencodeClient.session.messages({
+                sessionID,
+                limit: 50,
+            });
+            const data = result?.data || [];
+            const messages = Array.isArray(data) ? data : [];
+            const msg = messages.find((m) => {
+                const info = m.info || m;
+                return info.id === messageID;
+            });
+            if (!msg)
+                return;
+            const parts = (msg.parts || msg?.info?.parts || []);
+            const textPart = parts.find((p) => p.type === 'text' && typeof p.text === 'string');
+            if (textPart && !s.userText) {
+                s.userText = truncate(textPart.text, USER_TEXT_MAX) || '';
+                logger_1.log.info(`[Trajectory] fetched userText via API: sessionID=${sessionID}, len=${textPart.text.length}`);
+                const workerRole = this._roleFor?.(sessionID) ?? undefined;
+                this.store.upsertTurn({
+                    projectID: s.projectID,
+                    sessionID,
+                    turnID: s.turnID,
+                    turnStartMs: s.turnStartMs,
+                    turnEndMs: null,
+                    durationMs: null,
+                    toolCount: s.toolCount,
+                    toolErrorCount: s.toolErrorCount,
+                    reasoningCount: s.reasoningCount,
+                    agentSwitchCount: s.agentSwitchCount,
+                    tokens: s.tokens,
+                    cost: s.cost,
+                    finish: s.finish,
+                    model: s.model,
+                    provider: s.provider,
+                    agent: s.agent,
+                    userText: s.userText,
+                    workerRole,
+                });
+            }
+        }
+        catch (err) {
+            logger_1.log.warn(`[Trajectory] fetchUserText failed: ${err.message}`);
+        }
+    }
+}
+exports.TrajectoryCollector = TrajectoryCollector;
+function addTokens(a, b) {
+    return {
+        input: a.input + (b.input || 0),
+        output: a.output + (b.output || 0),
+        reasoning: a.reasoning + (b.reasoning || 0),
+        cache: { read: a.cache.read + (b.cache?.read || 0), write: a.cache.write + (b.cache?.write || 0) },
+    };
+}
+function summarizeInput(input) {
+    if (!input)
+        return '';
+    try {
+        const s = JSON.stringify(input);
+        return s.length > 200 ? s.slice(0, 200) + '\u2026' : s;
+    }
+    catch {
+        return '';
+    }
+}