@mcoda/core 0.1.26 → 0.1.28

package/dist/services/review/CodeReviewService.js

@@ -207,6 +207,90 @@ const normalizeSlugList = (input) => {
     }
     return Array.from(cleaned);
 };
+const isRecord = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+const normalizeFailoverEvents = (value) => {
+    if (!Array.isArray(value))
+        return [];
+    const events = [];
+    for (const entry of value) {
+        if (!isRecord(entry))
+            continue;
+        if (typeof entry.type !== "string" || entry.type.trim().length === 0)
+            continue;
+        events.push({ ...entry });
+    }
+    return events;
+};
+const mergeFailoverEvents = (left, right) => {
+    if (!left.length)
+        return right;
+    if (!right.length)
+        return left;
+    const seen = new Set();
+    const merged = [];
+    const signature = (event) => [
+        event.type ?? "",
+        event.fromAgentId ?? "",
+        event.toAgentId ?? "",
+        event.at ?? "",
+        event.until ?? "",
+        event.durationMs ?? "",
+    ].join("|");
+    for (const event of [...left, ...right]) {
+        const key = signature(event);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        merged.push(event);
+    }
+    return merged;
+};
+const mergeInvocationMetadata = (current, incoming) => {
+    if (!current && !incoming)
+        return undefined;
+    if (!incoming)
+        return current;
+    if (!current)
+        return { ...incoming };
+    const merged = { ...current, ...incoming };
+    const currentEvents = normalizeFailoverEvents(current.failoverEvents);
+    const incomingEvents = normalizeFailoverEvents(incoming.failoverEvents);
+    if (currentEvents.length > 0 || incomingEvents.length > 0) {
+        merged.failoverEvents = mergeFailoverEvents(currentEvents, incomingEvents);
+    }
+    return merged;
+};
+const summarizeFailoverEvent = (event) => {
+    const type = String(event.type ?? "unknown");
+    if (type === "switch_agent") {
+        const from = typeof event.fromAgentId === "string" ? event.fromAgentId : "unknown";
+        const to = typeof event.toAgentId === "string" ? event.toAgentId : "unknown";
+        return `switch_agent ${from} -> ${to}`;
+    }
+    if (type === "sleep_until_reset") {
+        const duration = typeof event.durationMs === "number" && Number.isFinite(event.durationMs)
+            ? `${Math.round(event.durationMs / 1000)}s`
+            : "unknown duration";
+        const until = typeof event.until === "string" ? event.until : "unknown";
+        return `sleep_until_reset ${duration} (until ${until})`;
+    }
+    if (type === "stream_restart_after_limit") {
+        const from = typeof event.fromAgentId === "string" ? event.fromAgentId : "unknown";
+        return `stream_restart_after_limit from ${from}`;
+    }
+    return type;
+};
+const resolveFailoverAgentId = (events, fallbackAgentId) => {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event?.type !== "switch_agent")
+            continue;
+        if (typeof event.toAgentId === "string" && event.toAgentId.trim().length > 0) {
+            return event.toAgentId;
+        }
+    }
+    return fallbackAgentId;
+};
 const normalizePath = (value) => value
     .replace(/\\/g, "/")
     .replace(/^\.\//, "")
@@ -1990,6 +2074,45 @@ export class CodeReviewService {
                         metadata: { commandName: "code-review", phase, action: phase, attempt },
                     });
                 };
+                const logFailoverEvents = async (events) => {
+                    if (!events.length)
+                        return;
+                    for (const event of events) {
+                        await this.deps.workspaceRepo.insertTaskLog({
+                            taskRunId: taskRun.id,
+                            sequence: this.sequenceForTask(taskRun.id),
+                            timestamp: new Date().toISOString(),
+                            source: "agent_failover",
+                            message: `Agent failover: ${summarizeFailoverEvent(event)}`,
+                            details: event,
+                        });
+                    }
+                };
+                const resolveUsageAgent = async (fallback, events) => {
+                    const usageAgentId = resolveFailoverAgentId(events, fallback.id);
+                    if (usageAgentId === fallback.id)
+                        return fallback;
+                    const resolver = this.deps.agentService?.resolveAgent;
+                    if (typeof resolver !== "function")
+                        return fallback;
+                    try {
+                        const resolved = await resolver.call(this.deps.agentService, usageAgentId);
+                        return {
+                            id: resolved.id,
+                            defaultModel: typeof resolved.defaultModel === "string" ? resolved.defaultModel : fallback.defaultModel,
+                        };
+                    }
+                    catch (error) {
+                        await this.deps.workspaceRepo.insertTaskLog({
+                            taskRunId: taskRun.id,
+                            sequence: this.sequenceForTask(taskRun.id),
+                            timestamp: new Date().toISOString(),
+                            source: "agent_failover",
+                            message: `Unable to resolve failover agent (${usageAgentId}) for usage accounting: ${error instanceof Error ? error.message : String(error)}`,
+                        });
+                        return fallback;
+                    }
+                };
                 agentOutput = "";
                 let durationSeconds = 0;
                 let lastStreamMeta;
@@ -2002,7 +2125,7 @@ export class CodeReviewService {
                     if (useStream && this.deps.agentService.invokeStream) {
                         const stream = await withAbort(this.deps.agentService.invokeStream(agentToUse.id, {
                             input: prompt,
-                            metadata: { taskKey: task.key, retry: logSource === "agent_retry" },
+                            metadata: { command: "code-review", taskKey: task.key, retry: logSource === "agent_retry" },
                         }));
                         while (true) {
                             abortIfSignaled();
@@ -2011,7 +2134,7 @@ export class CodeReviewService {
                                 break;
                             const chunk = value;
                             output += chunk.output ?? "";
-                            metadata = chunk.metadata ?? metadata;
+                            metadata = mergeInvocationMetadata(metadata, chunk.metadata);
                             await this.deps.workspaceRepo.insertTaskLog({
                                 taskRunId: taskRun.id,
                                 sequence: this.sequenceForTask(taskRun.id),
@@ -2024,10 +2147,10 @@ export class CodeReviewService {
                     else {
                         const response = await withAbort(this.deps.agentService.invoke(agentToUse.id, {
                             input: prompt,
-                            metadata: { taskKey: task.key, retry: logSource === "agent_retry" },
+                            metadata: { command: "code-review", taskKey: task.key, retry: logSource === "agent_retry" },
                         }));
                         output = response.output ?? "";
-                        metadata = response.metadata;
+                        metadata = mergeInvocationMetadata(metadata, response.metadata);
                         await this.deps.workspaceRepo.insertTaskLog({
                             taskRunId: taskRun.id,
                             sequence: this.sequenceForTask(taskRun.id),
@@ -2074,7 +2197,15 @@ export class CodeReviewService {
                         model: (lastStreamMeta.model ?? lastStreamMeta.model_name ?? null),
                     }
                     : undefined;
-                await recordUsage("review_main", prompt, agentOutput, durationSeconds, tokenMetaMain, agentUsedForOutput, outputAttempt);
+                const mainFailoverEvents = normalizeFailoverEvents(lastStreamMeta?.failoverEvents);
+                await logFailoverEvents(mainFailoverEvents);
+                const usageAgentForOutput = await resolveUsageAgent({
+                    id: agentUsedForOutput.id,
+                    defaultModel: typeof agentUsedForOutput?.defaultModel === "string"
+                        ? agentUsedForOutput.defaultModel
+                        : undefined,
+                }, mainFailoverEvents);
+                await recordUsage("review_main", prompt, agentOutput, durationSeconds, tokenMetaMain, usageAgentForOutput, outputAttempt);
                 const primaryOutput = agentOutput;
                 let retryOutput;
                 let retryAgentUsed;
@@ -2126,7 +2257,10 @@ export class CodeReviewService {
                             message: `Retrying with JSON-only agent override: ${retryAgentUsed.slug ?? retryAgentUsed.id}`,
                         });
                     }
-                    const retryResp = await withAbort(this.deps.agentService.invoke(retryAgentUsed.id, { input: retryPrompt, metadata: { taskKey: task.key, retry: true } }));
+                    const retryResp = await withAbort(this.deps.agentService.invoke(retryAgentUsed.id, {
+                        input: retryPrompt,
+                        metadata: { command: "code-review", taskKey: task.key, retry: true },
+                    }));
                     retryOutput = retryResp.output ?? "";
                     const retryDuration = Math.round(((Date.now() - retryStarted) / 1000) * 1000) / 1000;
                     await this.deps.workspaceRepo.insertTaskLog({
@@ -2150,7 +2284,15 @@ export class CodeReviewService {
                             model: (retryResp.metadata.model ?? retryResp.metadata.model_name ?? null),
                         }
                         : undefined;
-                    await recordUsage("review_retry", retryPrompt, retryOutput, retryDuration, retryTokenMeta, retryAgentUsed, 2);
+                    const retryFailoverEvents = normalizeFailoverEvents(retryResp.metadata?.failoverEvents);
+                    await logFailoverEvents(retryFailoverEvents);
+                    const retryUsageAgent = await resolveUsageAgent({
+                        id: retryAgentUsed.id,
+                        defaultModel: typeof retryAgentUsed?.defaultModel === "string"
+                            ? retryAgentUsed.defaultModel
+                            : undefined,
+                    }, retryFailoverEvents);
+                    await recordUsage("review_retry", retryPrompt, retryOutput, retryDuration, retryTokenMeta, retryUsageAgent, 2);
                     normalization = normalizeReviewOutput(retryOutput);
                     parsed = normalization.result;
                     validationError = validateReviewOutput(parsed, { requireCommentSlugs });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcoda/core",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "description": "Core services and APIs for the mcoda CLI.",
   "type": "module",
   "main": "dist/index.js",
@@ -32,11 +32,11 @@
   "dependencies": {
     "@apidevtools/swagger-parser": "^10.1.0",
     "yaml": "^2.4.2",
-    "@mcoda/shared": "0.1.26",
-    "@mcoda/agents": "0.1.26",
-    "@mcoda/generators": "0.1.26",
-    "@mcoda/integrations": "0.1.26",
-    "@mcoda/db": "0.1.26"
+    "@mcoda/shared": "0.1.28",
+    "@mcoda/generators": "0.1.28",
+    "@mcoda/db": "0.1.28",
+    "@mcoda/agents": "0.1.28",
+    "@mcoda/integrations": "0.1.28"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",