@evomap/evolver-adapter-public 2.0.0-beta.16 → 2.0.0-beta.17

package/dist/index.d.ts

@@ -15,6 +15,7 @@ export * from './offlinePermit.js';
 export * from './hubReuse.js';
 export * from './hubUrl.js';
 export * from './learningPacketSink.js';
+export * from './learningPacketFeedback.js';
 export * from './atp.js';
 export * from './pricing/modelPrices.js';
 export * from './connect.js';

package/dist/index.js

@@ -15,6 +15,7 @@ export * from './offlinePermit.js';
 export * from './hubReuse.js';
 export * from './hubUrl.js';
 export * from './learningPacketSink.js';
+export * from './learningPacketFeedback.js';
 export * from './atp.js';
 export * from './pricing/modelPrices.js';
 export * from './connect.js';

package/dist/learningPacketFeedback.d.ts

@@ -0,0 +1,68 @@
+import type { hub } from '@evomap/evolver-core';
+import { type FetchLike } from './hubFetch.js';
+/** Hub appendLearningFeedbackSchema closed enums (evomap-hub src/schemas/learningOps.js). */
+export declare const LEARNING_FEEDBACK_TYPES: readonly ["outcome", "rating", "correction", "governance", "note"];
+export type LearningFeedbackType = (typeof LEARNING_FEEDBACK_TYPES)[number];
+export declare const LEARNING_FEEDBACK_DECISIONS: readonly ["accepted", "rejected", "needs_redaction", "not_training_eligible", "training_candidate", "note"];
+export type LearningFeedbackDecision = (typeof LEARNING_FEEDBACK_DECISIONS)[number];
+export interface LearningPacketFeedbackInput {
+    /** Default hub-side: 'outcome'. */
+    feedbackType?: LearningFeedbackType;
+    decision: LearningFeedbackDecision;
+    /** 0..1 (hub-validated). */
+    rating?: number;
+    scores?: Record<string, unknown>;
+    rationale?: string;
+    /** Hub VERIFIERS enum member (e.g. 'automated_test', 'human'). */
+    verifier?: string;
+    /** Hub FAILURE_CATEGORIES enum member. */
+    failureCategory?: string;
+    /** Anchor the feedback to one trace event instead of the whole packet. */
+    traceEventId?: string;
+    actorNodeId?: string;
+}
+export type LearningFeedbackResult = {
+    ok: true;
+    feedbackId?: string;
+} | {
+    ok: false;
+    reason: string;
+};
+/** Server-managed governance/eligibility state read back from GET /api/learning-packets/:id. */
+export interface LearningPacketStatus {
+    id: string;
+    status?: string;
+    outcomeStatus?: string | null;
+    verifier?: string | null;
+    /** LearningOpsTrainingEligibility mirror: pending/eligible/ineligible/revoked/expired. */
+    trainingEligibilityStatus?: string | null;
+    /** pending/approved/blocked/purge_requested. */
+    governanceStatus?: string | null;
+    trainingEligible?: boolean;
+    consentStatus?: string | null;
+    redactionStatus?: string | null;
+    retentionPolicy?: string | null;
+}
+export type LearningPacketReadResult = {
+    ok: true;
+    packet: LearningPacketStatus;
+} | {
+    ok: false;
+    reason: string;
+};
+export interface HubLearningPacketFeedbackClientOptions {
+    baseUrl: string;
+    auth: hub.AuthProvider;
+    fetchFn: FetchLike;
+}
+/**
+ * Feedback append + packet governance read-back against the hub Learning Ops API. Best-effort by the
+ * same contract as HubLearningPacketSink: this is observability/ops tooling, so every failure —
+ * network, auth, 4xx/5xx, unparseable body — returns { ok:false, reason } and never throws.
+ */
+export declare class HubLearningPacketFeedbackClient {
+    private readonly opts;
+    constructor(opts: HubLearningPacketFeedbackClientOptions);
+    submitFeedback(packetId: string, feedback: LearningPacketFeedbackInput): Promise<LearningFeedbackResult>;
+    getPacket(packetId: string): Promise<LearningPacketReadResult>;
+}

package/dist/learningPacketFeedback.js

@@ -0,0 +1,103 @@
+import { assertHubUrlSecure, isHubUnreachableError } from './hubFetch.js';
+import { learningOpsAuthHeaders } from './learningPacketSink.js';
+/** Hub appendLearningFeedbackSchema closed enums (evomap-hub src/schemas/learningOps.js). */
+export const LEARNING_FEEDBACK_TYPES = ['outcome', 'rating', 'correction', 'governance', 'note'];
+export const LEARNING_FEEDBACK_DECISIONS = [
+    'accepted', 'rejected', 'needs_redaction', 'not_training_eligible', 'training_candidate', 'note',
+];
+function pickString(record, key) {
+    const value = record[key];
+    if (value === null)
+        return null;
+    return typeof value === 'string' ? value : undefined;
+}
+async function failureReason(res) {
+    const text = await res.text().catch(() => '');
+    return `hub ${res.status}${text ? `: ${text.slice(0, 200)}` : ''}`;
+}
+/**
+ * Feedback append + packet governance read-back against the hub Learning Ops API. Best-effort by the
+ * same contract as HubLearningPacketSink: this is observability/ops tooling, so every failure —
+ * network, auth, 4xx/5xx, unparseable body — returns { ok:false, reason } and never throws.
+ */
+export class HubLearningPacketFeedbackClient {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    async submitFeedback(packetId, feedback) {
+        try {
+            const path = `/api/learning-packets/${encodeURIComponent(packetId)}/feedback`;
+            const url = `${this.opts.baseUrl}${path}`;
+            assertHubUrlSecure(url);
+            const headers = await learningOpsAuthHeaders(this.opts.auth, 'POST', path);
+            // Exactly the appendLearningFeedbackSchema fields (strict zod): optional keys are omitted, not nulled.
+            const res = await this.opts.fetchFn(url, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({
+                    decision: feedback.decision,
+                    ...(feedback.feedbackType !== undefined ? { feedbackType: feedback.feedbackType } : {}),
+                    ...(feedback.rating !== undefined ? { rating: feedback.rating } : {}),
+                    ...(feedback.scores !== undefined ? { scores: feedback.scores } : {}),
+                    ...(feedback.rationale !== undefined ? { rationale: feedback.rationale } : {}),
+                    ...(feedback.verifier !== undefined ? { verifier: feedback.verifier } : {}),
+                    ...(feedback.failureCategory !== undefined ? { failureCategory: feedback.failureCategory } : {}),
+                    ...(feedback.traceEventId !== undefined ? { traceEventId: feedback.traceEventId } : {}),
+                    ...(feedback.actorNodeId !== undefined ? { actorNodeId: feedback.actorNodeId } : {}),
+                }),
+            });
+            if (res.status === 201) {
+                const body = await res.json().catch(() => null);
+                const row = body && typeof body === 'object' ? body.feedback : undefined;
+                return { ok: true, ...(typeof row?.id === 'string' ? { feedbackId: row.id } : {}) };
+            }
+            return { ok: false, reason: await failureReason(res) };
+        }
+        catch (e) {
+            if (isHubUnreachableError(e))
+                return { ok: false, reason: 'hub_unreachable' };
+            return { ok: false, reason: e instanceof Error ? e.message : String(e) };
+        }
+    }
+    async getPacket(packetId) {
+        try {
+            const path = `/api/learning-packets/${encodeURIComponent(packetId)}`;
+            const url = `${this.opts.baseUrl}${path}`;
+            assertHubUrlSecure(url);
+            const headers = await learningOpsAuthHeaders(this.opts.auth, 'GET', path);
+            const res = await this.opts.fetchFn(url, { method: 'GET', headers });
+            if (res.status !== 200)
+                return { ok: false, reason: await failureReason(res) };
+            const body = await res.json().catch(() => null);
+            const packet = body && typeof body === 'object' ? body.packet : undefined;
+            if (!packet || typeof packet !== 'object' || Array.isArray(packet)) {
+                return { ok: false, reason: 'hub 200: response missing packet object' };
+            }
+            const record = packet;
+            if (typeof record['id'] !== 'string' || record['id'].length === 0) {
+                return { ok: false, reason: 'hub 200: packet missing id' };
+            }
+            return {
+                ok: true,
+                packet: {
+                    id: record['id'],
+                    ...(pickString(record, 'status') !== undefined && pickString(record, 'status') !== null ? { status: record['status'] } : {}),
+                    ...(pickString(record, 'outcomeStatus') !== undefined ? { outcomeStatus: pickString(record, 'outcomeStatus') } : {}),
+                    ...(pickString(record, 'verifier') !== undefined ? { verifier: pickString(record, 'verifier') } : {}),
+                    ...(pickString(record, 'trainingEligibilityStatus') !== undefined ? { trainingEligibilityStatus: pickString(record, 'trainingEligibilityStatus') } : {}),
+                    ...(pickString(record, 'governanceStatus') !== undefined ? { governanceStatus: pickString(record, 'governanceStatus') } : {}),
+                    ...(typeof record['trainingEligible'] === 'boolean' ? { trainingEligible: record['trainingEligible'] } : {}),
+                    ...(pickString(record, 'consentStatus') !== undefined ? { consentStatus: pickString(record, 'consentStatus') } : {}),
+                    ...(pickString(record, 'redactionStatus') !== undefined ? { redactionStatus: pickString(record, 'redactionStatus') } : {}),
+                    ...(pickString(record, 'retentionPolicy') !== undefined ? { retentionPolicy: pickString(record, 'retentionPolicy') } : {}),
+                },
+            };
+        }
+        catch (e) {
+            if (isHubUnreachableError(e))
+                return { ok: false, reason: 'hub_unreachable' };
+            return { ok: false, reason: e instanceof Error ? e.message : String(e) };
+        }
+    }
+}

package/dist/learningPacketSink.d.ts

@@ -11,6 +11,12 @@ export interface HubLearningPacketSinkOptions {
 }
 /** Deterministic content hash over the draft body (hub contentHash column, dedup aid). */
 export declare function learningPacketContentHash(draft: trace.LearningPacketDraft): string;
+/**
+ * Auth headers for the strict learning-packets routes (requireAuth reads Authorization only).
+ * A legacy body credential (bodyFields.node_secret) is promoted to Bearer — the strict schemas
+ * reject extra body fields, so credentials must never ride in the body here.
+ */
+export declare function learningOpsAuthHeaders(auth: hub.AuthProvider, method: string, path: string): Promise<Record<string, string>>;
 /** Map a core draft to the hub createLearningPacket body. Exported for tests and for the private adapter to reuse. */
 export declare function learningPacketWireBody(draft: trace.LearningPacketDraft, nodeId?: string): Record<string, unknown>;
 /**

package/dist/learningPacketSink.js

@@ -30,6 +30,19 @@ function outcomeStatusFor(status) {
 export function learningPacketContentHash(draft) {
     return `sha256:${createHash('sha256').update(JSON.stringify(draft)).digest('hex')}`;
 }
+/**
+ * Auth headers for the strict learning-packets routes (requireAuth reads Authorization only).
+ * A legacy body credential (bodyFields.node_secret) is promoted to Bearer — the strict schemas
+ * reject extra body fields, so credentials must never ride in the body here.
+ */
+export async function learningOpsAuthHeaders(auth, method, path) {
+    const signed = await auth.authenticate({ method, path });
+    const headers = { 'content-type': 'application/json', ...(signed.headers ?? {}) };
+    const bodySecret = signed.bodyFields?.['node_secret'];
+    if (headers['authorization'] === undefined && bodySecret !== undefined)
+        headers['authorization'] = `Bearer ${String(bodySecret)}`;
+    return headers;
+}
 /** Map a core draft to the hub createLearningPacket body. Exported for tests and for the private adapter to reuse. */
 export function learningPacketWireBody(draft, nodeId) {
     const truncated = draft.trajectory.length > HUB_TRACE_EVENTS_MAX;
@@ -48,6 +61,9 @@ export function learningPacketWireBody(draft, nodeId) {
         contentHash: learningPacketContentHash(draft),
         ...(nodeId ? { nodeId } : {}),
         ...(outcomeStatus ? { outcomeStatus } : {}),
+        // evaluation fill-in (slice 6): a non-placeholder evaluation carries the runtime's external verifier
+        // ('automated_test' is in the hub VERIFIERS enum); passed/score details ride inside payload.evaluation.
+        ...(draft.evaluation.verifier !== null ? { verifier: draft.evaluation.verifier } : {}),
         ...(failureCategory ? { failureCategory } : {}),
         ...(draft.task.summary !== null ? { summary: draft.task.summary } : {}),
         payload: {
@@ -93,13 +109,7 @@ export class HubLearningPacketSink {
         try {
             const url = `${this.opts.baseUrl}/api/learning-packets`;
             assertHubUrlSecure(url);
-            const signed = await this.opts.auth.authenticate({ method: 'POST', path: '/api/learning-packets' });
-            // The strict learning-packets schema rejects extra body fields, so a legacy body credential
-            // (bodyFields.node_secret) is promoted to Authorization: Bearer — the header requireAuth reads.
-            const headers = { 'content-type': 'application/json', ...(signed.headers ?? {}) };
-            const bodySecret = signed.bodyFields?.['node_secret'];
-            if (headers['authorization'] === undefined && bodySecret !== undefined)
-                headers['authorization'] = `Bearer ${String(bodySecret)}`;
+            const headers = await learningOpsAuthHeaders(this.opts.auth, 'POST', '/api/learning-packets');
             const res = await this.opts.fetchFn(url, {
                 method: 'POST',
                 headers,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evomap/evolver-adapter-public",
-  "version": "2.0.0-beta.16",
+  "version": "2.0.0-beta.17",
   "private": false,
   "type": "module",
   "description": "公版 hub 适配器 (积分/治理)",
@@ -14,7 +14,7 @@
   },
   "dependencies": {
     "@evomap/atp-sdk": "^0.1.0",
-    "@evomap/evolver-core": "2.0.0-beta.16",
+    "@evomap/evolver-core": "2.0.0-beta.17",
     "undici": "^6.27.0"
   },
   "optionalDependencies": {