@evomap/evolver-adapter-public 2.0.0-beta.8 → 2.0.0

package/dist/learningPacketSink.d.ts

@@ -0,0 +1,40 @@
+import type { hub, trace } from '@evomap/evolver-core';
+import { type FetchLike } from './hubFetch.js';
+/** Hub traceEvents array cap (createLearningPacketSchema). Extra events are dropped, noted in metadata. */
+export declare const HUB_TRACE_EVENTS_MAX = 100;
+export interface HubLearningPacketSinkOptions {
+    baseUrl: string;
+    auth: hub.AuthProvider;
+    fetchFn: FetchLike;
+    /** Optional node identity recorded on the packet (hub nodeId column). */
+    nodeId?: () => string | undefined;
+}
+/** 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>;
+/**
+ * LearningPacketSink implementation against the public hub Learning Ops ingest API. Best-effort by
+ * contract: every failure returns { accepted: false, reason } (never throws) — the runtime treats packet
+ * delivery as observability, so a hub outage must never affect a task verdict. A 409 duplicate_source is
+ * reported as accepted (the packet is already there; the idempotency key did its job).
+ */
+export declare class HubLearningPacketSink implements trace.LearningPacketSink {
+    private readonly opts;
+    constructor(opts: HubLearningPacketSinkOptions);
+    submit(draft: trace.LearningPacketDraft): Promise<trace.LearningPacketSubmitResult>;
+}
+/** Fan-out: always deliver to `primary` (local file record), then best-effort to `secondary` (hub upload).
+ *  The composite result reflects the PRIMARY sink — the local record is the durability guarantee. */
+export declare class TeeLearningPacketSink implements trace.LearningPacketSink {
+    private readonly primary;
+    private readonly secondary;
+    constructor(primary: trace.LearningPacketSink, secondary: trace.LearningPacketSink);
+    submit(draft: trace.LearningPacketDraft): Promise<trace.LearningPacketSubmitResult>;
+}

package/dist/learningPacketSink.js

@@ -0,0 +1,153 @@
+// Learning Ops packet upload (slice 3) — the adapter half of core's LearningPacketSink port.
+// Maps a local LearningPacketDraft (learning_packet.v0, built by evolver-core/trace) onto the hub's
+// `POST /api/learning-packets` ingest contract (strict zod schema, requireAuth Bearer token).
+//
+// Deliberately NOT built on HubFetch: that helper injects sender_id/credential fields into every POST body
+// (the /a2a envelope convention), which the strict learning-packets schema rejects. This sink authenticates
+// via the injected AuthProvider (Authorization header only) and sends exactly the schema's fields.
+import { createHash } from 'node:crypto';
+import { assertHubUrlSecure, isHubUnreachableError } from './hubFetch.js';
+/** Hub traceEvents array cap (createLearningPacketSchema). Extra events are dropped, noted in metadata. */
+export const HUB_TRACE_EVENTS_MAX = 100;
+/** Hub failureCategory is a closed enum; runtime failureKind is looser. Only the sure mapping is direct. */
+function failureCategoryFor(failureKind) {
+    if (failureKind === null)
+        return undefined;
+    if (failureKind === 'permission_denied')
+        return 'permission_error';
+    if (failureKind === 'timeout' || failureKind === 'non_zero_exit' || failureKind === 'invalid_output')
+        return 'tool_error';
+    return 'other';
+}
+function outcomeStatusFor(status) {
+    if (status === 'success')
+        return 'succeeded';
+    if (status === 'failed')
+        return 'failed';
+    return undefined;
+}
+/** Deterministic content hash over the draft body (hub contentHash column, dedup aid). */
+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;
+    const events = draft.trajectory.slice(0, HUB_TRACE_EVENTS_MAX);
+    const outcomeStatus = outcomeStatusFor(draft.evaluation.outcomeStatus);
+    const failureCategory = failureCategoryFor(draft.evaluation.failureCategory);
+    return {
+        schemaVersion: draft.schemaVersion,
+        status: 'draft',
+        sourceRepo: draft.source.repo,
+        sourceRun: draft.source.run,
+        sourceType: draft.source.type,
+        sourceId: draft.source.id,
+        // One packet per run: the run id IS the idempotency key, so a retried submit dedups hub-side (409).
+        idempotencyKey: `${draft.source.repo}:${draft.source.run}`,
+        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: {
+            task: draft.task,
+            context: draft.context,
+            artifacts: draft.artifacts,
+            evaluation: draft.evaluation,
+            governance: draft.governance,
+        },
+        metadata: {
+            ...(truncated ? { traceEventsTruncated: true, traceEventsTotal: draft.trajectory.length } : {}),
+            ...(draft.evaluation.failureCategory !== null ? { runtimeFailureKind: draft.evaluation.failureCategory } : {}),
+        },
+        redactionStatus: draft.governance.redactionStatus,
+        consentStatus: draft.governance.consentStatus,
+        retentionPolicy: draft.governance.retentionPolicy,
+        traceEvents: events.map((e) => ({
+            eventId: e.eventId,
+            schemaVersion: e.schemaVersion,
+            eventType: e.eventType,
+            occurredAt: e.occurredAt,
+            traceId: e.traceId,
+            ...(e.sessionId !== undefined ? { sessionId: e.sessionId } : {}),
+            ...(e.taskId !== undefined ? { taskId: e.taskId } : {}),
+            sequence: e.sequence,
+            payload: e.payload,
+            metadata: e.metadata,
+        })),
+    };
+}
+/**
+ * LearningPacketSink implementation against the public hub Learning Ops ingest API. Best-effort by
+ * contract: every failure returns { accepted: false, reason } (never throws) — the runtime treats packet
+ * delivery as observability, so a hub outage must never affect a task verdict. A 409 duplicate_source is
+ * reported as accepted (the packet is already there; the idempotency key did its job).
+ */
+export class HubLearningPacketSink {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    async submit(draft) {
+        try {
+            const url = `${this.opts.baseUrl}/api/learning-packets`;
+            assertHubUrlSecure(url);
+            const headers = await learningOpsAuthHeaders(this.opts.auth, 'POST', '/api/learning-packets');
+            const res = await this.opts.fetchFn(url, {
+                method: 'POST',
+                headers,
+                redirect: 'manual',
+                body: JSON.stringify(learningPacketWireBody(draft, this.opts.nodeId?.())),
+            });
+            if (res.status === 201) {
+                const body = await res.json().catch(() => null);
+                const packet = body && typeof body === 'object' ? body.packet : undefined;
+                return { accepted: true, ...(typeof packet?.id === 'string' ? { reason: packet.id } : {}) };
+            }
+            if (res.status === 409)
+                return { accepted: true, reason: 'duplicate_source' };
+            const text = await res.text().catch(() => '');
+            return { accepted: false, reason: `hub ${res.status}${text ? `: ${text.slice(0, 200)}` : ''}` };
+        }
+        catch (e) {
+            if (isHubUnreachableError(e))
+                return { accepted: false, reason: 'hub_unreachable' };
+            return { accepted: false, reason: e instanceof Error ? e.message : String(e) };
+        }
+    }
+}
+/** Fan-out: always deliver to `primary` (local file record), then best-effort to `secondary` (hub upload).
+ *  The composite result reflects the PRIMARY sink — the local record is the durability guarantee. */
+export class TeeLearningPacketSink {
+    primary;
+    secondary;
+    constructor(primary, secondary) {
+        this.primary = primary;
+        this.secondary = secondary;
+    }
+    async submit(draft) {
+        const primary = await this.primary.submit(draft);
+        try {
+            await this.secondary.submit(draft);
+        }
+        catch { /* secondary is best-effort by contract; sinks should not throw, but never let one break the record */ }
+        return primary;
+    }
+}

package/dist/wireMap.d.ts

@@ -6,6 +6,8 @@ export declare function inboundToAgentEvent(m: Record<string, unknown>): hub.Age
  * payload.signals, #69)。text 不是 fetch 字段(自由文本走 semantic-search 端点, 见 hubCapability.search)。
  */
 export declare function searchQueryToFetchWire(q: hub.HubQuery): Record<string, unknown>;
+/** Free discovery phase on /a2a/fetch. Keep this separate from the paid/full fetch mapper. */
+export declare function searchQueryToSearchOnlyWire(q: hub.HubQuery): Record<string, unknown>;
 /** core AgentEvent(出站) → 公版 outbound 消息(id+type 必填). */
 export declare function agentEventToOutbound(e: hub.AgentEvent): Record<string, unknown>;
 /** Retry policy for a non-2xx hub status, shared by every money-touching caller (anti-drift, #177). */
@@ -25,4 +27,4 @@ export type AtpRetryClass = 'permanent' | 'cooldown' | 'recoverable';
  */
 export declare function atpRetryClass(status: number): AtpRetryClass;
 /** /a2a/publish 响应 → PublishReceipt. 200=accepted; 402/4xx=rejected 终态. */
-export declare function publishRespToReceipt(status: number, body: Record<string, unknown>): hub.PublishReceipt;
+export declare function publishRespToReceipt(status: number, body: Record<string, unknown>, retryAfterMs?: number): hub.PublishReceipt;

package/dist/wireMap.js

@@ -24,10 +24,16 @@ export function searchQueryToFetchWire(q) {
         out['category'] = q.category;
     if (q.gene)
         out['gene'] = q.gene;
+    if (q.domain)
+        out['domain'] = q.domain;
     if (q.limit !== undefined)
         out['limit'] = q.limit;
     return out;
 }
+/** Free discovery phase on /a2a/fetch. Keep this separate from the paid/full fetch mapper. */
+export function searchQueryToSearchOnlyWire(q) {
+    return { ...searchQueryToFetchWire(q), search_only: true };
+}
 /** core AgentEvent(出站) → 公版 outbound 消息(id+type 必填). */
 export function agentEventToOutbound(e) {
     return {
@@ -59,14 +65,20 @@ export function atpRetryClass(status) {
     return 'recoverable';
 }
 /** /a2a/publish 响应 → PublishReceipt. 200=accepted; 402/4xx=rejected 终态. */
-export function publishRespToReceipt(status, body) {
+export function publishRespToReceipt(status, body, retryAfterMs) {
     const payload = body['payload'] ?? body;
     const assetIds = payload['asset_ids'];
-    const assetId = payload['asset_id'] ?? body['asset_id'] ?? assetIds?.[0];
+    const targetAssetId = payload['target_asset_id']
+        ?? body['target_asset_id'];
+    const assetId = (status === 409 ? targetAssetId : undefined)
+        ?? payload['asset_id']
+        ?? body['asset_id']
+        ?? assetIds?.[0]
+        ?? targetAssetId;
     const bundleId = payload['bundle_id'];
     if (status >= 200 && status < 300) {
         const decision = String(payload['decision'] ?? payload['status'] ?? 'accepted');
-        const accepted = decision === 'accepted' || decision === 'approved' || decision === 'ok';
+        const accepted = decision === 'accept' || decision === 'accepted' || decision === 'approved' || decision === 'ok';
         return {
             receiptId: String(payload['receipt_id'] ?? bundleId ?? payload['id'] ?? assetId ?? 'unknown'),
             status: accepted ? 'accepted' : (decision === 'quarantine' ? 'quarantine' : 'rejected'),
@@ -80,12 +92,26 @@ export function publishRespToReceipt(status, body) {
     // M8-1: 按语义而非纯状态码区分(都终态不重试 = money-safety: 不反复打经济端点).
     // 402=creditShortage(余额不足) / 403=node 失效需 rebind / 409=duplicate / 422=payload 须修 / 429=cooldown.
     const reasonByStatus = { 402: 'credit_shortage', 403: 'node_unauthorized', 409: 'duplicate', 422: 'invalid_payload', 429: 'cooldown' };
+    const rejectionCodeByStatus = {
+        400: 'invalid_request',
+        402: 'credit_shortage',
+        403: 'node_unauthorized',
+        404: 'not_found',
+        409: 'duplicate',
+        422: 'invalid_payload',
+        429: 'cooldown',
+    };
     const receipt = {
         receiptId: String(payload['receipt_id'] ?? 'rejected'),
         status: 'rejected',
         reason: String(payload['reason'] ?? reasonByStatus[status] ?? `hub ${status}`),
         ...(assetId ? { assetId } : {}),
+        ...(assetIds ? { assetIds } : {}),
         terminal: true,
+        rejection: {
+            code: rejectionCodeByStatus[status] ?? 'hub_rejected',
+            ...(retryAfterMs !== undefined ? { retryAfterMs } : {}),
+        },
     };
     if (status === 402) {
         receipt.economic = {

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@evomap/evolver-adapter-public",
-  "version": "2.0.0-beta.8",
+  "version": "2.0.0",
   "private": false,
   "type": "module",
+  "engines": {
+    "node": "^22.13.0 || >=23.4.0"
+  },
   "description": "公版 hub 适配器 (积分/治理)",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -14,7 +17,7 @@
   },
   "dependencies": {
     "@evomap/atp-sdk": "^0.1.0",
-    "@evomap/evolver-core": "2.0.0-beta.8",
+    "@evomap/evolver-core": "2.0.0",
     "undici": "^6.27.0"
   },
   "optionalDependencies": {
@@ -26,7 +29,7 @@
   },
   "publishConfig": {
     "access": "public",
-    "tag": "v2-beta"
+    "tag": "latest"
   },
   "files": [
     "dist/",