@useorgx/openclaw-plugin 0.4.9 → 0.7.0

package/dist/http/helpers/decision-mapper.d.ts

@@ -1,12 +1,52 @@
 import type { Entity } from "../../types.js";
+import type { DecisionActionType } from "../../contracts/shared-types.js";
+type LiveDecisionOptionStatus = "approved" | "declined" | "cancelled";
+type LiveDecisionOption = {
+    id: string;
+    label: string;
+    description: string | null;
+    impliedStatus: LiveDecisionOptionStatus | null;
+    actionType: DecisionActionType | null;
+    requiresNote: boolean;
+};
+type LiveDecisionEvidenceRef = {
+    evidenceType: string | null;
+    title: string | null;
+    summary: string | null;
+    sourceUrl: string | null;
+    sourcePointer: string | null;
+    freshness: string | null;
+    confidence: number | null;
+    payload: Record<string, unknown> | null;
+};
 export declare function mapDecisionEntity(entity: Entity): {
     id: string;
     title: string;
     context: string | null;
     status: string;
+    priority: string | null;
+    decisionType: string | null;
     agentName: string | null;
+    agentId: string | null;
+    initiativeId: string | null;
+    workstreamId: string | null;
+    dueAt: string | null;
     requestedAt: string | null;
     updatedAt: string | null;
+    sourceSystem: string | null;
+    conflictSource: string | null;
+    dedupeKey: string | null;
+    recommendedAction: string | null;
+    occurrenceCount: number | null;
+    firstSeenAt: string | null;
+    lastSeenAt: string | null;
+    sourceRunId: string | null;
+    sourceSessionId: string | null;
+    sourceStreamId: string | null;
+    evidenceRefs: LiveDecisionEvidenceRef[];
     waitingMinutes: number;
     metadata: Record<string, unknown>;
+    options: LiveDecisionOption[];
+    selectedOptionId: string | null;
 };
+export {};

package/dist/http/helpers/decision-mapper.js

@@ -1,7 +1,186 @@
 import { pickNumber, pickString, toIsoString } from "./value-utils.js";
+import { normalizeDecisionActionType } from "../../contracts/shared-types.js";
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return value;
+}
+function normalizeOptionStatus(value) {
+    if (typeof value !== "string")
+        return null;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "rejected")
+        return "declined";
+    if (normalized === "approved" || normalized === "declined" || normalized === "cancelled") {
+        return normalized;
+    }
+    return null;
+}
+function pickStringFromRecords(records, keys) {
+    for (const record of records) {
+        if (!record)
+            continue;
+        const value = pickString(record, keys);
+        if (value)
+            return value;
+    }
+    return null;
+}
+function pickNumberFromRecords(records, keys) {
+    for (const record of records) {
+        if (!record)
+            continue;
+        const value = pickNumber(record, keys);
+        if (typeof value === "number" && Number.isFinite(value))
+            return value;
+    }
+    return null;
+}
+function pickActionType(values) {
+    for (const value of values) {
+        const normalized = normalizeDecisionActionType(value);
+        if (normalized)
+            return normalized;
+    }
+    return null;
+}
+function parseDecisionOptions(record) {
+    const metadata = asRecord(record.metadata);
+    const envelope = metadata ? asRecord(metadata.envelope_v2) : null;
+    const containers = [record];
+    if (metadata)
+        containers.push(metadata);
+    if (envelope)
+        containers.push(envelope);
+    const rawItems = [];
+    for (const container of containers) {
+        for (const key of ["decision_options", "options", "actions"]) {
+            const value = container[key];
+            if (Array.isArray(value))
+                rawItems.push(...value);
+        }
+    }
+    const options = [];
+    const seen = new Set();
+    for (let index = 0; index < rawItems.length; index += 1) {
+        const item = rawItems[index];
+        if (typeof item === "string") {
+            const label = item.trim();
+            if (!label)
+                continue;
+            const id = `option-${index + 1}`;
+            if (seen.has(id))
+                continue;
+            seen.add(id);
+            options.push({
+                id,
+                label,
+                description: null,
+                impliedStatus: null,
+                actionType: null,
+                requiresNote: false,
+            });
+            continue;
+        }
+        const candidate = asRecord(item);
+        if (!candidate)
+            continue;
+        const id = (typeof candidate.id === "string" && candidate.id.trim()) ||
+            (typeof candidate.option_id === "string" && candidate.option_id.trim()) ||
+            (typeof candidate.action_id === "string" && candidate.action_id.trim()) ||
+            `option-${index + 1}`;
+        if (seen.has(id))
+            continue;
+        const label = (typeof candidate.label === "string" && candidate.label.trim()) ||
+            (typeof candidate.title === "string" && candidate.title.trim()) ||
+            (typeof candidate.name === "string" && candidate.name.trim()) ||
+            (typeof candidate.action === "string" && candidate.action.trim()) ||
+            null;
+        if (!label)
+            continue;
+        seen.add(id);
+        options.push({
+            id,
+            label,
+            description: typeof candidate.description === "string" ? candidate.description : null,
+            impliedStatus: normalizeOptionStatus(candidate.implied_status) ??
+                normalizeOptionStatus(candidate.status) ??
+                normalizeOptionStatus(candidate.disposition),
+            actionType: pickActionType([
+                candidate.action_type,
+                candidate.type,
+                candidate.verb,
+                candidate.action,
+            ]) ?? null,
+            requiresNote: candidate.requires_note === true ||
+                candidate.requiresNote === true ||
+                candidate.note_required === true,
+        });
+    }
+    return options.slice(0, 12);
+}
+function parseSelectedOptionId(record) {
+    const metadata = asRecord(record.metadata);
+    if (!metadata)
+        return null;
+    const resolution = asRecord(metadata.resolution);
+    if (!resolution)
+        return null;
+    const selected = (typeof resolution.selected_option_id === "string" && resolution.selected_option_id.trim()) ||
+        (typeof resolution.option_id === "string" && resolution.option_id.trim()) ||
+        null;
+    return selected;
+}
+function parseEvidenceRefs(record) {
+    const metadata = asRecord(record.metadata);
+    const envelope = metadata ? asRecord(metadata.envelope_v2) : null;
+    const rawGroups = [
+        record.evidence_refs,
+        metadata?.evidence_refs,
+        metadata?.decision_evidence,
+        envelope?.evidence_refs,
+    ];
+    const refs = [];
+    for (const group of rawGroups) {
+        if (!Array.isArray(group))
+            continue;
+        for (const item of group) {
+            const evidence = asRecord(item);
+            if (!evidence)
+                continue;
+            const confidenceRaw = pickNumber(evidence, ["confidence"]);
+            refs.push({
+                evidenceType: pickString(evidence, ["evidence_type", "evidenceType", "type"]),
+                title: pickString(evidence, ["title", "name"]),
+                summary: pickString(evidence, ["summary", "description"]),
+                sourceUrl: pickString(evidence, ["source_url", "sourceUrl", "url"]),
+                sourcePointer: pickString(evidence, ["source_pointer", "sourcePointer", "pointer", "path"]),
+                freshness: pickString(evidence, ["freshness"]),
+                confidence: typeof confidenceRaw === "number" && Number.isFinite(confidenceRaw)
+                    ? confidenceRaw
+                    : null,
+                payload: asRecord(evidence.payload),
+            });
+        }
+    }
+    return refs.slice(0, 20);
+}
 export function mapDecisionEntity(entity) {
     const record = entity;
-    const requestedAt = toIsoString(pickString(record, [
+    const metadata = asRecord(record.metadata);
+    const envelope = metadata ? asRecord(metadata.envelope_v2) : null;
+    const sourceRef = asRecord(record.source_ref);
+    const metadataSourceRef = metadata ? asRecord(metadata.source_ref) : null;
+    const envelopeSourceRef = envelope ? asRecord(envelope.source_ref) : null;
+    const containers = [
+        record,
+        metadata,
+        envelope,
+        sourceRef,
+        metadataSourceRef,
+        envelopeSourceRef,
+    ];
+    const requestedAt = toIsoString(pickStringFromRecords(containers, [
         "requestedAt",
         "requested_at",
         "createdAt",
@@ -9,8 +188,9 @@ export function mapDecisionEntity(entity) {
         "updatedAt",
         "updated_at",
     ]));
-    const updatedAt = toIsoString(pickString(record, ["updatedAt", "updated_at", "createdAt", "created_at"]));
-    const waitingMinutesFromEntity = pickNumber(record, [
+    const updatedAt = toIsoString(pickStringFromRecords(containers, ["updatedAt", "updated_at", "createdAt", "created_at"]));
+    const dueAt = toIsoString(pickStringFromRecords(containers, ["dueAt", "due_at"]));
+    const waitingMinutesFromEntity = pickNumberFromRecords(containers, [
         "waitingMinutes",
         "waiting_minutes",
         "ageMinutes",
@@ -20,12 +200,23 @@ export function mapDecisionEntity(entity) {
         (requestedAt
             ? Math.max(0, Math.floor((Date.now() - Date.parse(requestedAt)) / 60_000))
             : 0);
+    const options = parseDecisionOptions(record);
+    const evidenceRefs = parseEvidenceRefs(record);
     return {
         id: String(record.id ?? ""),
-        title: pickString(record, ["title", "name"]) ?? "Decision",
-        context: pickString(record, ["context", "summary", "description", "details"]),
-        status: pickString(record, ["status", "decision_status"]) ?? "pending",
-        agentName: pickString(record, [
+        title: pickStringFromRecords(containers, ["title", "name"]) ?? "Decision",
+        context: pickStringFromRecords(containers, [
+            "context",
+            "summary",
+            "description",
+            "details",
+            "recommended_action",
+            "recommendedAction",
+        ]),
+        status: pickStringFromRecords(containers, ["status", "decision_status"]) ?? "pending",
+        priority: pickStringFromRecords(containers, ["priority"]),
+        decisionType: pickStringFromRecords(containers, ["decision_type", "decisionType"]),
+        agentName: pickStringFromRecords(containers, [
             "agentName",
             "agent_name",
             "requestedBy",
@@ -36,9 +227,34 @@ export function mapDecisionEntity(entity) {
             "createdBy",
             "created_by",
         ]),
+        agentId: pickStringFromRecords(containers, ["agent_id", "agentId"]),
+        initiativeId: pickStringFromRecords(containers, ["initiative_id", "initiativeId"]),
+        workstreamId: pickStringFromRecords(containers, ["workstream_id", "workstreamId"]),
+        dueAt,
         requestedAt,
         updatedAt,
+        sourceSystem: pickStringFromRecords(containers, ["source_system", "sourceSystem"]),
+        conflictSource: pickStringFromRecords(containers, ["conflict_source", "conflictSource"]),
+        dedupeKey: pickStringFromRecords(containers, ["dedupe_key", "dedupeKey"]),
+        recommendedAction: pickStringFromRecords(containers, [
+            "recommended_action",
+            "recommendedAction",
+        ]),
+        occurrenceCount: pickNumberFromRecords(containers, ["occurrence_count", "occurrenceCount"]),
+        firstSeenAt: toIsoString(pickStringFromRecords(containers, ["first_seen_at", "firstSeenAt"])),
+        lastSeenAt: toIsoString(pickStringFromRecords(containers, ["last_seen_at", "lastSeenAt"])),
+        sourceRunId: pickStringFromRecords(containers, ["source_run_id", "sourceRunId"]),
+        sourceSessionId: pickStringFromRecords(containers, [
+            "source_session_id",
+            "sourceSessionId",
+            "session_id",
+            "sessionId",
+        ]),
+        sourceStreamId: pickStringFromRecords(containers, ["source_stream_id", "sourceStreamId"]),
+        evidenceRefs,
         waitingMinutes,
         metadata: record,
+        options,
+        selectedOptionId: parseSelectedOptionId(record),
     };
 }

package/dist/http/helpers/dispatch-lifecycle.d.ts

@@ -34,9 +34,26 @@ export declare function createDispatchLifecycle(deps: DispatchLifecycleDeps): {
         title: string;
         summary?: string | null;
         urgency?: "low" | "medium" | "high" | "urgent";
-        options?: string[];
+        options?: Array<string | Record<string, unknown>>;
         blocking?: boolean;
-    }) => Promise<void>;
+        decisionType?: string | null;
+        workstreamId?: string | null;
+        agentId?: string | null;
+        dueAt?: string | null;
+        sourceSystem?: string | null;
+        conflictSource?: string | null;
+        dedupeKey?: string | null;
+        recommendedAction?: string | null;
+        sourceRunId?: string | null;
+        sourceSessionId?: string | null;
+        sourceStreamId?: string | null;
+        sourceRef?: Record<string, unknown> | null;
+        evidenceRefs?: Array<Record<string, unknown>> | null;
+        metadata?: Record<string, unknown> | null;
+    }) => Promise<{
+        queued: boolean;
+        decisionIds: string[];
+    }>;
     checkSpawnGuardSafe: (input: {
         domain: string;
         taskId?: string | null;