@deepseek-ai/dsh-message-feedback 0.0.1-rc.2

package/lib/types/index.js

@@ -0,0 +1,342 @@
+/**
+ * Durable, lifecycle-bound feedback for finalized assistant messages.
+ * @module @deepseek-ai/dsh-message-feedback
+ */
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { Buffer } from 'node:buffer';
+import { randomUUID } from 'node:crypto';
+import { Service } from '@deepseek-ai/cordis';
+import s from '@deepseek-ai/schemastery';
+import { deriveEventMessage, isAppendSurfaceEvent } from '@deepseek-ai/dsh-session/surface';
+import { GatewayService, Remote } from '@deepseek-ai/dsh-type-meta';
+import { messageFeedbackDomainSpec } from "./spec.js";
+export { messageFeedbackDomainSpec, messageFeedbackItemSchema, messageFeedbackRatingSchema, messageFeedbackRowSchema, messageFeedbackSessionIdentitySchema, messageFeedbackVersionSchema, } from "./spec.js";
+/** Immutable empty list reused only as an input to caller-owned copying. */
+const EMPTY_ITEMS = Object.freeze([]);
+/** Validate the one deployment-varying limit at the configuration boundary. */
+function resolveMaxNoteBytes(value) {
+    if (!Number.isSafeInteger(value) || value < 1) {
+        throw new TypeError(`message-feedback: maxNoteBytes must be a positive safe integer, got ${String(value)}`);
+    }
+    return value;
+}
+/** Copy and freeze one item before it crosses the service boundary. */
+function snapshotItem(item) {
+    return Object.freeze({
+        messageId: item.messageId,
+        rating: item.rating,
+        ...(item.note === undefined ? {} : { note: item.note }),
+        version: item.version,
+        createdAt: item.createdAt,
+        updatedAt: item.updatedAt,
+    });
+}
+/** Copy and freeze a list response. */
+function snapshotList(items) {
+    return Object.freeze({ items: Object.freeze(items.map(snapshotItem)) });
+}
+/** Build a frozen success branch. */
+function success(value) {
+    return Object.freeze({ ok: true, value });
+}
+/** Build a frozen business-failure branch. */
+function rejected(error) {
+    return Object.freeze({ ok: false, error: Object.freeze(error) });
+}
+/** Project the Session fields that distinguish one persisted log lifecycle. */
+function identityOf(header) {
+    return Object.freeze({
+        createdAt: header.createdAt,
+        ...(header.cwd === undefined ? {} : { cwd: header.cwd }),
+    });
+}
+/** Whether a stored row belongs to the inspected Session lifecycle. */
+function sameIdentity(row, header) {
+    return row.session.createdAt === header.createdAt && row.session.cwd === header.cwd;
+}
+/** Whether two observations name the same persisted Session lifecycle. */
+function sameHeaderIdentity(left, right) {
+    return left.id === right.id && left.createdAt === right.createdAt && left.cwd === right.cwd;
+}
+/** Freeze the replacement row so storage-domain never exposes mutable aliases. */
+function rowSnapshot(session, items) {
+    const copiedItems = items.map(snapshotItem);
+    Object.freeze(copiedItems);
+    return Object.freeze({
+        session,
+        items: copiedItems,
+    });
+}
+/** Generate an opaque equality token for one material mutation. */
+function nextVersion() {
+    return randomUUID();
+}
+/**
+ * Storage-domain sidecar service. It inspects persisted Session history and
+ * never creates or resumes an Agent or Session.
+ */
+let MessageFeedbackService = (() => {
+    let _classSuper = GatewayService;
+    let _instanceExtraInitializers = [];
+    let _list_decorators;
+    let _put_decorators;
+    let _delete_decorators;
+    return class MessageFeedbackService extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _list_decorators = [Remote('list')];
+            _put_decorators = [Remote('put')];
+            _delete_decorators = [Remote('delete')];
+            __esDecorate(this, null, _list_decorators, { kind: "method", name: "list", static: false, private: false, access: { has: obj => "list" in obj, get: obj => obj.list }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _put_decorators, { kind: "method", name: "put", static: false, private: false, access: { has: obj => "put" in obj, get: obj => obj.put }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _delete_decorators, { kind: "method", name: "delete", static: false, private: false, access: { has: obj => "delete" in obj, get: obj => obj.delete }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static inject = ['storageDomain', 'sessionPersistence', 'sessions'];
+        /** Loader validation for the required note-size policy. */
+        static Config = s.object({
+            maxNoteBytes: s.number().step(1).min(1).required(),
+        });
+        maxNoteBytes = __runInitializers(this, _instanceExtraInitializers);
+        table;
+        operationTails = new Map();
+        mutationAdmissionOpen = true;
+        /**
+         * @param ctx - Host context carrying persistence and the storage-domain form.
+         * @param config - Required note-size policy.
+         */
+        constructor(ctx, config) {
+            super(ctx, 'messageFeedback');
+            this.maxNoteBytes = resolveMaxNoteBytes(config.maxNoteBytes);
+        }
+        /** Open and own the one message-feedback sidecar domain. */
+        async [Service.init]() {
+            const domain = await this.ctx.storageDomain.open(messageFeedbackDomainSpec);
+            this.ctx.effect(() => async () => {
+                this.mutationAdmissionOpen = false;
+                await Promise.all(this.operationTails.values());
+                await domain.close();
+            }, 'message-feedback.domainClose');
+            this.table = domain.table('sessions');
+        }
+        /**
+         * Read feedback belonging to the current persisted Session lifecycle.
+         * A stale row from a reused Session id is invisible.
+         * @param request - Session identity to inspect and list.
+         * @returns current immutable items or `session-not-found`.
+         */
+        async list(request) {
+            const known = await this.inspectSession(request.sessionId);
+            if (!known.ok)
+                return known;
+            const row = this.requireTable().get(request.sessionId);
+            const items = row !== undefined && sameIdentity(row, known.value.meta) ? row.items : EMPTY_ITEMS;
+            return success(snapshotList(items));
+        }
+        /**
+         * Create or replace feedback for one derived append-origin assistant
+         * message. Every request must match the addressed item's current version;
+         * a matching no-op returns the stored item without changing its revision.
+         * @param request - target, desired value, and observed item version.
+         * @returns the committed item or an explicit business failure.
+         */
+        put(request) {
+            const note = this.resolveNote(request.note);
+            if (!note.ok)
+                return Promise.resolve(note);
+            return this.enqueue(request.sessionId, async () => {
+                const known = await this.inspectSession(request.sessionId);
+                if (!known.ok)
+                    return known;
+                if (!this.hasFeedbackTarget(known.value, request.messageId)) {
+                    return rejected({
+                        code: 'target-not-found',
+                        sessionId: request.sessionId,
+                        messageId: request.messageId,
+                    });
+                }
+                const durable = await this.ensureTargetDurable(known.value);
+                if (!sameHeaderIdentity(durable.meta, known.value.meta)
+                    || !this.hasFeedbackTarget(durable, request.messageId)) {
+                    return rejected({
+                        code: 'target-not-found',
+                        sessionId: request.sessionId,
+                        messageId: request.messageId,
+                    });
+                }
+                const table = this.requireTable();
+                const stored = table.get(request.sessionId);
+                const current = stored !== undefined && sameIdentity(stored, durable.meta) ? stored : undefined;
+                const items = current?.items ?? EMPTY_ITEMS;
+                const index = items.findIndex(item => item.messageId === request.messageId);
+                const existing = items[index];
+                if (request.ifVersion !== (existing?.version ?? null)) {
+                    return rejected(this.versionConflict(existing ?? null));
+                }
+                if (existing !== undefined
+                    && existing.rating === request.rating
+                    && existing.note === note.value) {
+                    return success(snapshotItem(existing));
+                }
+                const now = Date.now();
+                const item = snapshotItem({
+                    messageId: request.messageId,
+                    rating: request.rating,
+                    ...(note.value === undefined ? {} : { note: note.value }),
+                    version: nextVersion(),
+                    createdAt: existing?.createdAt ?? now,
+                    updatedAt: existing === undefined ? now : Math.max(now, existing.updatedAt),
+                });
+                const nextItems = [...items];
+                if (index === -1)
+                    nextItems.push(item);
+                else
+                    nextItems[index] = item;
+                await table.put(request.sessionId, rowSnapshot(identityOf(durable.meta), nextItems));
+                return success(snapshotItem(item));
+            });
+        }
+        /**
+         * Delete one feedback item. Absence is successful regardless of the
+         * supplied version; an existing item requires an exact version match.
+         * @param request - Session, message, and observed item version.
+         * @returns the stable absent postcondition, or an explicit failure.
+         */
+        delete(request) {
+            return this.enqueue(request.sessionId, async () => {
+                const known = await this.inspectSession(request.sessionId);
+                if (!known.ok)
+                    return known;
+                const table = this.requireTable();
+                const stored = table.get(request.sessionId);
+                const current = stored !== undefined && sameIdentity(stored, known.value.meta) ? stored : undefined;
+                const items = current?.items ?? EMPTY_ITEMS;
+                const existing = items.find(item => item.messageId === request.messageId);
+                if (existing === undefined) {
+                    return success(Object.freeze({ absent: true }));
+                }
+                if (request.ifVersion !== existing.version) {
+                    return rejected(this.versionConflict(existing));
+                }
+                await table.put(request.sessionId, rowSnapshot(identityOf(known.value.meta), items.filter(item => item !== existing)));
+                return success(Object.freeze({ absent: true }));
+            });
+        }
+        /**
+         * Resolve a live owner directly; otherwise use the storage catalog as the
+         * existence authority before inspecting the log. Inspection failures for a
+         * catalogued Session remain infrastructure failures rather than being
+         * guessed into the business `session-not-found` branch.
+         */
+        async inspectSession(sessionId) {
+            if (this.ctx.sessions.get(sessionId) === undefined) {
+                const snapshots = await this.ctx.sessionPersistence.listSnapshots();
+                if (!snapshots.some(snapshot => snapshot.header.id === sessionId)
+                    && this.ctx.sessions.get(sessionId) === undefined) {
+                    return rejected({ code: 'session-not-found', sessionId });
+                }
+            }
+            return success(await this.ctx.sessionPersistence.inspect(sessionId));
+        }
+        /** Require the exact finalized append-origin assistant message projection. */
+        hasFeedbackTarget(inspection, messageId) {
+            return inspection.events.some((event) => {
+                if (event.type !== 'assistant/message' || !isAppendSurfaceEvent(event))
+                    return false;
+                const message = deriveEventMessage(event);
+                return message?.role === 'assistant' && message.id === messageId;
+            });
+        }
+        /**
+         * Put the target log prefix behind a durability barrier before its sidecar.
+         * A live owner flushes through the SessionStore's canonical checkpoint; a
+         * cold owner is re-read from the physical durable prefix.
+         */
+        async ensureTargetDurable(inspection) {
+            const live = this.ctx.sessions.get(inspection.meta.id);
+            if (live !== undefined && sameHeaderIdentity(live.header, inspection.meta)) {
+                if (!(await this.ctx.sessions.flush(live))) {
+                    throw new Error(`message-feedback: no durability listener participated for live session '${inspection.meta.id}'`);
+                }
+                return await this.ctx.sessionPersistence.readFrom(inspection.meta.id, 0);
+            }
+            return await this.ctx.sessionPersistence.readFrom(inspection.meta.id, 0);
+        }
+        /** Validate optional-note semantics and the configured complete UTF-8 byte bound. */
+        resolveNote(note) {
+            if (note === undefined)
+                return success(undefined);
+            if (note.trim().length === 0)
+                return rejected({ code: 'note-blank' });
+            const actualBytes = Buffer.byteLength(note, 'utf8');
+            if (actualBytes > this.maxNoteBytes) {
+                return rejected({ code: 'note-too-large', maxBytes: this.maxNoteBytes, actualBytes });
+            }
+            return success(note);
+        }
+        /** Return the authoritative item needed to reconcile one failed comparison. */
+        versionConflict(current) {
+            return {
+                code: 'version-conflict',
+                current: current === null ? null : snapshotItem(current),
+            };
+        }
+        /** Queue a complete read/compare/write mutation behind this Session's prior mutation. */
+        enqueue(sessionId, operation) {
+            if (!this.mutationAdmissionOpen) {
+                return Promise.reject(new Error('message-feedback: service is disposing'));
+            }
+            const previous = this.operationTails.get(sessionId) ?? Promise.resolve();
+            const result = previous.then(operation);
+            const tail = result.then(() => undefined, () => undefined);
+            this.operationTails.set(sessionId, tail);
+            return result.finally(() => {
+                if (this.operationTails.get(sessionId) === tail)
+                    this.operationTails.delete(sessionId);
+            });
+        }
+        /** Resolve the initialized durable table or fail a broken service lifecycle. */
+        requireTable() {
+            if (this.table === undefined) {
+                throw new Error('message-feedback: durable domain is not initialized');
+            }
+            return this.table;
+        }
+    };
+})();
+export { MessageFeedbackService };
+export default MessageFeedbackService;
+//# sourceMappingURL=index.js.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,13 @@
+/** Package-owned invariant companion. @module @deepseek-ai/dsh-message-feedback/invariant */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "message-feedback-invariant";
+/** Services required before the companion can reserve and check package ownership. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/lib/types/invariant.js

@@ -0,0 +1,19 @@
+/** Package-owned invariant companion. @module @deepseek-ai/dsh-message-feedback/invariant */
+const PACKAGE_NAME = '@deepseek-ai/dsh-message-feedback';
+/** Cordis companion plugin name. */
+export const name = 'message-feedback-invariant';
+/** Services required before the companion can reserve and check package ownership. */
+export const inject = ['invariants'];
+/**
+ * No runtime invariant: the private typed writer owns current row mutations,
+ * the domain schema validates rows on reopen, and no second authority exists.
+ */
+const install = Object.assign(() => { }, { inject: ['messageFeedback'] });
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+/* jscpd:ignore-end */
+//# sourceMappingURL=invariant.js.map

package/lib/types/spec.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Durable storage-domain declaration for lifecycle-bound message feedback.
+ * @module @deepseek-ai/dsh-message-feedback/src/spec
+ */
+import { z } from 'zod';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { MessageFeedbackItem, MessageFeedbackVersion } from './types.ts';
+/** Runtime schema for the closed rating vocabulary. */
+export declare const messageFeedbackRatingSchema: z.ZodUnion<readonly [z.ZodLiteral<"positive">, z.ZodLiteral<"negative">]>;
+/** Runtime schema for one opaque item version stored on disk. */
+export declare const messageFeedbackVersionSchema: z.ZodPipe<z.ZodUUID, z.ZodTransform<MessageFeedbackVersion, string>>;
+/** Runtime schema for one current feedback item. */
+export declare const messageFeedbackItemSchema: z.ZodType<MessageFeedbackItem>;
+/** Persisted Session fields that fence a sidecar row to one log lifecycle. */
+export declare const messageFeedbackSessionIdentitySchema: z.ZodObject<{
+    createdAt: z.ZodNumber;
+    cwd: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Persisted lifecycle identity inferred from its durable schema. */
+export type MessageFeedbackSessionIdentity = z.infer<typeof messageFeedbackSessionIdentitySchema>;
+/**
+ * One whole-Session sidecar. Duplicate message ids would make item lookup
+ * ambiguous; duplicate versions would break their independent identity.
+ */
+export declare const messageFeedbackRowSchema: z.ZodObject<{
+    session: z.ZodObject<{
+        createdAt: z.ZodNumber;
+        cwd: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    items: z.ZodArray<z.ZodType<MessageFeedbackItem, unknown, z.core.$ZodTypeInternals<MessageFeedbackItem, unknown>>>;
+}, z.core.$strip>;
+/** Durable sidecar row inferred from {@link messageFeedbackRowSchema}. */
+export type MessageFeedbackRow = z.infer<typeof messageFeedbackRowSchema>;
+/** One lifecycle-bound sidecar record per Session id. */
+export declare const messageFeedbackDomainSpec: {
+    name: string;
+    version: number;
+    tables: {
+        sessions: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<SessionId, {
+            session: {
+                createdAt: number;
+                cwd?: string | undefined;
+            };
+            items: MessageFeedbackItem[];
+        }>;
+    };
+};
+//# sourceMappingURL=spec.d.ts.map

package/lib/types/spec.js

@@ -0,0 +1,74 @@
+/**
+ * Durable storage-domain declaration for lifecycle-bound message feedback.
+ * @module @deepseek-ai/dsh-message-feedback/src/spec
+ */
+import { z } from 'zod';
+import { defineDomain, domainTable } from '@deepseek-ai/dsh-storage-domain';
+const nonNegativeSafeInteger = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+/** Runtime schema for the closed rating vocabulary. */
+export const messageFeedbackRatingSchema = z.union([
+    z.literal('positive'),
+    z.literal('negative'),
+]);
+/** Runtime schema for one opaque item version stored on disk. */
+export const messageFeedbackVersionSchema = z.uuid()
+    .transform(value => value);
+/** Runtime schema for one current feedback item. */
+// Zod infers transformed branded fields structurally, so it cannot name the
+// public interface even though every branded output is created below.
+export const messageFeedbackItemSchema = z.object({
+    messageId: z.string().min(1).transform(value => value),
+    rating: messageFeedbackRatingSchema,
+    note: z.string().refine(note => note.trim().length > 0, {
+        message: 'message feedback note must contain a non-whitespace character',
+    }).optional(),
+    version: messageFeedbackVersionSchema,
+    createdAt: nonNegativeSafeInteger,
+    updatedAt: nonNegativeSafeInteger,
+}).refine(item => item.updatedAt >= item.createdAt, {
+    path: ['updatedAt'],
+    message: 'message feedback updatedAt must not precede createdAt',
+});
+/** Persisted Session fields that fence a sidecar row to one log lifecycle. */
+export const messageFeedbackSessionIdentitySchema = z.object({
+    createdAt: nonNegativeSafeInteger,
+    cwd: z.string().optional(),
+});
+/**
+ * One whole-Session sidecar. Duplicate message ids would make item lookup
+ * ambiguous; duplicate versions would break their independent identity.
+ */
+export const messageFeedbackRowSchema = z.object({
+    session: messageFeedbackSessionIdentitySchema,
+    items: z.array(messageFeedbackItemSchema),
+}).superRefine((row, ctx) => {
+    const messageIds = new Set();
+    const versions = new Set();
+    row.items.forEach((item, index) => {
+        if (messageIds.has(item.messageId)) {
+            ctx.addIssue({
+                code: 'custom',
+                path: ['items', index, 'messageId'],
+                message: `duplicate message feedback id '${item.messageId}'`,
+            });
+        }
+        messageIds.add(item.messageId);
+        if (versions.has(item.version)) {
+            ctx.addIssue({
+                code: 'custom',
+                path: ['items', index, 'version'],
+                message: `duplicate message feedback version '${item.version}'`,
+            });
+        }
+        versions.add(item.version);
+    });
+});
+/** One lifecycle-bound sidecar record per Session id. */
+export const messageFeedbackDomainSpec = defineDomain({
+    name: 'message_feedback',
+    version: 0,
+    tables: {
+        sessions: domainTable(messageFeedbackRowSchema),
+    },
+});
+//# sourceMappingURL=spec.js.map

package/lib/types/types.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Public request, value, and failure vocabulary for per-message feedback.
+ * This module contains types only so generated Remote clients can consume it
+ * without importing Host runtime code.
+ * @module @deepseek-ai/dsh-message-feedback/types
+ */
+import type { Branded } from '@deepseek-ai/dsh-brand';
+import type { MessageId } from '@deepseek-ai/dsh-llm/brand';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+/** Opaque compare-and-set token for one exact feedback item revision. */
+export type MessageFeedbackVersion = Branded<'MessageFeedbackVersion'>;
+/** The human's overall judgment of one assistant message. */
+export type MessageFeedbackRating = 'positive' | 'negative';
+/** One current feedback value and its opaque mutation token. */
+export interface MessageFeedbackItem {
+    /** Stable identity of the assistant message inside the owning Session. */
+    readonly messageId: MessageId;
+    /** Overall positive or negative judgment. */
+    readonly rating: MessageFeedbackRating;
+    /** Optional explanation, preserved verbatim after validation. */
+    readonly note?: string;
+    /** Equality-only token replaced by every material create or update. */
+    readonly version: MessageFeedbackVersion;
+    /** Host-assigned creation time in Unix epoch milliseconds. */
+    readonly createdAt: number;
+    /** Host-assigned time of the most recent material update. */
+    readonly updatedAt: number;
+}
+/** Read all message feedback belonging to one persisted Session lifecycle. */
+export interface MessageFeedbackListRequest {
+    /** Persisted Session whose sidecar should be read. */
+    readonly sessionId: SessionId;
+}
+/** Current feedback values for one Session, in first-creation order. */
+export interface MessageFeedbackListValue {
+    /** Fresh immutable item snapshots. */
+    readonly items: readonly MessageFeedbackItem[];
+}
+/** Create or replace feedback for one assistant message. */
+export interface MessageFeedbackPutRequest {
+    /** Persisted Session that owns the target message. */
+    readonly sessionId: SessionId;
+    /** Target assistant-message identity. */
+    readonly messageId: MessageId;
+    /** Desired overall judgment. */
+    readonly rating: MessageFeedbackRating;
+    /** Optional non-blank explanation. */
+    readonly note?: string;
+    /** Observed item version, or `null` to require that no item exists. */
+    readonly ifVersion: MessageFeedbackVersion | null;
+}
+/** Delete feedback for one message after observing its current version. */
+export interface MessageFeedbackDeleteRequest {
+    /** Persisted Session that owns the sidecar. */
+    readonly sessionId: SessionId;
+    /** Message whose feedback should be absent after this operation. */
+    readonly messageId: MessageId;
+    /** Observed item version; ignored when the item is already absent. */
+    readonly ifVersion: MessageFeedbackVersion;
+}
+/** Idempotent deletion acknowledgement. */
+export interface MessageFeedbackDeleteValue {
+    /** Stable postcondition shared by the first deletion and every retry. */
+    readonly absent: true;
+}
+/** No persisted Session header exists for the requested id. */
+export interface MessageFeedbackSessionNotFound {
+    readonly code: 'session-not-found';
+    readonly sessionId: SessionId;
+}
+/** The id does not name a derived, append-origin assistant message. */
+export interface MessageFeedbackTargetNotFound {
+    readonly code: 'target-not-found';
+    readonly sessionId: SessionId;
+    readonly messageId: MessageId;
+}
+/** A material mutation did not match the addressed item's current version. */
+export interface MessageFeedbackVersionConflict {
+    readonly code: 'version-conflict';
+    /** Authoritative current item, or `null` when it does not exist. */
+    readonly current: MessageFeedbackItem | null;
+}
+/** A supplied note contains no non-whitespace character. */
+export interface MessageFeedbackNoteBlank {
+    readonly code: 'note-blank';
+}
+/** A supplied note exceeds the configured UTF-8 byte limit. */
+export interface MessageFeedbackNoteTooLarge {
+    readonly code: 'note-too-large';
+    readonly maxBytes: number;
+    readonly actualBytes: number;
+}
+/** Failures shared by the public message-feedback operations. */
+export type MessageFeedbackFailure = MessageFeedbackSessionNotFound | MessageFeedbackTargetNotFound | MessageFeedbackVersionConflict | MessageFeedbackNoteBlank | MessageFeedbackNoteTooLarge;
+/** Successful public operation result. */
+export interface MessageFeedbackSuccess<T> {
+    readonly ok: true;
+    readonly value: T;
+}
+/** Rejected public operation result with a stable business failure. */
+export interface MessageFeedbackRejected<E extends MessageFeedbackFailure> {
+    readonly ok: false;
+    readonly error: E;
+}
+/** Result returned by the message-feedback `list` operation. */
+export type MessageFeedbackListResult = MessageFeedbackSuccess<MessageFeedbackListValue> | MessageFeedbackRejected<MessageFeedbackSessionNotFound>;
+/** Result returned by the message-feedback `put` operation. */
+export type MessageFeedbackPutResult = MessageFeedbackSuccess<MessageFeedbackItem> | MessageFeedbackRejected<MessageFeedbackSessionNotFound | MessageFeedbackTargetNotFound | MessageFeedbackVersionConflict | MessageFeedbackNoteBlank | MessageFeedbackNoteTooLarge>;
+/** Result returned by the message-feedback `delete` operation. */
+export type MessageFeedbackDeleteResult = MessageFeedbackSuccess<MessageFeedbackDeleteValue> | MessageFeedbackRejected<MessageFeedbackSessionNotFound | MessageFeedbackVersionConflict>;
+//# sourceMappingURL=types.d.ts.map

package/lib/types/types.js

@@ -0,0 +1,8 @@
+/**
+ * Public request, value, and failure vocabulary for per-message feedback.
+ * This module contains types only so generated Remote clients can consume it
+ * without importing Host runtime code.
+ * @module @deepseek-ai/dsh-message-feedback/types
+ */
+export {};
+//# sourceMappingURL=types.js.map