@prur/dsh-chat-service 0.1.14 → 0.1.16

package/lib/store.d.ts

@@ -10,12 +10,13 @@
  * append cannot corrupt a log.
  * @module @prur/dsh-chat-service/src/store
  */
-import type { ChatMessage, ChatTextBlock } from './types.ts';
+import type { ChatBlock, ChatMessage } from './types.ts';
 /** One still-queued user send (content persisted before the turn runs). */
 export interface PendingSend {
     /** Persisted user message seq this send belongs to — the turn's context boundary. */
     readonly seq: number;
-    readonly content: readonly ChatTextBlock[];
+    /** Persisted blocks of the user message (durable refs; no upload bytes). */
+    readonly content: readonly ChatBlock[];
     readonly createdAt: number;
 }
 /** Durable per-conversation record, held in `index.json`. */
@@ -32,6 +33,14 @@ export interface ChatIndexRecord {
     readonly queue: readonly PendingSend[];
     /** Mirror of the live run state, persisted so restart recovery can resume the queue. */
     readonly running: boolean;
+    /** Archive flag (M4); legacy records treat absence as false. */
+    readonly archived?: boolean;
+    /**
+     * Durable monotonic sequence high-water mark (never reused — even when a
+     * message is deleted, the next allocated seq keeps advancing). Legacy
+     * records without the field normalize from their log on first use.
+     */
+    readonly seqHighWater: number;
 }
 /** Storage failure raised by a missing conversation; mapped to an RPC error. */
 export declare class ChatStorageError extends Error {
@@ -62,18 +71,64 @@ export declare class ChatStore {
     /** @throws {@link ChatStorageError} when the conversation does not exist. */
     require(conversationId: string): Promise<ChatIndexRecord>;
     put(record: ChatIndexRecord): Promise<void>;
+    /**
+     * Atomic read-modify-write of one conversation record: the read and the
+     * write happen inside one store-wide write lock, so a concurrent queue
+     * append / flag flip cannot be lost to an outdated snapshot (the
+     * require-then-put pattern is a lost-update hazard under concurrent
+     * `chat/send` / `chat/regenerate` / turn bookkeeping).
+     * @throws {@link ChatStorageError} when the conversation does not exist.
+     */
+    mutateRecord(conversationId: string, mutate: (record: ChatIndexRecord) => ChatIndexRecord): Promise<ChatIndexRecord>;
     /** Delete a conversation and its log; idempotent. */
     remove(conversationId: string): Promise<void>;
     readMessages(conversationId: string): Promise<ChatMessage[]>;
+    /**
+     * Serialize one combined conversation mutation (read record + messages,
+     * write index, optionally rewrite the log) under the store-wide write
+     * lock. Competing tail mutations (regenerate / send / deleteMessage) are
+     * serialized at this boundary, so a second regenerate cannot double-enqueue
+     * the same turn against a stale view (review P1).
+     */
+    mutateConversation<T>(conversationId: string, mutate: (record: ChatIndexRecord, messages: ChatMessage[]) => Promise<{
+        nextRecord: ChatIndexRecord;
+        nextMessages?: ChatMessage[];
+        result: T;
+    }>): Promise<T>;
+    /**
+     * Allocate the next monotonic message seq from the record high-water mark
+     * and persist the bump atomically. Sequence identities are never reused —
+     * even after a message is deleted, the next allocation keeps advancing
+     * (a crash between this bump and the log append only skips a seq).
+     */
+    reserveTurnSeq(conversationId: string): Promise<number>;
     /**
      * Append one message under the write lock and maintain the per-conversation
      * cap: when the cap would be exceeded, the oldest messages are dropped and
      * a system marker row is appended in their place (client renders a notice).
+     * The marker seq is a fresh high-water value (above every real seq), so a
+     * trimmed conversation keeps clean monotonic anchors.
      * @returns whether trimming occurred.
      */
     appendMessage(conversationId: string, message: ChatMessage): Promise<{
         trimmed: boolean;
     }>;
+    /**
+     * Normalize legacy records without `seqHighWater`: persist the log's max
+     * seq so regeneration and future allocations keep monotonic identity.
+     */
+    normalizeSeqHighWaters(): Promise<void>;
+    /**
+     * Rewrite the log without one message (design §2.3: host rewrites the
+     * message file; subsequent context assembly recalculates). Missing seq is
+     * reported via `removed: false` (idempotent). Never touches the running
+     * flag or the queue — queued sends bound to the deleted seq are dropped by
+     * the caller.
+     * @returns whether a message with `seq` was present and removed.
+     */
+    deleteMessage(conversationId: string, seq: number): Promise<{
+        removed: boolean;
+    }>;
     /**
      * Page history newest-first paging semantics like `session.history`: the
      * tail page (no `beforeSeq`) returns the newest `maxMessages` messages in

package/lib/store.js

@@ -26,6 +26,15 @@ export class ChatStorageError extends Error {
 export const CHAT_MESSAGE_CAP = 500;
 /** Marker row inserted after trimming: keeps the timeline readable for clients. */
 export const CHAT_TRIM_MARKER_TEXT = '上下文已裁剪';
+/** Next monotonic message sequence from a history's max seq (legacy path). */
+function nextSeqOf(messages) {
+    let last = 0;
+    for (const message of messages) {
+        if (message.seq > last)
+            last = message.seq;
+    }
+    return last + 1;
+}
 /** conversationId charset guard: ids are opaque tokens, never path syntax. */
 const CONVERSATION_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
 /** Whether a candidate conversation id is safe to use as a filename stem. */
@@ -62,6 +71,12 @@ export class ChatStore {
         return join(this.chatHome, 'index.json');
     }
     logPath(conversationId) {
+        // 纵深防御（安全审计 2026-08-26）：RPC 边界的 zod regex 是唯一闸门——若未来
+        // 新增 @Remote 路径漏用该 codec，join() 会直接逃逸 $DSH_HOME/chat。store 层
+        // 重校验一次，把"路径安全"从不变量化边界提前到每个文件操作。
+        if (!isSafeConversationId(conversationId)) {
+            throw new ChatStorageError('corrupt', `chat store: unsafe conversationId ${JSON.stringify(conversationId)}`);
+        }
         return join(this.chatHome, `${conversationId}.jsonl`);
     }
     /** Serialize every mutation: one store-wide chain, errors contained per op. */
@@ -98,6 +113,27 @@ export class ChatStore {
             await writeFileAtomic(this.indexPath(), JSON.stringify(next, null, 2));
         });
     }
+    /**
+     * Atomic read-modify-write of one conversation record: the read and the
+     * write happen inside one store-wide write lock, so a concurrent queue
+     * append / flag flip cannot be lost to an outdated snapshot (the
+     * require-then-put pattern is a lost-update hazard under concurrent
+     * `chat/send` / `chat/regenerate` / turn bookkeeping).
+     * @throws {@link ChatStorageError} when the conversation does not exist.
+     */
+    async mutateRecord(conversationId, mutate) {
+        return this.withWriteLock(async () => {
+            const records = await readJson(this.indexPath(), []);
+            const index = records.findIndex(record => record.conversationId === conversationId);
+            if (index < 0) {
+                throw new ChatStorageError('conversation-not-found', `chat: conversation "${conversationId}" does not exist`);
+            }
+            const next = mutate(records[index]);
+            records[index] = next;
+            await writeFileAtomic(this.indexPath(), JSON.stringify(records, null, 2));
+            return next;
+        });
+    }
     /** Delete a conversation and its log; idempotent. */
     async remove(conversationId) {
         return this.withWriteLock(async () => {
@@ -131,15 +167,72 @@ export class ChatStore {
             throw new ChatStorageError('io', `chat: cannot read log: ${error.message}`);
         }
     }
+    /**
+     * Serialize one combined conversation mutation (read record + messages,
+     * write index, optionally rewrite the log) under the store-wide write
+     * lock. Competing tail mutations (regenerate / send / deleteMessage) are
+     * serialized at this boundary, so a second regenerate cannot double-enqueue
+     * the same turn against a stale view (review P1).
+     */
+    async mutateConversation(conversationId, mutate) {
+        return this.withWriteLock(async () => {
+            const records = await readJson(this.indexPath(), []);
+            const index = records.findIndex(record => record.conversationId === conversationId);
+            if (index < 0) {
+                throw new ChatStorageError('conversation-not-found', `chat: conversation "${conversationId}" does not exist`);
+            }
+            const messages = await this.readMessages(conversationId);
+            const { nextRecord, nextMessages, result } = await mutate(records[index], messages);
+            records[index] = nextRecord;
+            await writeFileAtomic(this.indexPath(), JSON.stringify(records, null, 2));
+            if (nextMessages !== undefined) {
+                await writeFileAtomic(this.logPath(conversationId), `${nextMessages.map(item => JSON.stringify(item)).join('\n')}\n`);
+            }
+            return result;
+        });
+    }
+    /**
+     * Allocate the next monotonic message seq from the record high-water mark
+     * and persist the bump atomically. Sequence identities are never reused —
+     * even after a message is deleted, the next allocation keeps advancing
+     * (a crash between this bump and the log append only skips a seq).
+     */
+    async reserveTurnSeq(conversationId) {
+        return this.withWriteLock(async () => {
+            await this.ensure();
+            const records = await readJson(this.indexPath(), []);
+            const index = records.findIndex(record => record.conversationId === conversationId);
+            if (index < 0) {
+                throw new ChatStorageError('conversation-not-found', `chat: conversation "${conversationId}" does not exist`);
+            }
+            const record = records[index];
+            const messages = await this.readMessages(conversationId);
+            const next = (record.seqHighWater ?? nextSeqOf(messages)) + 1;
+            records[index] = { ...record, seqHighWater: next };
+            await writeFileAtomic(this.indexPath(), JSON.stringify(records, null, 2));
+            return next;
+        });
+    }
     /**
      * Append one message under the write lock and maintain the per-conversation
      * cap: when the cap would be exceeded, the oldest messages are dropped and
      * a system marker row is appended in their place (client renders a notice).
+     * The marker seq is a fresh high-water value (above every real seq), so a
+     * trimmed conversation keeps clean monotonic anchors.
      * @returns whether trimming occurred.
      */
     async appendMessage(conversationId, message) {
         return this.withWriteLock(async () => {
             await this.ensure();
+            // 锁内核对 index 存在性：对话已删除时其日志必须一起死亡——并发
+            // chat/delete 与 send 的竞态若绕开此检查，会按旧路径复活一个孤儿日志
+            // （index 是唯一事实源；孤儿文件客户端不可见，但会永久残留）。
+            const records = await readJson(this.indexPath(), []);
+            const index = records.findIndex(item => item.conversationId === conversationId);
+            if (index < 0) {
+                throw new ChatStorageError('conversation-not-found', `chat: conversation "${conversationId}" does not exist`);
+            }
+            const record = records[index];
             const messages = await this.readMessages(conversationId);
             messages.push(message);
             const excess = messages.length - CHAT_MESSAGE_CAP;
@@ -150,20 +243,65 @@ export class ChatStore {
                 // One marker at a time: drop every existing system row, then trim the
                 // oldest real rows to the cap minus the marker slot, then append the
                 // fresh marker (a notice at the trim boundary, not a per-append flood).
-                const real = messages.filter(message => message.role !== 'system');
+                const real = messages.filter(item => item.role !== 'system');
                 const kept = real.slice(real.length - (CHAT_MESSAGE_CAP - 1));
+                const markerSeq = (record.seqHighWater ?? nextSeqOf(messages)) + 1;
                 const marker = {
-                    seq: message.seq + excess,
+                    seq: markerSeq,
                     role: 'system',
                     blocks: [{ type: 'text', text: CHAT_TRIM_MARKER_TEXT }],
                     createdAt: Date.now(),
                 };
+                records[index] = { ...record, seqHighWater: markerSeq };
+                await writeFileAtomic(this.indexPath(), JSON.stringify(records, null, 2));
                 next = [...kept, marker];
             }
             await writeFileAtomic(this.logPath(conversationId), `${next.map(item => JSON.stringify(item)).join('\n')}\n`);
             return { trimmed };
         });
     }
+    /**
+     * Normalize legacy records without `seqHighWater`: persist the log's max
+     * seq so regeneration and future allocations keep monotonic identity.
+     */
+    async normalizeSeqHighWaters() {
+        return this.withWriteLock(async () => {
+            const records = await readJson(this.indexPath(), []);
+            let changed = false;
+            for (const record of records) {
+                if (record.seqHighWater === undefined) {
+                    const messages = await this.readMessages(record.conversationId);
+                    records[records.findIndex(item => item.conversationId === record.conversationId)] = {
+                        ...record,
+                        seqHighWater: nextSeqOf(messages),
+                        archived: record.archived === true,
+                    };
+                    changed = true;
+                }
+            }
+            if (changed) {
+                await writeFileAtomic(this.indexPath(), JSON.stringify(records, null, 2));
+            }
+        });
+    }
+    /**
+     * Rewrite the log without one message (design §2.3: host rewrites the
+     * message file; subsequent context assembly recalculates). Missing seq is
+     * reported via `removed: false` (idempotent). Never touches the running
+     * flag or the queue — queued sends bound to the deleted seq are dropped by
+     * the caller.
+     * @returns whether a message with `seq` was present and removed.
+     */
+    async deleteMessage(conversationId, seq) {
+        return this.withWriteLock(async () => {
+            const messages = await this.readMessages(conversationId);
+            const next = messages.filter(message => message.seq !== seq);
+            if (next.length === messages.length)
+                return { removed: false };
+            await writeFileAtomic(this.logPath(conversationId), `${next.map(item => JSON.stringify(item)).join('\n')}\n`);
+            return { removed: true };
+        });
+    }
     /**
      * Page history newest-first paging semantics like `session.history`: the
      * tail page (no `beforeSeq`) returns the newest `maxMessages` messages in

package/lib/typert.host.js

@@ -16,10 +16,23 @@ const textBlockSchema = z.object({
     type: z.literal('text'),
     text: z.string(),
 }).readonly();
+const imageRefSchema = z.object({
+    attachmentId: z.string().min(1),
+    mediaType: z.enum(['image/png', 'image/jpeg', 'image/webp', 'image/gif']),
+    bytes: z.number().int().nonnegative(),
+    width: z.number().int().positive(),
+    height: z.number().int().positive(),
+    name: z.string().optional(),
+}).readonly();
+const imageBlockSchema = z.object({
+    type: z.literal('image'),
+    attachment: imageRefSchema,
+}).readonly();
+const blockSchema = z.union([textBlockSchema, imageBlockSchema]);
 const messageSchema = z.object({
     seq: z.number().int().nonnegative(),
     role: z.enum(['user', 'assistant', 'system']),
-    blocks: z.array(textBlockSchema).readonly(),
+    blocks: z.array(blockSchema).readonly(),
     model: z.string().optional(),
     provider: z.string().optional(),
     createdAt: z.number().int().nonnegative().optional(),
@@ -33,6 +46,7 @@ const summarySchema = z.object({
     updatedAt: z.number().int().nonnegative(),
     messageCount: z.number().int().nonnegative(),
     running: z.boolean(),
+    archived: z.boolean(),
 }).readonly();
 const settingsSchema = z.object({
     conversationId: conversationIdSchema,
@@ -49,7 +63,13 @@ const patchSchema = z.object({
     temperature: z.number().nullable().optional(),
     contextMessages: z.number().int().positive().nullable().optional(),
 }).readonly();
-const contentSchema = z.array(textBlockSchema).min(1).readonly();
+const imageUploadSchema = z.object({
+    type: z.literal('image'),
+    mediaType: z.enum(['image/png', 'image/jpeg', 'image/webp', 'image/gif']),
+    data: z.string().min(1),
+    name: z.string().optional(),
+}).readonly();
+const contentSchema = z.array(z.union([textBlockSchema, imageUploadSchema])).min(1).readonly();
 const emptyOkSchema = z.object({}).readonly();
 const listResultSchema = z.object({
     ok: z.literal(true),
@@ -82,6 +102,27 @@ const updateResultSchema = z.object({
     ok: z.literal(true),
     value: settingsSchema,
 }).readonly();
+const deleteMessageResultSchema = z.object({
+    ok: z.literal(true),
+    value: z.object({ removed: z.boolean() }),
+}).readonly();
+const regenerateResultSchema = sendResultSchema;
+const capabilitiesResultSchema = z.object({
+    ok: z.literal(true),
+    value: z.object({
+        provider: z.string(),
+        model: z.string(),
+        imageInput: z.boolean(),
+        contextWindow: z.number().int().positive().nullable(),
+    }),
+}).readonly();
+const attachmentResultSchema = z.object({
+    ok: z.literal(true),
+    value: z.object({
+        attachment: imageRefSchema,
+        data: z.string(),
+    }),
+}).readonly();
 const RESULT_TYPE_SYMBOLS = {
     list: '@prur/dsh-chat-service/types#ChatListResult',
     create: '@prur/dsh-chat-service/types#ChatCreateResult',
@@ -92,6 +133,11 @@ const RESULT_TYPE_SYMBOLS = {
     cancel: '@prur/dsh-chat-service/types#ChatEmptyResult',
     selectModel: '@prur/dsh-chat-service/types#ChatSelectModelResult',
     update: '@prur/dsh-chat-service/types#ChatUpdateResult',
+    deleteMessage: '@prur/dsh-chat-service/types#ChatDeleteMessageResult',
+    regenerate: '@prur/dsh-chat-service/types#ChatRegenerateResult',
+    capabilities: '@prur/dsh-chat-service/types#ChatCapabilitiesResult',
+    attachment: '@prur/dsh-chat-service/types#ChatAttachmentResult',
+    archive: '@prur/dsh-chat-service/types#ChatEmptyResult',
 };
 const invocation = (id, method, parameters, result) => ({
     id: `@prur/dsh-chat-service#${id}`,
@@ -131,7 +177,7 @@ export const TYPERT = {
         ], historyResultSchema),
         invocation('chat/send', 'send', [
             { name: 'conversationId', wire: 'conversationId', source: 'json', codec: { mode: 'strict', typeSymbol: 'string', schema: conversationIdSchema } },
-            { name: 'content', wire: 'content', source: 'json', codec: { mode: 'strict', typeSymbol: '@prur/dsh-chat-service/types#ChatTextBlock[]', schema: contentSchema } },
+            { name: 'content', wire: 'content', source: 'json', codec: { mode: 'strict', typeSymbol: '@prur/dsh-chat-service/types#ChatContentPart[]', schema: contentSchema } },
         ], sendResultSchema),
         invocation('chat/cancel', 'cancel', [
             { name: 'conversationId', wire: 'conversationId', source: 'json', codec: { mode: 'strict', typeSymbol: 'string', schema: conversationIdSchema } },
@@ -145,6 +191,24 @@ export const TYPERT = {
             { name: 'conversationId', wire: 'conversationId', source: 'json', codec: { mode: 'strict', typeSymbol: 'string', schema: conversationIdSchema } },
             { name: 'patch', wire: 'patch', source: 'json', codec: { mode: 'strict', typeSymbol: '@prur/dsh-chat-service/types#ChatUpdatePatch', schema: patchSchema } },
         ], updateResultSchema),
+        invocation('chat/archive', 'archive', [
+            { name: 'conversationId', wire: 'conversationId', source: 'json', codec: { mode: 'strict', typeSymbol: 'string', schema: conversationIdSchema } },
+            { name: 'archived', wire: 'archived', source: 'json', codec: { mode: 'strict', typeSymbol: 'boolean', schema: z.boolean() } },
+        ], emptyResultSchema),
+        invocation('chat/deleteMessage', 'deleteMessage', [
+            { name: 'conversationId', wire: 'conversationId', source: 'json', codec: { mode: 'strict', typeSymbol: 'string', schema: conversationIdSchema } },
+            { name: 'seq', wire: 'seq', source: 'json', codec: { mode: 'strict', typeSymbol: 'number', schema: z.number().int().nonnegative() } },
+        ], deleteMessageResultSchema),
+        invocation('chat/regenerate', 'regenerate', [
+            { name: 'conversationId', wire: 'conversationId', source: 'json', codec: { mode: 'strict', typeSymbol: 'string', schema: conversationIdSchema } },
+        ], regenerateResultSchema),
+        invocation('chat/capabilities', 'capabilities', [
+            { name: 'conversationId', wire: 'conversationId', source: 'json', codec: { mode: 'strict', typeSymbol: 'string', schema: conversationIdSchema } },
+        ], capabilitiesResultSchema),
+        invocation('chat/attachment', 'attachment', [
+            { name: 'conversationId', wire: 'conversationId', source: 'json', codec: { mode: 'strict', typeSymbol: 'string', schema: conversationIdSchema } },
+            { name: 'attachmentId', wire: 'attachmentId', source: 'json', codec: { mode: 'strict', typeSymbol: 'string', schema: z.string().min(1) } },
+        ], attachmentResultSchema),
     ],
     model: {
         services: [],

package/lib/typert.remote-client.js

@@ -15,6 +15,11 @@ const RESULT_TYPE_SYMBOLS = {
     cancel: '@prur/dsh-chat-service/types#ChatEmptyResult',
     selectModel: '@prur/dsh-chat-service/types#ChatSelectModelResult',
     update: '@prur/dsh-chat-service/types#ChatUpdateResult',
+    deleteMessage: '@prur/dsh-chat-service/types#ChatDeleteMessageResult',
+    regenerate: '@prur/dsh-chat-service/types#ChatRegenerateResult',
+    capabilities: '@prur/dsh-chat-service/types#ChatCapabilitiesResult',
+    attachment: '@prur/dsh-chat-service/types#ChatAttachmentResult',
+    archive: '@prur/dsh-chat-service/types#ChatEmptyResult',
 };
 const descriptor = (id, method, parameters) => ({
     id: `@prur/dsh-chat-service#${id}`,
@@ -65,6 +70,24 @@ export const TYPERT_REMOTE = {
             { name: 'conversationId', wire: 'conversationId', source: 'json' },
             { name: 'patch', wire: 'patch', source: 'json' },
         ]),
+        descriptor('chat/archive', 'archive', [
+            { name: 'conversationId', wire: 'conversationId', source: 'json' },
+            { name: 'archived', wire: 'archived', source: 'json' },
+        ]),
+        descriptor('chat/deleteMessage', 'deleteMessage', [
+            { name: 'conversationId', wire: 'conversationId', source: 'json' },
+            { name: 'seq', wire: 'seq', source: 'json' },
+        ]),
+        descriptor('chat/regenerate', 'regenerate', [
+            { name: 'conversationId', wire: 'conversationId', source: 'json' },
+        ]),
+        descriptor('chat/capabilities', 'capabilities', [
+            { name: 'conversationId', wire: 'conversationId', source: 'json' },
+        ]),
+        descriptor('chat/attachment', 'attachment', [
+            { name: 'conversationId', wire: 'conversationId', source: 'json' },
+            { name: 'attachmentId', wire: 'attachmentId', source: 'json' },
+        ]),
     ],
 };
 export default TYPERT_REMOTE;

package/lib/types.d.ts

@@ -4,11 +4,43 @@
  * shape lives here; the DSH-Mobile SDK mirrors it in `ChatRemoteClient`.
  * @module @prur/dsh-chat-service/src/types
  */
-/** One text content block (v1 keeps chat text-only; image blocks arrive with M3). */
+/** One text content block. */
 export interface ChatTextBlock {
     readonly type: 'text';
     readonly text: string;
 }
+/**
+ * A durable raster image reference carried by a persisted chat message.
+ * The bytes live in the harness attachment store; clients fetch them through
+ * `chat/attachment` after proving the conversation references the id
+ * (`chat/history` / `chat/message` events carry this ref in the block).
+ */
+export interface ChatImageAttachmentRef {
+    readonly attachmentId: string;
+    readonly mediaType: 'image/png' | 'image/jpeg' | 'image/webp' | 'image/gif';
+    readonly bytes: number;
+    readonly width: number;
+    readonly height: number;
+    readonly name?: string;
+}
+/** One image content block as persisted on the wire (ref without bytes). */
+export interface ChatImageBlock {
+    readonly type: 'image';
+    readonly attachment: ChatImageAttachmentRef;
+}
+/**
+ * One client-submitted content part for `chat/send`: a text span, or a
+ * base64 image upload admitted against the deployment's attachment limits
+ * and promoted to a durable {@link ChatImageBlock} on the message.
+ */
+export type ChatContentPart = ChatTextBlock | {
+    readonly type: 'image';
+    readonly mediaType: ChatImageAttachmentRef['mediaType'];
+    readonly data: string;
+    readonly name?: string;
+};
+/** One chat message content block persisted on the wire. */
+export type ChatBlock = ChatTextBlock | ChatImageBlock;
 /** Reason a running turn settled, carried by the `chat/status` event. */
 export type ChatTurnReason = 'completed' | 'aborted' | 'error' | 'max-tokens' | 'context-trimmed';
 /**
@@ -18,7 +50,7 @@ export type ChatTurnReason = 'completed' | 'aborted' | 'error' | 'max-tokens' |
 export interface ChatMessage {
     readonly seq: number;
     readonly role: 'user' | 'assistant' | 'system';
-    readonly blocks: readonly ChatTextBlock[];
+    readonly blocks: readonly ChatBlock[];
     /** Provider route that produced an assistant message. */
     readonly model?: string;
     /** Provider route key that produced an assistant message. */
@@ -45,6 +77,8 @@ export interface ChatConversationSummary {
     readonly updatedAt: number;
     readonly messageCount: number;
     readonly running: boolean;
+    /** Archived conversations stay in the store but drop out of the active view. */
+    readonly archived: boolean;
 }
 /** Settings view of one conversation (returned by `chat/update`). */
 export interface ChatConversationSettings {
@@ -57,6 +91,15 @@ export interface ChatConversationSettings {
     readonly systemPrompt: string | null;
     readonly updatedAt: number;
 }
+/**
+ * One `chat/update` field patch: `undefined` keeps the current value,
+ * `null` unsets it.
+ */
+export interface ChatUpdatePatch {
+    readonly systemPrompt?: string | null;
+    readonly temperature?: number | null;
+    readonly contextMessages?: number | null;
+}
 /** Successful chats of `chat/list`. */
 export type ChatListResult = {
     readonly ok: true;
@@ -104,3 +147,38 @@ export type ChatUpdateResult = {
     readonly ok: true;
     readonly value: ChatConversationSettings;
 };
+/** Successful value of `chat/deleteMessage` (idempotent: removed or absent). */
+export type ChatDeleteMessageResult = {
+    readonly ok: true;
+    readonly value: {
+        readonly removed: boolean;
+    };
+};
+/** Successful value of `chat/regenerate`. */
+export type ChatRegenerateResult = {
+    readonly ok: true;
+    readonly value: {
+        readonly accepted: true;
+    };
+};
+/** Successful value of `chat/capabilities`. */
+export type ChatCapabilitiesResult = {
+    readonly ok: true;
+    readonly value: {
+        readonly provider: string;
+        readonly model: string;
+        /** Whether the model accepts image input (adapter `inputModalities`). */
+        readonly imageInput: boolean;
+        /** Advertised context window in tokens; null when unknown. */
+        readonly contextWindow: number | null;
+    };
+};
+/** Successful value of `chat/attachment`. */
+export type ChatAttachmentResult = {
+    readonly ok: true;
+    readonly value: {
+        readonly attachment: ChatImageAttachmentRef;
+        /** Canonical base64 encoding of the image bytes. */
+        readonly data: string;
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prur/dsh-chat-service",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Typert Remote namespace exposing a plain streaming model chat (no agent loop) to DSH Mobile clients",
   "repository": {
     "type": "git",
@@ -32,17 +32,18 @@
   },
   "dsh": null,
   "dependencies": {
-    "zod": "^4.4.3",
     "@deepseek-ai/schemastery": "^3.18.1",
     "ws": "^8.21.0",
-    "@prur/dsh-client-connection-mobile": "^0.1.14"
+    "zod": "^4.4.3",
+    "@prur/dsh-client-connection-mobile": "^0.1.16"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-attachment": "^0.1.0-rc.8 || ^0.1.1-rc.2",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.0-rc.8 || ^0.1.1-rc.2",
     "@deepseek-ai/dsh-invariants": "^0.1.0-rc.8 || ^0.1.1-rc.2",
     "@deepseek-ai/dsh-llm": "^0.1.0-rc.8 || ^0.1.1-rc.2",
-    "@deepseek-ai/dsh-typert-protocol": "^0.1.0-rc.8 || ^0.1.1-rc.2",
-    "@deepseek-ai/dsh-host-webserver": "^0.1.0-rc.8 || ^0.1.1-rc.2"
+    "@deepseek-ai/dsh-typert-protocol": "^0.1.0-rc.8 || ^0.1.1-rc.2"
   },
   "files": [
     "lib/*.js",