@degreesign/chat 1.1.0 → 1.3.0

package/dist/chat.d.ts

@@ -1,13 +1,13 @@
 import { ChatModelId } from './enums';
 import type { CancelChat, ChatInput, ChatPreloadInput, ChatState, ChatStatusSnapshot, Runtime } from './types';
-/** Build one model and request status snapshot */
+/** Build one status snapshot */
 declare const statusSnapshot: (service: Runtime, model: ChatModelId | undefined, state: ChatState) => ChatStatusSnapshot;
-/** Build a one-shot chat function over one runtime */
+/** Build chat over one runtime */
 declare const createChatOn: (service: Runtime) => ((input: ChatInput) => CancelChat);
-/** Build a model preload over one runtime */
+/** Build preload over one runtime */
 declare const createPreloadOn: (service: Runtime) => (input?: ChatPreloadInput) => Promise<boolean>;
 declare const createChat: (input: ChatInput) => CancelChat;
 declare const preloadModel: (input?: ChatPreloadInput) => Promise<boolean>;
-/** Delete every model file cached on this device */
+/** Delete every cached model file */
 declare const clearModelCache: () => Promise<void>;
 export { clearModelCache, createChat, createChatOn, createPreloadOn, preloadModel, statusSnapshot, };

package/dist/describe.d.ts

@@ -1,13 +1,22 @@
 import { ChatModelId } from './enums';
 import type { DescribeImagesInput, DescribeTranslatedInput, ImageDescription, Runtime } from './types';
-/** Model that describes every image, the Q3 build keeps the CPU pass light */
-declare const describeModelId = ChatModelId.qwen3_vl_2b_instruct_q3;
-/** Build image descriptions over one runtime */
+declare const 
+/** System message of the describer */
+imageSystem: string, 
+/** System image rules */
+imageRules: string, 
+/** Request for every image */
+imageNote = "Describe all elements of the image.";
+/** Reply budget, about 100 words */
+declare const imageReplyTokens = 128;
+/** Describer model, Q4 CPU build */
+declare const describeModelId = ChatModelId.qwen3_vl_2b_instruct;
+/** Build descriptions over one runtime */
 declare const createDescribeOn: (service: Runtime) => (input: DescribeImagesInput) => Promise<ImageDescription[]>;
-/** Build translations of English image descriptions over one runtime */
+/** Build translations over one runtime */
 declare const createTranslateOn: (service: Runtime) => (input: DescribeTranslatedInput) => Promise<string[]>;
-/** Describe every image in English, then translate each description on a GPU */
+/** Describe images in English, translate */
 declare const describeImages: (input: DescribeImagesInput) => Promise<ImageDescription[]>;
-/** Translate English image descriptions on a GPU */
+/** Translate image descriptions on GPU */
 declare const describeTranslated: (input: DescribeTranslatedInput) => Promise<string[]>;
-export { createDescribeOn, createTranslateOn, describeImages, describeModelId, describeTranslated, };
+export { createDescribeOn, createTranslateOn, describeImages, describeModelId, describeTranslated, imageNote, imageReplyTokens, imageRules, imageSystem, };

package/dist/engines/engine.d.ts

@@ -1,37 +1,37 @@
 import type { ChatMessage, ChatModel, EngineMessage, EngineRunParams, LlmLimits, StreamReplyParams } from '../types';
-/** Default token, prompt and thread budgets of the CPU engine */
+/** Default CPU engine budgets */
 declare const defaultLlmLimits: LlmLimits;
-/** Merge developer budgets over the backend defaults */
+/** Merge budgets over backend defaults */
 declare const resolveLlmLimits: (overrides?: Partial<LlmLimits>, gpu?: boolean) => LlmLimits;
-/** Sampling options shared by every engine stream */
-declare const replyOptions: (limits: LlmLimits, reasoning: boolean) => {
+/** Sampling options for every stream */
+declare const replyOptions: (limits: LlmLimits, reasoning: boolean, temperature?: number) => {
     stream: true;
     temperature: number;
     max_tokens: number;
 };
 declare const 
-/** Resolve one model file on the model host */
+/** Resolve one model file URL */
 modelUrl: (repo: string, file: string) => string, 
-/** Declared size of one download, zero when the host hides it */
+/** Declared download size or zero */
 contentLength: (response: Response) => number, 
-/** Whether any turn carries an image */
+/** Any turn carries an image */
 hasImages: (messages: EngineMessage[]) => boolean, 
 /** Whether any turn carries audio */
 hasAudio: (messages: EngineMessage[]) => boolean;
 declare const 
-/** Map the host messages to OpenAI-style turns, bounded for local context */
+/** Map host messages to turns */
 buildMessages: (messages: ChatMessage[], limits?: LlmLimits) => EngineMessage[], 
-/** Split inline reasoning markers out of the streamed content */
+/** Split reasoning markers from content */
 createThinkSplitter: (onReason: (text: string) => void, onText: (text: string) => void) => {
     feed: (text: string) => void;
     flush: () => void;
 };
 declare const 
-/** Log an engine chat call with all message text censored */
+/** Log chat call, text censored */
 logChatCall: (model: ChatModel, messages: EngineMessage[]) => void, 
-/** Stream one reply, logging it and returning undefined when stopped */
+/** Stream reply, undefined when stopped */
 streamReply: ({ model, logging, onReason, onText, onSpeed, start, stopped, firstTimeoutMs, idleTimeoutMs, onStall, }: StreamReplyParams) => Promise<string | undefined>;
 declare const 
-/** Build the prompt and stream one reply through an engine */
+/** Build prompt, stream through engine */
 runEngineChat: ({ model, params, start, stopped, onStall, }: EngineRunParams) => Promise<string | undefined>;
 export { buildMessages, createThinkSplitter, logChatCall, runEngineChat, streamReply, replyOptions, defaultLlmLimits, resolveLlmLimits, hasImages, hasAudio, modelUrl, contentLength, };

package/dist/engines/images.d.ts

@@ -6,14 +6,14 @@ imageTokens = 128,
 tokenCell = 32, 
 /** Tokens allowed above the target */
 tokenSlack = 8;
-/** Square size the WebGPU engine encodes */
+/** Square size for WebGPU encoding */
 declare const gpuImageSize: ImageSize;
-/** Decode a data URL or fetch a URL into bytes for an engine */
+/** Decode URL into engine bytes */
 declare const contentBuffer: (url: string) => Promise<ArrayBuffer>;
-/** Full-frame size near the token target */
-declare const visionSize: (width: number, height: number) => ImageSize;
-/** Fit one image URL to the token grid for an engine */
-declare const resizeImageUrl: (url: string, size?: ImageSize) => Promise<string>;
-/** Fit every image part before an engine sees it */
-declare const resizeImages: (messages: EngineMessage[], size?: ImageSize) => Promise<EngineMessage[]>;
+/** Full-frame size near token target */
+declare const visionSize: (width: number, height: number, tokens?: number) => ImageSize;
+/** Fit image to token grid */
+declare const resizeImageUrl: (url: string, size?: ImageSize, tokens?: number) => Promise<string>;
+/** Fit image parts before engine */
+declare const resizeImages: (messages: EngineMessage[], size?: ImageSize, tokens?: number) => Promise<EngineMessage[]>;
 export { gpuImageSize, imageTokens, tokenCell, tokenSlack, visionSize, contentBuffer, resizeImageUrl, resizeImages, };

package/dist/engines/litert.d.ts

@@ -1,16 +1,28 @@
-import type { EngineChunk, EngineMessage, LitertMessage, LitertSettings, LitertSettingsParams, LlmEngine, StartLlmParams, StreamLitertParams } from '../types';
+import { loadLitert } from './litertLoader';
+import type { EngineChunk, EngineMessage, GpuDevice, GpuThrottleParams, LitertMessage, LitertSettings, LitertSettingsParams, LlmEngine, StartLlmParams, StreamLitertParams } from '../types';
 declare const 
-/** Smallest Gemma 4 vision budget in tokens */
-visionTokens = 70;
-/** Fetch one model file into the cache, once per URL */
+/** Smallest Gemma 4 vision budget */
+visionTokens = 70, 
+/** GPU busy share of time */
+gpuShare = 0.7, 
+/** Most rest per readback */
+maxRestMs = 40;
+declare const 
+/** Rest owed for busy interval */
+restFor: (busyMs: number) => number;
+/** WebGPU device resting after readback */
+declare const throttledDevice: ({ device, pace, }: GpuThrottleParams) => GpuDevice;
+/** Drop device and wasm module */
+declare const releaseDevice: (mod: Awaited<ReturnType<typeof loadLitert>>) => void;
+/** Cache one file per URL */
 declare const cacheModel: (url: string, cache: Cache, signal: AbortSignal | undefined, onProgress: StartLlmParams[`onProgress`]) => Promise<void>;
-/** Map built messages to LiteRT turns */
+/** Map messages to LiteRT turns */
 declare const toLitertMessages: (messages: EngineMessage[], keepMedia?: boolean) => Promise<LitertMessage[]>;
-/** Whether the live conversation already holds the incoming history */
+/** Whether conversation holds incoming history */
 declare const continuesHistory: (sent: EngineMessage[], history: EngineMessage[]) => boolean;
-/** Stream one LiteRT reply as engine chunks */
+/** Stream LiteRT reply as chunks */
 declare const streamLitert: ({ engine, mod, params, messages, session, }: StreamLitertParams) => AsyncGenerator<EngineChunk>;
-/** Build one engine settings object with the small vision budget */
-declare const litertSettings: ({ model, limits, source, mod, }: LitertSettingsParams) => LitertSettings;
+/** Engine settings with vision budget */
+declare const litertSettings: ({ model, limits, contextSize, source, mod, }: LitertSettingsParams) => LitertSettings;
 declare const litertEngine: LlmEngine;
-export { cacheModel, continuesHistory, litertEngine, litertSettings, streamLitert, toLitertMessages, visionTokens, };
+export { cacheModel, continuesHistory, gpuShare, litertEngine, litertSettings, maxRestMs, releaseDevice, restFor, streamLitert, throttledDevice, toLitertMessages, visionTokens, };

package/dist/engines/store.d.ts

@@ -1,11 +1,11 @@
 import type { ModelStore, ResumePlan, StoredFilePart, StoredPart } from '../types';
 declare const 
-/** Contiguous parts from offset zero, stopping at the first gap */
+/** Contiguous parts until first gap */
 chainParts: (parts: StoredFilePart[]) => StoredFilePart[], 
-/** Where one response continues the parts, undefined restarts them */
+/** Where response continues parts */
 resumePlan: (response: Response, part: StoredPart) => ResumePlan | undefined, 
-/** Whether a failed store write means this host cannot use a file store */
+/** Whether store failure disables storage */
 isStoreError: (error: unknown) => boolean;
-/** Create the resumable file store of one engine */
+/** Create engine resumable file store */
 declare const createModelStore: (dirName: string) => ModelStore;
 export { chainParts, createModelStore, isStoreError, resumePlan, };

package/dist/engines/threads.d.ts

@@ -1,3 +1,3 @@
-/** Logical cores minus a fifth, one kept free for the page */
+/** Reserve one fifth for page */
 declare const heuristicThreads: (cores: number) => number;
 export { heuristicThreads };

package/dist/engines/wllama.d.ts

@@ -8,19 +8,19 @@ declare const visionLimits: (model: ChatModel) => {
     image_max_tokens?: undefined;
 };
 declare const 
-/** Every CPU file of one model, its name and remote URL */
+/** CPU file names and URLs */
 cpuFiles: (model: ChatModel) => Array<{
     name: string;
     url: string;
 }>, 
-/** Every CPU file as a Blob, from the store or a resumable download */
+/** CPU files as stored blobs */
 storedBlobs: ({ model, signal, onProgress, }: {
     model: ChatModel;
     signal?: AbortSignal;
     onProgress: StartLlmParams[`onProgress`];
 }) => Promise<Blob[] | undefined>, 
-/** Map built messages to wllama turns */
+/** Map messages to wllama turns */
 toWllamaMessages: (messages: EngineMessage[]) => Promise<WllamaMessage[]>, 
-/** Start the CPU runtime, the unified engine entry */
+/** Start CPU runtime engine entry */
 startLLM: ({ model, limits, onProgress, signal, logging, assets: overrides, }: StartLlmParams) => Promise<LlmRuntime>, wllamaEngine: LlmEngine;
 export { cpuFiles, startLLM, storedBlobs, toWllamaMessages, visionLimits, wllamaEngine, };

package/dist/enums.d.ts

@@ -1,10 +1,10 @@
-/** Who a chat message is from */
+/** Author of a chat message */
 declare enum LlmRole {
     system = "system",
     user = "user",
     assistant = "assistant"
 }
-/** Assistant availability derived from the engine */
+/** Assistant availability from engine */
 declare enum ChatStatus {
     online = 0,
     away = 1,
@@ -18,23 +18,22 @@ declare enum LlmStatus {
     error = 3,
     unsupported = 4
 }
-/** Which engine runs the model on this device */
+/** Engine running the model */
 declare enum LlmBackend {
     cpu = "cpu",
     gpu = "gpu",
     none = "none"
 }
-/** Download or load-into-memory phase of a model load */
+/** Download or load phase */
 declare enum LlmPhase {
     download = "download",
     load = "load"
 }
-/** Catalog ids of the on-device models */
+/** Catalog ids of on-device models */
 declare enum ChatModelId {
     qwen3_vl_2b = "qwen3-vl-2b",
     qwen3_vl_2b_instruct = "qwen3-vl-2b-instruct",
     qwen3_vl_2b_instruct_q3 = "qwen3-vl-2b-instruct-q3",
-    gemma4_e2b = "gemma4-e2b",
     gemma4_e2b_limited = "gemma4-e2b-limited"
 }
 /** Built-in tools the package ships */
@@ -43,7 +42,7 @@ declare enum BuiltinTool {
     calculate = "calculate",
     currency = "currency"
 }
-/** Search provider behind the websearch tool */
+/** Provider behind the websearch tool */
 declare enum WebSearchProvider {
     wikipedia = "wikipedia",
     duckduckgo = "duckduckgo"

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { clearModelCache, createChat, preloadModel } from './chat';
-export { describeImages, describeModelId, describeTranslated } from './describe';
+export { describeImages, describeModelId, describeTranslated, imageReplyTokens } from './describe';
+export { gpuAdapter } from './models';
 export { builtinTools, calculateTool, currencyTool, webSearchTool, } from './tools';
 export { LlmRole, ChatStatus, LlmStatus, LlmBackend, LlmPhase, ChatModelId, BuiltinTool, WebSearchProvider, } from './enums';
 export type { ChatMessage, LlmLimits, ChatStatusSnapshot, ChatInput, ChatPreloadInput, CancelChat, DescribeImagesInput, DescribeTranslatedInput, ImageDescription, WllamaAssets, ChatTool, ChatToolCall, ChatToolResult, ChatToolSchema, ChatToolValue, WebSearchConfig, WebSearchResult, } from './types';

package/dist/log.d.ts

@@ -1,3 +1,3 @@
-/** Write one package log line when logging is on */
+/** Write log line when enabled */
 declare const log: (logging: boolean | undefined, ...args: unknown[]) => void;
 export { log };

package/dist/models.d.ts

@@ -1,26 +1,26 @@
 import { ChatModelId } from './enums';
 import type { ChatModel, MobileNavigator } from './types';
 declare const llmModels: ChatModel[], 
-/** Context window requested from the CPU engine, a 32k KV cache needs 3.5 GB */
+/** CPU context window, 8k tokens */
 cpuContextWindow = 8192, // max 262_400
-/** CPU window on a phone, the smaller cache keeps the tab alive */
+/** Phone CPU window, 4096 tokens */
 mobileCpuContextWindow = 4096, // max 32_768
-/** Context window requested from the GPU engine, the wasm heap holds the model */
-litertContextWindow = 4096, // max 32_768
-/** Whether this client is a phone or tablet */
+/** GPU context window, 32k tokens */
+litertContextWindow = 32768, // max 32_768
+/** Phone GPU window, 16k tokens */
+mobileLitertContextWindow = 16384, // max 32_768
+/** Whether this client is mobile */
 mobileDevice: (nav?: MobileNavigator) => boolean, 
-/** Build of a Gemma request that this device loads */
-deviceModelId: (id?: ChatModelId, mobile?: boolean) => ChatModelId | undefined, 
-/** Look up a catalog entry by id */
+/** Find catalog entry by id */
 findLlmModel: (id?: string) => ChatModel | undefined, 
-/** Whether this browser provides a WebGPU adapter */
+/** Whether browser has WebGPU adapter */
 gpuAdapter: () => Promise<boolean>, 
-/** Default model, the GPU one when a WebGPU adapter exists */
+/** Default model, GPU when available */
 defaultLlmModel: () => Promise<ChatModelId | undefined>, 
-/** Resolve the requested model or the default of this device */
+/** Resolve requested model or default */
 resolveLlmModel: (id?: ChatModelId) => Promise<ChatModel | undefined>, 
 /** Whether a model accepts images */
 supportsImages: (model: ChatModel) => boolean, 
 /** Whether a model accepts audio */
 supportsAudio: (model: ChatModel) => boolean;
-export { llmModels, cpuContextWindow, mobileCpuContextWindow, litertContextWindow, mobileDevice, deviceModelId, findLlmModel, gpuAdapter, defaultLlmModel, resolveLlmModel, supportsImages, supportsAudio, };
+export { llmModels, cpuContextWindow, mobileCpuContextWindow, litertContextWindow, mobileLitertContextWindow, mobileDevice, findLlmModel, gpuAdapter, defaultLlmModel, resolveLlmModel, supportsImages, supportsAudio, };