@prur/dsh-chat-service 0.1.15 → 0.1.16

package/lib/engine.d.ts

@@ -4,20 +4,48 @@
  * in this repo directly against these functions.
  * @module @prur/dsh-chat-service/src/engine
  */
-import type { ChatMessage } from './types.ts';
+import type { ChatImageAttachmentRef, ChatMessage } from './types.ts';
 /** Truncated title derived from the first user message. */
 export declare const TITLE_MAX_CHARS = 30;
 /** Rough token estimate (4 chars per token) for context-window trimming. */
 export declare const CHARS_PER_TOKEN = 4;
+/**
+ * Rough token estimate for one image block: one token per 85×85 tile
+ * (the conventional vision-model pricing granularity), rounding up.
+ */
+export declare const IMAGE_TILE_EDGE = 85;
 /** Context-window utilization kept under this fraction before trimming. */
 export declare const CONTEXT_WINDOW_SAFETY = 0.9;
+/** One model-facing content part produced by context assembly. */
+export type AssembledContentPart = {
+    readonly type: 'text';
+    readonly text: string;
+} | {
+    readonly type: 'image';
+    readonly attachment: ChatImageAttachmentRef;
+};
+/**
+ * The producer provenance DSH's `ctx.llm.stream` requires on every message
+ * (`Message.source`, `message.ts`). Without it the llm layer's `forAdapter`
+ * reads `source.kind` on an assistant message and throws
+ * "Cannot read properties of undefined (reading 'kind')" — the chat multi-turn
+ * failure. A user message is `{kind:'user'}`; an assistant message is
+ * `{kind:'model', provider, model}` (no `replayState`, so the llm layer returns
+ * the message unchanged rather than rewriting its provenance).
+ */
+export type AssembledMessageSource = {
+    readonly kind: 'user';
+} | {
+    readonly kind: 'model';
+    readonly provider: string;
+    readonly model: string;
+};
 /** One model-facing message produced by context assembly. */
 export interface AssembledMessage {
     readonly role: 'user' | 'assistant';
-    readonly content: readonly {
-        readonly type: 'text';
-        readonly text: string;
-    }[];
+    readonly content: readonly AssembledContentPart[];
+    /** Required by DSH's llm layer; see {@link AssembledMessageSource}. */
+    readonly source: AssembledMessageSource;
 }
 /** Derived one-line title from a prompt's text; null for empty prompts. */
 export declare function deriveTitle(text: string): string | null;
@@ -28,6 +56,19 @@ export interface ContextAssemblyResult {
     /** True when the context-window estimate trimmed older messages. */
     readonly windowTrimmed: boolean;
 }
+/**
+ * Resolve the regenerate pair: the last assistant message and THE user
+ * message it answers (turn association). Returns undefined when there is no
+ * assistant message at all; `user` is undefined when the turn association is
+ * broken — the user message immediately preceding the assistant is missing
+ * (deleted) or not the last row before it (an intervening message makes the
+ * association ambiguous), which the service rejects rather than silently
+ * regenerating an unrelated older prompt (review P1).
+ */
+export declare function regenerateTarget(history: readonly ChatMessage[]): {
+    assistant: ChatMessage;
+    user: ChatMessage | undefined;
+} | undefined;
 /**
  * Assemble the model-facing message list for one turn. System marker rows and
  * failed assistant messages are excluded; `contextMessages` (when set) keeps
@@ -35,5 +76,5 @@ export interface ContextAssemblyResult {
  * messages when the rough token count would overflow the model window.
  */
 export declare function assembleContext(history: readonly ChatMessage[], contextMessages: number | null, contextWindow: number | null): ContextAssemblyResult;
-/** Rough token estimate for one message's text blocks. */
+/** Rough token estimate for one message's text and image blocks. */
 export declare function estimateTokens(message: ChatMessage): number;

package/lib/engine.js

@@ -8,8 +8,19 @@
 export const TITLE_MAX_CHARS = 30;
 /** Rough token estimate (4 chars per token) for context-window trimming. */
 export const CHARS_PER_TOKEN = 4;
+/**
+ * Rough token estimate for one image block: one token per 85×85 tile
+ * (the conventional vision-model pricing granularity), rounding up.
+ */
+export const IMAGE_TILE_EDGE = 85;
 /** Context-window utilization kept under this fraction before trimming. */
 export const CONTEXT_WINDOW_SAFETY = 0.9;
+/** Provenance for an assembled message derived from its chat log row. */
+function sourceFor(role, message) {
+    return role === 'user'
+        ? { kind: 'user' }
+        : { kind: 'model', provider: message.provider ?? 'unknown', model: message.model ?? 'unknown' };
+}
 /** Derived one-line title from a prompt's text; null for empty prompts. */
 export function deriveTitle(text) {
     const firstLine = text.replace(/\s+/g, ' ').trim();
@@ -22,6 +33,28 @@ export function deriveTitle(text) {
 function isUsable(message) {
     return message.role !== 'system' && message.error === undefined;
 }
+/**
+ * Resolve the regenerate pair: the last assistant message and THE user
+ * message it answers (turn association). Returns undefined when there is no
+ * assistant message at all; `user` is undefined when the turn association is
+ * broken — the user message immediately preceding the assistant is missing
+ * (deleted) or not the last row before it (an intervening message makes the
+ * association ambiguous), which the service rejects rather than silently
+ * regenerating an unrelated older prompt (review P1).
+ */
+export function regenerateTarget(history) {
+    for (let index = history.length - 1; index >= 0; index -= 1) {
+        const candidate = history[index];
+        if (candidate.role !== 'assistant')
+            continue;
+        const previous = history[index - 1];
+        if (previous !== undefined && previous.role === 'user') {
+            return { assistant: candidate, user: previous };
+        }
+        return { assistant: candidate, user: undefined };
+    }
+    return undefined;
+}
 /**
  * Assemble the model-facing message list for one turn. System marker rows and
  * failed assistant messages are excluded; `contextMessages` (when set) keeps
@@ -56,16 +89,27 @@ export function assembleContext(history, contextMessages, contextWindow) {
     return {
         messages: selected.map((message) => ({
             role: message.role,
-            content: message.blocks.map(block => ({ type: 'text', text: block.text })),
+            content: message.blocks.map(block => block.type === 'image'
+                ? { type: 'image', attachment: block.attachment }
+                : { type: 'text', text: block.text }),
+            source: sourceFor(message.role, message),
         })),
         contextMessages,
         windowTrimmed,
     };
 }
-/** Rough token estimate for one message's text blocks. */
+/** Rough token estimate for one message's text and image blocks. */
 export function estimateTokens(message) {
-    let chars = 0;
-    for (const block of message.blocks)
-        chars += block.text.length;
-    return Math.ceil(chars / CHARS_PER_TOKEN);
+    let tokens = 0;
+    for (const block of message.blocks) {
+        if (block.type === 'image') {
+            const widthTiles = Math.ceil(block.attachment.width / IMAGE_TILE_EDGE);
+            const heightTiles = Math.ceil(block.attachment.height / IMAGE_TILE_EDGE);
+            tokens += Math.max(1, widthTiles * heightTiles);
+        }
+        else {
+            tokens += Math.ceil(block.text.length / CHARS_PER_TOKEN);
+        }
+    }
+    return tokens;
 }

package/lib/index.d.ts

@@ -11,7 +11,7 @@ import { Context } from '@deepseek-ai/cordis';
 import z from '@deepseek-ai/schemastery';
 import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import { ChatStorageError } from './store.ts';
-import type { ChatCreateResult, ChatEmptyResult, ChatHistoryResult, ChatListResult, ChatSelectModelResult, ChatSendResult, ChatUpdateResult, ChatTextBlock } from './types.ts';
+import type { ChatAttachmentResult, ChatCapabilitiesResult, ChatContentPart, ChatCreateResult, ChatDeleteMessageResult, ChatEmptyResult, ChatHistoryResult, ChatListResult, ChatRegenerateResult, ChatSelectModelResult, ChatSendResult, ChatUpdatePatch, ChatUpdateResult } from './types.ts';
 /** Stable Cordis plugin name. */
 export declare const name = "chat-service";
 declare module '@deepseek-ai/cordis' {
@@ -28,8 +28,8 @@ declare module '@deepseek-ai/cordis' {
 }
 /** Business failure carrying a stable code for diagnostics. */
 export declare class ChatServiceError extends Error {
-    readonly code: 'no-model' | 'invalid-request' | 'unsupported-block';
-    constructor(code: 'no-model' | 'invalid-request' | 'unsupported-block', message: string);
+    readonly code: 'no-model' | 'invalid-request' | 'unsupported-block' | 'image-unsupported';
+    constructor(code: 'no-model' | 'invalid-request' | 'unsupported-block' | 'image-unsupported', message: string);
 }
 /** Resolve the harness home the chat store lives under (env overrides default). */
 export declare function chatHomePath(): string;
@@ -70,19 +70,56 @@ export declare class ChatService extends TypertRemoteService {
     /**
      * Send one user turn into a conversation: the user message persists and is
      * anchored through `chat/message`, then its turn joins the FIFO queue.
+     * Image parts are admitted against the deployment attachment limits and
+     * promoted to durable references on the persisted message (design §3).
      */
-    send(conversationId: string, content: readonly ChatTextBlock[]): Promise<ChatSendResult>;
+    send(conversationId: string, content: readonly ChatContentPart[]): Promise<ChatSendResult>;
+    /**
+     * Toggle a conversation's archive flag (M4). Archived conversations keep
+     * their messages and settings; the client hides them from the active view.
+     */
+    archive(conversationId: string, archived: boolean): Promise<ChatEmptyResult>;
+    /**
+     * Delete a single message (design §2.3): the host rewrites the message
+     * file, so subsequent context assembly excludes it. Queued sends bound to
+     * the deleted seq are dropped too; an in-flight turn keeps its assembled
+     * context and settles normally. Idempotent: absent seq reports removed:
+     * false without error.
+     */
+    deleteMessage(conversationId: string, seq: number): Promise<ChatDeleteMessageResult>;
+    /**
+     * Regenerate the last assistant message (design §3): remove it, then rerun
+     * the last user turn with the same context boundary. Rejected while a turn
+     * is running or when there is no assistant message to regenerate.
+     */
+    regenerate(conversationId: string): Promise<ChatRegenerateResult>;
+    /**
+     * Model capability probe for the conversation's current selection
+     * (adapter metadata; design §4.6): the client preflights image sending
+     * instead of discovering a refusal after the bytes were picked.
+     */
+    capabilities(conversationId: string): Promise<ChatCapabilitiesResult>;
+    /**
+     * Read one image's bytes after proving the conversation's message log
+     * references its attachment id (mirror of `session.attachment`'s
+     * authorization discipline; design §3 读图).
+     */
+    attachment(conversationId: string, attachmentId: string): Promise<ChatAttachmentResult>;
     /** Abort the in-flight turn (frozen partial is persisted); idempotent. */
     cancel(conversationId: string): Promise<ChatEmptyResult>;
     /** Switch the conversation's model selection. */
     selectModel(conversationId: string, provider: string, model: string): Promise<ChatSelectModelResult>;
     /** Update conversation settings; `null` in the patch unsets a field. */
-    update(conversationId: string, patch: {
-        readonly systemPrompt?: string | null;
-        readonly temperature?: number | null;
-        readonly contextMessages?: number | null;
-    }): Promise<ChatUpdateResult>;
+    update(conversationId: string, patch: ChatUpdatePatch): Promise<ChatUpdateResult>;
     private defaultSelection;
+    /** Adapter metadata for the conversation's model (structural llm seam). */
+    private resolveModelInfo;
+    /**
+     * Whether the model accepts image input. Unknown capability is a refusal
+     * (fail-closed, mirror of the session image admission preflight outcome:
+     * an unresolvable adapter must not silently accept an image request).
+     */
+    private imageInputAllowed;
     private runnerFor;
     private turnRecord;
     /** Persist turn-start bookkeeping: shift the queued send and mark running. */