@simulatte/doppler 0.1.9 → 0.2.0

package/src/client/doppler-api.js

@@ -1,323 +0,0 @@
-import { loadLoRAFromManifest, loadLoRAFromUrl } from '../adapters/lora-loader.js';
-import { log } from '../debug/index.js';
-import { getManifestUrl, parseManifest } from '../formats/rdrr/index.js';
-import { createPipeline } from '../generation/index.js';
-import { getKernelCapabilities } from '../gpu/device.js';
-import { formatChatMessages } from '../inference/pipelines/text/chat-format.js';
-import { buildQuickstartModelBaseUrl, listQuickstartModels, resolveQuickstartModel } from './doppler-registry.js';
-
-const convenienceModelCache = new Map();
-const inFlightLoadCache = new Map();
-
-function isNodeRuntime() {
-  return typeof process !== 'undefined'
-    && typeof process.versions === 'object'
-    && typeof process.versions.node === 'string';
-}
-
-async function ensureWebGPUAvailable() {
-  if (typeof globalThis.navigator !== 'undefined' && globalThis.navigator?.gpu) {
-    return;
-  }
-  if (isNodeRuntime()) {
-    const { bootstrapNodeWebGPU } = await import('../tooling/node-webgpu.js');
-    const result = await bootstrapNodeWebGPU();
-    if (result.ok && globalThis.navigator?.gpu) {
-      return;
-    }
-  }
-  throw new Error('WebGPU is unavailable. Install a Node WebGPU provider or run in a WebGPU-capable browser.');
-}
-
-function emitLoadProgress(callback, phase, percent, message) {
-  if (typeof callback !== 'function') return;
-  callback({ phase, percent, message });
-}
-
-export function createDefaultNodeLoadProgressLogger() {
-  return (event) => {
-    const message = typeof event?.message === 'string' ? event.message.trim() : '';
-    if (!message) return;
-    log.info('doppler', message);
-  };
-}
-
-export function resolveLoadProgressHandlers(options = {}) {
-  const onProgress = typeof options?.onProgress === 'function' ? options.onProgress : null;
-  if (onProgress) {
-    return {
-      userProgress: onProgress,
-      pipelineProgress: onProgress,
-    };
-  }
-  if (isNodeRuntime()) {
-    return {
-      userProgress: createDefaultNodeLoadProgressLogger(),
-      pipelineProgress: null,
-    };
-  }
-  return {
-    userProgress: null,
-    pipelineProgress: null,
-  };
-}
-
-async function fetchManifestFromBaseUrl(baseUrl) {
-  const response = await fetch(getManifestUrl(baseUrl));
-  if (!response.ok) {
-    throw new Error(`Failed to fetch manifest from ${baseUrl}: ${response.status}`);
-  }
-  return parseManifest(await response.text());
-}
-
-async function resolveModelSource(model) {
-  if (typeof model === 'string') {
-    const entry = await resolveQuickstartModel(model);
-    return {
-      modelId: entry.modelId,
-      baseUrl: buildQuickstartModelBaseUrl(entry),
-      manifest: null,
-    };
-  }
-  if (model && typeof model === 'object' && typeof model.url === 'string' && model.url.trim().length > 0) {
-    return {
-      modelId: model.url.trim(),
-      baseUrl: model.url.trim(),
-      manifest: null,
-    };
-  }
-  if (model && typeof model === 'object' && model.manifest && typeof model.manifest === 'object') {
-    const manifest = model.manifest;
-    const modelId = typeof manifest.modelId === 'string' && manifest.modelId.length > 0
-      ? manifest.modelId
-      : 'manifest';
-    return {
-      modelId,
-      baseUrl: typeof model.baseUrl === 'string' && model.baseUrl.length > 0 ? model.baseUrl : null,
-      manifest,
-    };
-  }
-  throw new Error('doppler.load expects a quickstart registry id, { url }, or { manifest, baseUrl? }.');
-}
-
-function countTokens(pipeline, text) {
-  if (!text || typeof text !== 'string') return 0;
-  try {
-    return pipeline?.tokenizer?.encode(text)?.length ?? 0;
-  } catch {
-    return 0;
-  }
-}
-
-function resolveChatPromptForUsage(pipeline, messages) {
-  const templateType = pipeline?.manifest?.inference?.chatTemplate?.enabled === false
-    ? null
-    : (pipeline?.manifest?.inference?.chatTemplate?.type ?? null);
-  try {
-    return formatChatMessages(messages, templateType);
-  } catch {
-    return messages.map((message) => String(message?.content ?? '')).join('\n');
-  }
-}
-
-async function collectText(iterable) {
-  let output = '';
-  for await (const token of iterable) {
-    output += token;
-  }
-  return output;
-}
-
-function assertNoLoadAffectingOptions(apiName, options) {
-  if (!options || typeof options !== 'object') {
-    return;
-  }
-  if (
-    options.runtimeConfig !== undefined
-    || options.runtimePreset !== undefined
-    || options.runtimeConfigUrl !== undefined
-  ) {
-    throw new Error(
-      `${apiName} does not accept load-affecting options. Use doppler.load(model, options) instead.`
-    );
-  }
-}
-
-function createModelHandle(pipeline, resolved) {
-  return {
-    generate(prompt, options = {}) {
-      return pipeline.generate(prompt, options);
-    },
-    async generateText(prompt, options = {}) {
-      return collectText(pipeline.generate(prompt, options));
-    },
-    chat(messages, options = {}) {
-      return pipeline.generate(messages, options);
-    },
-    async chatText(messages, options = {}) {
-      const content = await collectText(pipeline.generate(messages, options));
-      const promptText = resolveChatPromptForUsage(pipeline, messages);
-      const promptTokens = countTokens(pipeline, promptText);
-      const completionTokens = countTokens(pipeline, content);
-      return {
-        content,
-        usage: {
-          promptTokens,
-          completionTokens,
-          totalTokens: promptTokens + completionTokens,
-        },
-      };
-    },
-    async loadLoRA(adapter) {
-      const lora = typeof adapter === 'string'
-        ? await loadLoRAFromUrl(adapter)
-        : await loadLoRAFromManifest(adapter);
-      pipeline.setLoRAAdapter(lora);
-    },
-    async unloadLoRA() {
-      pipeline.setLoRAAdapter(null);
-    },
-    async unload() {
-      await pipeline.unload();
-    },
-    get activeLoRA() {
-      return pipeline.getActiveLoRA()?.name ?? null;
-    },
-    get loaded() {
-      return pipeline.isLoaded === true;
-    },
-    get modelId() {
-      return resolved.modelId;
-    },
-    get manifest() {
-      return pipeline.manifest;
-    },
-    get deviceInfo() {
-      return getKernelCapabilities()?.adapterInfo ?? null;
-    },
-    advanced: {
-      prefillKV(prompt, options = {}) {
-        return pipeline.prefillKVOnly(prompt, options);
-      },
-      prefillWithLogits(prompt, options = {}) {
-        return pipeline.prefillWithLogits(prompt, options);
-      },
-      decodeStepLogits(currentIds, options = {}) {
-        return pipeline.decodeStepLogits(currentIds, options);
-      },
-      generateWithPrefixKV(prefix, prompt, options = {}) {
-        return pipeline.generateWithPrefixKV(prefix, prompt, options);
-      },
-    },
-  };
-}
-
-export async function load(model, options = {}) {
-  const { userProgress, pipelineProgress } = resolveLoadProgressHandlers(options);
-
-  emitLoadProgress(userProgress, 'resolve', 5, 'Resolving model');
-  const resolved = await resolveModelSource(model);
-  await ensureWebGPUAvailable();
-
-  emitLoadProgress(userProgress, 'manifest', 15, 'Fetching manifest');
-  const manifest = resolved.manifest ?? await fetchManifestFromBaseUrl(resolved.baseUrl);
-
-  emitLoadProgress(userProgress, 'load', 25, 'Loading weights');
-  const pipeline = await createPipeline(manifest, {
-    baseUrl: resolved.baseUrl ?? undefined,
-    runtimeConfig: options.runtimeConfig,
-    onProgress: pipelineProgress
-      ? (progress) => emitLoadProgress(
-        pipelineProgress,
-        'load',
-        Math.max(25, Math.min(99, Math.round(progress.percent))),
-        progress.message || 'Loading weights'
-      )
-      : undefined,
-  });
-
-  emitLoadProgress(userProgress, 'ready', 100, 'Model ready');
-  return createModelHandle(pipeline, resolved);
-}
-
-async function getCachedModel(model, options = {}) {
-  const resolved = await resolveModelSource(model);
-  const cacheKey = resolved.modelId;
-  const cached = convenienceModelCache.get(cacheKey);
-  if (cached?.loaded) {
-    return cached;
-  }
-  if (cached && !cached.loaded) {
-    convenienceModelCache.delete(cacheKey);
-  }
-  if (!inFlightLoadCache.has(cacheKey)) {
-    inFlightLoadCache.set(cacheKey, load(model, options).then((instance) => {
-      convenienceModelCache.set(cacheKey, instance);
-      inFlightLoadCache.delete(cacheKey);
-      return instance;
-    }).catch((error) => {
-      inFlightLoadCache.delete(cacheKey);
-      throw error;
-    }));
-  }
-  return inFlightLoadCache.get(cacheKey);
-}
-
-async function* dopplerGenerate(prompt, options = {}) {
-  if (!options || typeof options !== 'object' || options.model == null) {
-    throw new Error('doppler() requires options.model.');
-  }
-  assertNoLoadAffectingOptions('doppler()', options);
-  const model = await getCachedModel(options.model, { onProgress: options.onProgress });
-  yield* model.generate(prompt, options);
-}
-
-export function doppler(prompt, options) {
-  return dopplerGenerate(prompt, options);
-}
-
-doppler.load = load;
-doppler.text = async function text(prompt, options) {
-  if (!options || typeof options !== 'object' || options.model == null) {
-    throw new Error('doppler.text() requires options.model.');
-  }
-  assertNoLoadAffectingOptions('doppler.text()', options);
-  return collectText(doppler(prompt, options));
-};
-doppler.chat = function chat(messages, options = {}) {
-  if (!options || typeof options !== 'object' || options.model == null) {
-    throw new Error('doppler.chat() requires options.model.');
-  }
-  assertNoLoadAffectingOptions('doppler.chat()', options);
-  return (async function* () {
-    const model = await getCachedModel(options.model, { onProgress: options.onProgress });
-    yield* model.chat(messages, options);
-  }());
-};
-doppler.chatText = async function chatText(messages, options = {}) {
-  if (!options || typeof options !== 'object' || options.model == null) {
-    throw new Error('doppler.chatText() requires options.model.');
-  }
-  assertNoLoadAffectingOptions('doppler.chatText()', options);
-  const model = await getCachedModel(options.model, { onProgress: options.onProgress });
-  return model.chatText(messages, options);
-};
-doppler.evict = async function evict(model) {
-  const resolved = await resolveModelSource(model);
-  const cached = convenienceModelCache.get(resolved.modelId);
-  if (!cached) {
-    return false;
-  }
-  await cached.unload();
-  convenienceModelCache.delete(resolved.modelId);
-  return true;
-};
-doppler.evictAll = async function evictAll() {
-  const cached = [...convenienceModelCache.values()];
-  convenienceModelCache.clear();
-  await Promise.allSettled(cached.map((entry) => entry.unload()));
-};
-doppler.listModels = async function listModels() {
-  const models = await listQuickstartModels();
-  return models.map((entry) => entry.modelId);
-};

package/src/client/doppler-provider/generation.d.ts

@@ -1,25 +0,0 @@
-import type { KVCacheSnapshot } from '../../inference/pipelines/text.js';
-import type { ChatTemplateType } from '../../inference/pipelines/text/chat-format.js';
-import type { GenerateOptions, ChatMessage, ChatResponse } from './types.js';
-
-export declare function generate(prompt: string, options?: GenerateOptions): AsyncGenerator<string>;
-
-export declare function prefillKV(prompt: string, options?: GenerateOptions): Promise<KVCacheSnapshot>;
-
-export declare function generateWithPrefixKV(
-  prefix: KVCacheSnapshot,
-  prompt: string,
-  options?: GenerateOptions
-): AsyncGenerator<string>;
-
-export declare function formatGemmaChat(messages: ChatMessage[]): string;
-
-export declare function formatLlama3Chat(messages: ChatMessage[]): string;
-
-export declare function formatGptOssChat(messages: ChatMessage[]): string;
-
-export declare function formatChatMessages(messages: ChatMessage[], templateType?: ChatTemplateType): string;
-
-export declare function buildChatPrompt(messages: ChatMessage[], options?: GenerateOptions): string;
-
-export declare function dopplerChat(messages: ChatMessage[], options?: GenerateOptions): Promise<ChatResponse>;

package/src/client/doppler-provider/generation.js

@@ -1,126 +0,0 @@
-import { log } from '../../debug/index.js';
-import {
-  formatChatMessages as formatChatMessagesForTemplate,
-  formatGemmaChat,
-  formatLlama3Chat,
-  formatGptOssChat,
-} from '../../inference/pipelines/text/chat-format.js';
-import { getRuntimeConfig } from '../../config/runtime.js';
-import { DEFAULT_CHAT_TEMPLATE_CONFIG } from '../../config/schema/index.js';
-import { getPipeline } from './model-manager.js';
-
-export { formatGemmaChat, formatLlama3Chat, formatGptOssChat };
-
-function assertSupportedGenerateOptions(options = {}) {
-  if (Array.isArray(options?.stopTokens) && options.stopTokens.length > 0) {
-    throw new Error(
-      'Doppler provider generate options do not support stopTokens on this surface. ' +
-      'Use stopSequences instead.'
-    );
-  }
-}
-
-function resolveChatTemplate(pipeline, options) {
-  const override = options?.useChatTemplate;
-  const runtimeEnabled = pipeline?.runtimeConfig?.inference?.chatTemplate?.enabled;
-  const modelEnabled = pipeline?.modelConfig?.chatTemplateEnabled;
-  const enabled = override ?? runtimeEnabled ?? modelEnabled ?? DEFAULT_CHAT_TEMPLATE_CONFIG.enabled;
-  const type = pipeline?.modelConfig?.chatTemplateType ?? null;
-  return { enabled, type };
-}
-
-export async function* generate(prompt, options = {}) {
-  assertSupportedGenerateOptions(options);
-  const pipeline = getPipeline();
-  if (!pipeline) {
-    throw new Error('No model loaded. Call loadModel() first.');
-  }
-
-  const runtimeConfig = pipeline.runtimeConfig ?? getRuntimeConfig();
-  const samplingDefaults = runtimeConfig.inference.sampling;
-  const maxTokensDefault = runtimeConfig.inference.batching.maxTokens;
-
-  const maxTokens = options.maxTokens ?? maxTokensDefault;
-  const temperature = options.temperature ?? samplingDefaults.temperature;
-  const topP = options.topP ?? samplingDefaults.topP;
-  const topK = options.topK ?? samplingDefaults.topK;
-  const stopSequences = options.stopSequences ?? [];
-  const useChatTemplate = options.useChatTemplate;
-  const onToken = options.onToken ?? null;
-
-  for await (const token of pipeline.generate(prompt, {
-    maxTokens,
-    temperature,
-    topP,
-    topK,
-    stopSequences,
-    useChatTemplate,
-  })) {
-    if (onToken) onToken(token);
-    yield token;
-  }
-}
-
-export async function prefillKV(prompt, options = {}) {
-  assertSupportedGenerateOptions(options);
-  const pipeline = getPipeline();
-  if (!pipeline) {
-    throw new Error('No model loaded. Call loadModel() first.');
-  }
-  const { onToken: _unused, ...pipelineOptions } = options;
-  return pipeline.prefillKVOnly(prompt, pipelineOptions);
-}
-
-export async function* generateWithPrefixKV(prefix, prompt, options = {}) {
-  assertSupportedGenerateOptions(options);
-  const pipeline = getPipeline();
-  if (!pipeline) {
-    throw new Error('No model loaded. Call loadModel() first.');
-  }
-  const { onToken, ...pipelineOptions } = options;
-  for await (const token of pipeline.generateWithPrefixKV(prefix, prompt, pipelineOptions)) {
-    if (onToken) onToken(token);
-    yield token;
-  }
-}
-
-export function formatChatMessages(messages, templateType) {
-  const pipeline = getPipeline();
-  const resolvedType = templateType ?? pipeline?.modelConfig?.chatTemplateType ?? null;
-  return formatChatMessagesForTemplate(messages, resolvedType);
-}
-
-export function buildChatPrompt(messages, options = {}) {
-  const pipeline = getPipeline();
-  const { enabled, type } = resolveChatTemplate(pipeline, options);
-  return formatChatMessagesForTemplate(messages, enabled ? type : null);
-}
-
-export async function dopplerChat(messages, options = {}) {
-  const pipeline = getPipeline();
-  const prompt = buildChatPrompt(messages, options);
-
-  let promptTokens = 0;
-  if (pipeline && pipeline.tokenizer) {
-    try {
-      const encoded = pipeline.tokenizer.encode(prompt);
-      promptTokens = encoded.length;
-    } catch (e) {
-      log.warn('DopplerProvider', 'Failed to count prompt tokens', e);
-    }
-  }
-
-  const tokens = [];
-  for await (const token of generate(prompt, { ...options, useChatTemplate: false })) {
-    tokens.push(token);
-  }
-
-  return {
-    content: tokens.join(''),
-    usage: {
-      promptTokens,
-      completionTokens: tokens.length,
-      totalTokens: promptTokens + tokens.length,
-    },
-  };
-}

package/src/client/doppler-provider/index.d.ts

@@ -1,2 +0,0 @@
-export * from '../doppler-provider.d.ts';
-export { default } from '../doppler-provider.js';

package/src/client/doppler-provider/index.js

@@ -1,3 +0,0 @@
-// Types and interfaces
-export * from '../doppler-provider.js';
-export { default } from '../doppler-provider.js';

package/src/client/doppler-provider/model-manager.d.ts

@@ -1,71 +0,0 @@
-import type { InferencePipeline } from '../../inference/pipelines/text.js';
-import type { RDRRManifest } from '../../formats/rdrr/index.js';
-import type { LoRAManifest } from '../../adapters/lora-loader.js';
-import type {
-  TextModelConfig,
-  LoadProgressEvent,
-} from './types.js';
-
-export declare function getPipeline(): InferencePipeline | null;
-
-export declare function getCurrentModelId(): string | null;
-
-export declare function verifyExplicitModelUrlMatch(
-  localManifest: RDRRManifest | Record<string, unknown> | null | undefined,
-  modelUrl: string | null | undefined,
-  fetchRemoteManifest?: (modelUrl: string) => Promise<RDRRManifest | Record<string, unknown> | null>
-): Promise<void>;
-
-export declare function shouldAutoTuneKernels(
-  runtimeConfig?: Record<string, unknown> | null
-): boolean;
-
-export declare function extractTextModelConfig(manifest: RDRRManifest): TextModelConfig;
-
-export declare function readOPFSFile(path: string): Promise<ArrayBuffer>;
-
-export declare function writeOPFSFile(path: string, data: ArrayBuffer): Promise<void>;
-
-export declare function fetchArrayBuffer(url: string): Promise<ArrayBuffer>;
-
-export declare function initDoppler(): Promise<boolean>;
-
-export declare function loadModel(
-  modelId: string,
-  modelUrl?: string | null,
-  onProgress?: ((event: LoadProgressEvent) => void) | null,
-  localPath?: string | null
-): Promise<boolean>;
-
-export declare function unloadModel(): Promise<void>;
-
-export declare function loadLoRAAdapter(adapter: LoRAManifest | RDRRManifest | string): Promise<void>;
-
-export declare function activateLoRAFromTrainingOutput(
-  trainingOutput:
-    | string
-    | {
-      adapter?: LoRAManifest | RDRRManifest | string;
-      adapterManifest?: LoRAManifest | RDRRManifest;
-      adapterManifestJson?: string;
-      adapterManifestUrl?: string;
-      adapterManifestPath?: string;
-    }
-    | null
-    | undefined
-): Promise<{
-  activated: boolean;
-  adapterName: string | null;
-  source: string | null;
-  reason: string | null;
-}>;
-
-export declare function unloadLoRAAdapter(): Promise<void>;
-
-export declare function getActiveLoRA(): string | null;
-
-export declare function getAvailableModels(): Promise<string[]>;
-
-export declare function getDopplerStorageInfo(): Promise<unknown>;
-
-export declare function destroyDoppler(): Promise<void>;