@minasoft/mina-ai-router 0.1.4 → 0.2.0

package/dist/packages/core/src/request-store.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RequestStore = void 0;
+const openStatuses = new Set(["created", "sent", "waiting"]);
+const archiveOnlyErrorPrefixes = [
+    "Archived by operator",
+    "Archived orphaned request",
+];
 class RequestStore {
     constructor(requests = []) {
         this.requests = new Map();
@@ -31,11 +36,141 @@ class RequestStore {
             ...current,
             ...patch,
             status,
+            diagnosticStatus: patch.diagnosticStatus ?? diagnosticStatusFor(status),
             updatedAt: new Date().toISOString(),
         };
         this.requests.set(id, updated);
         return updated;
     }
+    updateOpenStatus(id, status, patch = {}) {
+        const current = this.require(id);
+        if (!openStatuses.has(current.status)) {
+            return undefined;
+        }
+        return this.updateStatus(id, status, patch);
+    }
+    cancel(id, reason = "Cancelled by operator.", source = "system") {
+        const current = this.require(id);
+        this.assertActionAllowed(current, "cancel");
+        const now = new Date().toISOString();
+        return this.updateStatus(id, "cancelled", {
+            error: reason,
+            leaseStatus: "released",
+            leaseReleasedAt: now,
+            recoveryEvents: appendRecoveryEvent(current, {
+                at: now,
+                action: "cancel",
+                source,
+                message: reason,
+                previousLeaseStatus: current.leaseStatus,
+                activeRequestId: current.id,
+            }),
+        });
+    }
+    archive(id, reason, source = "system") {
+        const current = this.require(id);
+        this.assertActionAllowed(current, "archive");
+        const now = new Date().toISOString();
+        const releasesLease = current.leaseStatus === "active" || current.leaseStatus === "orphaned";
+        const archiveReason = current.error ?? reason;
+        return this.updateStatus(id, "archived", {
+            archivedAt: now,
+            archivedFromStatus: current.status,
+            error: archiveReason,
+            leaseStatus: releasesLease ? "released" : current.leaseStatus,
+            leaseReleasedAt: releasesLease ? now : current.leaseReleasedAt,
+            recoveryStatus: current.leaseStatus === "orphaned" ? "recovered" : current.recoveryStatus,
+            recoveredAt: current.leaseStatus === "orphaned" ? now : current.recoveredAt,
+            recoveryEvents: current.leaseStatus === "orphaned"
+                ? appendRecoveryEvent(current, {
+                    at: now,
+                    action: "archive",
+                    source,
+                    message: reason ?? "Archived orphaned request and released lease.",
+                    previousLeaseStatus: current.leaseStatus,
+                    activeRequestId: current.id,
+                })
+                : current.recoveryEvents,
+        });
+    }
+    unarchive(id) {
+        const current = this.require(id);
+        this.assertActionAllowed(current, "unarchive");
+        const restoredStatus = current.archivedFromStatus ?? "answered";
+        const shouldClearArchiveError = current.error
+            && restoredStatus !== "failed"
+            && restoredStatus !== "timeout"
+            && archiveOnlyErrorPrefixes.some((prefix) => current.error?.startsWith(prefix));
+        return this.updateStatus(id, restoredStatus, {
+            archivedAt: undefined,
+            archivedFromStatus: undefined,
+            error: shouldClearArchiveError ? undefined : current.error,
+        });
+    }
+    recordRetry(originalRequestId, retryRequestId) {
+        const original = this.require(originalRequestId);
+        return this.patch(original.id, {
+            retriedByRequestId: retryRequestId,
+        });
+    }
+    recordInterrupt(id, options) {
+        const current = this.require(id);
+        this.assertActionAllowed(current, "interrupt");
+        const now = new Date().toISOString();
+        return this.patch(current.id, {
+            recoveryStatus: "interrupted",
+            interruptedAt: now,
+            recoveryEvents: appendRecoveryEvent(current, {
+                at: now,
+                action: "interrupt",
+                source: options.source,
+                message: options.message ?? "Terminal interrupt sent by operator.",
+                previousLeaseStatus: current.leaseStatus,
+                activeRequestId: current.id,
+                terminalTarget: options.terminalTarget,
+            }),
+        });
+    }
+    markRecovered(id, source, message = "Marked recovered by operator.") {
+        const current = this.require(id);
+        this.assertActionAllowed(current, "recover");
+        const now = new Date().toISOString();
+        return this.patch(current.id, {
+            leaseStatus: "released",
+            leaseReleasedAt: now,
+            recoveryStatus: "recovered",
+            recoveredAt: now,
+            recoveryEvents: appendRecoveryEvent(current, {
+                at: now,
+                action: "recover",
+                source,
+                message,
+                previousLeaseStatus: current.leaseStatus,
+                activeRequestId: current.id,
+            }),
+        });
+    }
+    assertActionAllowed(request, action) {
+        const validActions = this.validActions(request);
+        if (!validActions.includes(action)) {
+            throw new Error(`Cannot ${action} request "${request.id}" while it is ${request.status}. Valid actions: ${validActions.join(", ") || "none"}.`);
+        }
+    }
+    validActions(request) {
+        if (request.status === "archived") {
+            return ["retry", "unarchive"];
+        }
+        if (request.leaseStatus === "orphaned") {
+            const recoveryActions = request.recoveryStatus === "interrupted"
+                ? ["recover"]
+                : ["interrupt", "recover"];
+            return [...recoveryActions, "retry", "archive"];
+        }
+        if (openStatuses.has(request.status)) {
+            return ["cancel"];
+        }
+        return ["retry", "archive"];
+    }
     patch(id, patch) {
         const current = this.require(id);
         const updated = {
@@ -48,3 +183,26 @@ class RequestStore {
     }
 }
 exports.RequestStore = RequestStore;
+function appendRecoveryEvent(request, event) {
+    return [...(request.recoveryEvents ?? []), event];
+}
+function diagnosticStatusFor(status) {
+    switch (status) {
+        case "created":
+        case "sent":
+        case "waiting":
+            return "pending";
+        case "answered":
+            return "answered";
+        case "timeout":
+            return "timeout";
+        case "cancelled":
+            return "cancelled";
+        case "archived":
+            return "archived";
+        case "failed":
+            return "unknown_failure";
+        default:
+            return "unknown_failure";
+    }
+}

package/dist/packages/core/src/response-parser.js

@@ -1,33 +1,101 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResponseMarkerNotFoundError = void 0;
+exports.ResponseMarkerNotFoundError = exports.ResponseParseError = void 0;
+exports.inspectMarkedResponse = inspectMarkedResponse;
 exports.parseMarkedResponse = parseMarkedResponse;
-class ResponseMarkerNotFoundError extends Error {
-    constructor(requestId) {
-        super(`Response markers were not found for request ${requestId}.`);
+class ResponseParseError extends Error {
+    constructor(diagnostics) {
+        super(diagnostics.message);
+        this.diagnostics = diagnostics;
+        this.name = "ResponseParseError";
+    }
+}
+exports.ResponseParseError = ResponseParseError;
+class ResponseMarkerNotFoundError extends ResponseParseError {
+    constructor(diagnostics) {
+        super(diagnostics);
         this.name = "ResponseMarkerNotFoundError";
     }
 }
 exports.ResponseMarkerNotFoundError = ResponseMarkerNotFoundError;
-function parseMarkedResponse(output, requestId) {
+function inspectMarkedResponse(output, requestId) {
     const startMarker = `<<<MINA_AGENT_RESPONSE_START ${requestId}>>>`;
     const endMarker = `<<<MINA_AGENT_RESPONSE_END ${requestId}>>>`;
+    const startMarkerFound = output.includes(startMarker);
+    const endMarkerFound = output.includes(endMarker);
+    let candidateCount = 0;
+    let placeholderCount = 0;
     let end = output.lastIndexOf(endMarker);
     while (end !== -1) {
         const start = output.lastIndexOf(startMarker, end);
         if (start === -1) {
-            throw new ResponseMarkerNotFoundError(requestId);
+            return failedDiagnostics({
+                kind: "missing_start_marker",
+                requestId,
+                message: `Response end marker was found without a matching start marker for request ${requestId}.`,
+                startMarkerFound,
+                endMarkerFound,
+                candidateCount,
+                placeholderCount,
+            });
         }
         const contentStart = start + startMarker.length;
         const answer = output.slice(contentStart, end).trim();
+        candidateCount += 1;
         if (!isPlaceholderAnswer(answer)) {
-            return answer;
+            return {
+                ok: true,
+                answer,
+                diagnostics: {
+                    kind: "parsed",
+                    requestId,
+                    message: `Parsed marker-wrapped response for request ${requestId}.`,
+                    startMarkerFound,
+                    endMarkerFound,
+                    candidateCount,
+                    placeholderCount,
+                    answerLength: answer.length,
+                },
+            };
         }
+        placeholderCount += 1;
         end = output.lastIndexOf(endMarker, start - 1);
     }
-    throw new ResponseMarkerNotFoundError(requestId);
+    if (placeholderCount > 0) {
+        return failedDiagnostics({
+            kind: "placeholder_only",
+            requestId,
+            message: `Response markers only contained placeholder content for request ${requestId}.`,
+            startMarkerFound,
+            endMarkerFound,
+            candidateCount,
+            placeholderCount,
+        });
+    }
+    return failedDiagnostics({
+        kind: "missing_markers",
+        requestId,
+        message: `Response markers were not found for request ${requestId}.`,
+        startMarkerFound,
+        endMarkerFound,
+        candidateCount,
+        placeholderCount,
+    });
+}
+function parseMarkedResponse(output, requestId) {
+    const result = inspectMarkedResponse(output, requestId);
+    if (result.ok) {
+        return result.answer;
+    }
+    throw new ResponseMarkerNotFoundError(result.diagnostics);
 }
 function isPlaceholderAnswer(answer) {
     const normalized = answer.replace(/[|\s]/g, "");
     return normalized === "..." || normalized === "[youranswer]";
 }
+function failedDiagnostics(diagnostics) {
+    return {
+        ok: false,
+        diagnostics,
+    };
+}