@simulatte/doppler 0.1.8 → 0.2.0

package/src/inference/pipelines/text/chat-format.js

@@ -1,390 +0,0 @@
-// Chat template formatters keyed by template type.
-// Template types are stored in manifest.inference.chatTemplate.type.
-
-const TRANSLATEGEMMA_LANGUAGE_ENTRIES = Object.freeze([
-  ['ar-EG', 'Arabic'],
-  ['ar-SA', 'Arabic'],
-  ['bg-BG', 'Bulgarian'],
-  ['bn-IN', 'Bengali'],
-  ['ca-ES', 'Catalan'],
-  ['cs-CZ', 'Czech'],
-  ['da-DK', 'Danish'],
-  ['de-DE', 'German'],
-  ['el-GR', 'Greek'],
-  ['en', 'English'],
-  ['es-XX', 'Spanish'],
-  ['et-EE', 'Estonian'],
-  ['fa-IR', 'Persian'],
-  ['fi-FI', 'Finnish'],
-  ['fil-PH', 'Filipino'],
-  ['fr-CA', 'French'],
-  ['fr-FR', 'French'],
-  ['gu-IN', 'Gujarati'],
-  ['he-IL', 'Hebrew'],
-  ['hi-IN', 'Hindi'],
-  ['hr-HR', 'Croatian'],
-  ['hu-HU', 'Hungarian'],
-  ['id-ID', 'Indonesian'],
-  ['is-IS', 'Icelandic'],
-  ['it-IT', 'Italian'],
-  ['ja-JP', 'Japanese'],
-  ['kn-IN', 'Kannada'],
-  ['ko-KR', 'Korean'],
-  ['lt-LT', 'Lithuanian'],
-  ['lv-LV', 'Latvian'],
-  ['ml-IN', 'Malayalam'],
-  ['mr-IN', 'Marathi'],
-  ['nl-NL', 'Dutch'],
-  ['no-NO', 'Norwegian'],
-  ['pa-IN', 'Punjabi'],
-  ['pl-PL', 'Polish'],
-  ['pt-BR', 'Portuguese'],
-  ['pt-PT', 'Portuguese'],
-  ['ro-RO', 'Romanian'],
-  ['ru-RU', 'Russian'],
-  ['sk-SK', 'Slovak'],
-  ['sl-SI', 'Slovenian'],
-  ['sr-RS', 'Serbian'],
-  ['sv-SE', 'Swedish'],
-  ['sw-KE', 'Swahili'],
-  ['sw-TZ', 'Swahili'],
-  ['ta-IN', 'Tamil'],
-  ['te-IN', 'Telugu'],
-  ['th-TH', 'Thai'],
-  ['tr-TR', 'Turkish'],
-  ['uk-UA', 'Ukrainian'],
-  ['ur-PK', 'Urdu'],
-  ['vi-VN', 'Vietnamese'],
-  ['zh-TW', 'Chinese'],
-  ['zu-ZA', 'Zulu'],
-]);
-
-const TRANSLATEGEMMA_LANGUAGE_NAMES = new Map();
-const CHAT_ROLES = Object.freeze(['system', 'user', 'assistant']);
-const CHAT_ROLE_SET = new Set(CHAT_ROLES);
-
-function assertSupportedChatRole(role, templateName, messageIndex) {
-  if (!CHAT_ROLE_SET.has(role)) {
-    const suffix = Number.isInteger(messageIndex) ? ` at message index ${messageIndex}` : '';
-    throw new Error(
-      `${templateName} formatter expects message role "${CHAT_ROLES.join('", "')}".${suffix}`
-    );
-  }
-}
-
-for (const [code, name] of TRANSLATEGEMMA_LANGUAGE_ENTRIES) {
-  TRANSLATEGEMMA_LANGUAGE_NAMES.set(code, name);
-  const rootCode = code.split('-')[0];
-  if (!TRANSLATEGEMMA_LANGUAGE_NAMES.has(rootCode)) {
-    TRANSLATEGEMMA_LANGUAGE_NAMES.set(rootCode, name);
-  }
-}
-
-function normalizeChatRole(role) {
-  if (typeof role !== 'string') return null;
-  const normalized = role.trim().toLowerCase();
-  if (normalized === 'system' || normalized === 'user' || normalized === 'assistant') {
-    return normalized;
-  }
-  return null;
-}
-
-function normalizeTranslateLanguageCode(value) {
-  if (typeof value !== 'string') return null;
-  const normalized = value.trim().replace(/_/g, '-');
-  return normalized || null;
-}
-
-function resolveTranslateLanguageName(value) {
-  const normalized = normalizeTranslateLanguageCode(value);
-  if (!normalized) return null;
-  return TRANSLATEGEMMA_LANGUAGE_NAMES.get(normalized) ?? null;
-}
-
-function normalizeChatMessageContent(content) {
-  if (typeof content === 'string') {
-    return content;
-  }
-  if (Array.isArray(content) && content.length > 0) {
-    const block = content[0];
-    if (block && typeof block === 'object' && !Array.isArray(block)) {
-      if (block.type === 'text') {
-        return String(block.text ?? '');
-      }
-      if (block.type === 'image') {
-        return '<start_of_image>';
-      }
-    }
-    return content.map((entry) => String(entry ?? '')).join('\n');
-  }
-  if (content && typeof content === 'object' && !Array.isArray(content)) {
-    if (content.type === 'text') return String(content.text ?? '');
-    if (content.type === 'image') return '<start_of_image>';
-  }
-  return String(content ?? '');
-}
-
-function formatTurnBased(messages) {
-  // Turn-based format: <start_of_turn>role\ncontent<end_of_turn>
-  const parts = [];
-  let systemContent = '';
-
-  for (const [index, message] of messages.entries()) {
-    const role = normalizeChatRole(message?.role);
-    assertSupportedChatRole(role, 'Turn-based', index);
-    if (role === 'system') {
-      const content = normalizeChatMessageContent(message?.content);
-      systemContent += (systemContent ? '\n\n' : '') + content;
-    }
-  }
-
-  for (const [index, message] of messages.entries()) {
-    const role = normalizeChatRole(message?.role);
-    assertSupportedChatRole(role, 'Turn-based', index);
-    if (role === 'system') continue;
-
-    if (role === 'user') {
-      const content = normalizeChatMessageContent(message?.content);
-      const fullContent = systemContent ? `${systemContent}\n\n${content}` : content;
-      systemContent = '';
-      parts.push(`<start_of_turn>user\n${fullContent}<end_of_turn>\n`);
-      continue;
-    }
-    if (role === 'assistant') {
-      const content = normalizeChatMessageContent(message?.content);
-      parts.push(`<start_of_turn>model\n${content}<end_of_turn>\n`);
-    }
-  }
-
-  parts.push('<start_of_turn>model\n');
-
-  return parts.join('');
-}
-
-function formatHeaderBased(messages) {
-  // Header-based format: <|start_header_id|>role<|end_header_id|>\n\ncontent<|eot_id|>
-  const parts = ['<|begin_of_text|>'];
-
-  for (const [index, message] of messages.entries()) {
-    const role = normalizeChatRole(message?.role);
-    assertSupportedChatRole(role, 'Header-based', index);
-    const content = normalizeChatMessageContent(message?.content);
-    if (role === 'system') {
-      parts.push(`<|start_header_id|>system<|end_header_id|>\n\n${content}<|eot_id|>`);
-    } else if (role === 'user') {
-      parts.push(`<|start_header_id|>user<|end_header_id|>\n\n${content}<|eot_id|>`);
-    } else if (role === 'assistant') {
-      parts.push(`<|start_header_id|>assistant<|end_header_id|>\n\n${content}<|eot_id|>`);
-    }
-  }
-
-  parts.push('<|start_header_id|>assistant<|end_header_id|>\n\n');
-
-  return parts.join('');
-}
-
-function formatChannelBased(messages) {
-  // Channel-based format: <|start|>role<|channel|>channel<|message|>content<|end|>
-  const parts = [];
-
-  for (const [index, message] of messages.entries()) {
-    const role = normalizeChatRole(message?.role);
-    assertSupportedChatRole(role, 'Channel-based', index);
-    const content = normalizeChatMessageContent(message?.content);
-    if (role === 'system') {
-      parts.push(`<|start|>system<|message|>${content}<|end|>`);
-    } else if (role === 'user') {
-      parts.push(`<|start|>user<|message|>${content}<|end|>`);
-    } else if (role === 'assistant') {
-      parts.push(`<|start|>assistant<|channel|>final<|message|>${content}<|end|>`);
-    }
-  }
-
-  parts.push('<|start|>assistant<|channel|>final<|message|>');
-
-  return parts.join('');
-}
-
-function formatChatML(messages) {
-  // ChatML format: <|im_start|>role\ncontent<|im_end|>
-  const parts = [];
-  for (const [index, message] of messages.entries()) {
-    const role = normalizeChatRole(message?.role);
-    assertSupportedChatRole(role, 'ChatML', index);
-    const content = normalizeChatMessageContent(message?.content);
-    if (role === 'system') {
-      parts.push(`<|im_start|>system\n${content}<|im_end|>\n`);
-    } else if (role === 'user') {
-      parts.push(`<|im_start|>user\n${content}<|im_end|>\n`);
-    } else if (role === 'assistant') {
-      parts.push(`<|im_start|>assistant\n${content}<|im_end|>\n`);
-    }
-  }
-  parts.push('<|im_start|>assistant\n');
-  return parts.join('');
-}
-
-function formatQwen(messages) {
-  // Qwen 3.5 chat format is ChatML-like, but the generation prelude includes
-  // an explicit empty thinking block before assistant output.
-  const parts = [];
-  for (const [index, message] of messages.entries()) {
-    const role = normalizeChatRole(message?.role);
-    assertSupportedChatRole(role, 'Qwen', index);
-    if (role === 'system' && index !== 0) {
-      throw new Error('Qwen template requires any system message to appear first.');
-    }
-    const content = normalizeChatMessageContent(message?.content);
-    if (role === 'system') {
-      parts.push(`<|im_start|>system\n${content}<|im_end|>\n`);
-    } else if (role === 'user') {
-      parts.push(`<|im_start|>user\n${content}<|im_end|>\n`);
-    } else if (role === 'assistant') {
-      parts.push(`<|im_start|>assistant\n${content}<|im_end|>\n`);
-    }
-  }
-  parts.push('<|im_start|>assistant\n<think>\n\n</think>\n\n');
-  return parts.join('');
-}
-
-function formatTranslateGemmaUserPrompt(content) {
-  if (!Array.isArray(content) || content.length !== 1) {
-    throw new Error(
-      'TranslateGemma template requires user content as an array with exactly one item.'
-    );
-  }
-  const block = content[0];
-  if (!block || typeof block !== 'object' || Array.isArray(block)) {
-    throw new Error(
-      'TranslateGemma template requires content[0] to be an object with type/source_lang_code/target_lang_code.'
-    );
-  }
-
-  const sourceLangCode = normalizeTranslateLanguageCode(block.source_lang_code);
-  const targetLangCode = normalizeTranslateLanguageCode(block.target_lang_code);
-  if (!sourceLangCode) {
-    throw new Error('TranslateGemma template requires source_lang_code.');
-  }
-  if (!targetLangCode) {
-    throw new Error('TranslateGemma template requires target_lang_code.');
-  }
-
-  const sourceLang = resolveTranslateLanguageName(sourceLangCode);
-  const targetLang = resolveTranslateLanguageName(targetLangCode);
-  if (!sourceLang) {
-    throw new Error(`TranslateGemma template: unsupported source_lang_code "${sourceLangCode}".`);
-  }
-  if (!targetLang) {
-    throw new Error(`TranslateGemma template: unsupported target_lang_code "${targetLangCode}".`);
-  }
-
-  const instructionPrefix = (
-    `You are a professional ${sourceLang} (${sourceLangCode}) to ${targetLang} (${targetLangCode}) translator. ` +
-    `Your goal is to accurately convey the meaning and nuances of the original ${sourceLang} text while ` +
-    `adhering to ${targetLang} grammar, vocabulary, and cultural sensitivities.\n`
-  );
-
-  if (block.type === 'text') {
-    return (
-      instructionPrefix +
-      `Produce only the ${targetLang} translation, without any additional explanations or ` +
-      `commentary. Please translate the following ${sourceLang} text into ${targetLang}:\n\n\n` +
-      String(block.text ?? '').trim()
-    );
-  }
-
-  if (block.type === 'image') {
-    return (
-      instructionPrefix +
-      `Please translate the ${sourceLang} text in the provided image into ${targetLang}. ` +
-      `Produce only the ${targetLang} translation, without any additional explanations, ` +
-      `alternatives or commentary. Focus only on the text, do not output where the text is located, ` +
-      `surrounding objects or any other explanation about the picture. Ignore symbols, pictogram, and ` +
-      `arrows!\n\n\n<start_of_image>`
-    );
-  }
-
-  throw new Error('TranslateGemma template only supports user content type "text" or "image".');
-}
-
-function formatTranslateGemma(messages) {
-  if (!Array.isArray(messages) || messages.length === 0) {
-    throw new Error('TranslateGemma template requires at least one message.');
-  }
-  const firstRole = normalizeChatRole(messages[0]?.role);
-  assertSupportedChatRole(firstRole, 'TranslateGemma', 0);
-  if (firstRole !== 'user') {
-    throw new Error('TranslateGemma template requires the conversation to start with a user message.');
-  }
-
-  const parts = [];
-  for (let index = 0; index < messages.length; index++) {
-    const message = messages[index];
-    const role = normalizeChatRole(message?.role);
-    assertSupportedChatRole(role, 'TranslateGemma', index);
-    if ((role === 'user') !== (index % 2 === 0)) {
-      throw new Error('TranslateGemma template requires alternating user/assistant roles.');
-    }
-
-    if (role === 'assistant') {
-      if (message?.content == null || typeof message.content !== 'string') {
-        throw new Error('TranslateGemma template requires assistant messages to use string content.');
-      }
-      parts.push(`<start_of_turn>model\n${message.content.trim()}<end_of_turn>\n`);
-      continue;
-    }
-
-    if (role === 'user') {
-      const userPrompt = formatTranslateGemmaUserPrompt(message?.content);
-      parts.push(`<start_of_turn>user\n${userPrompt}<end_of_turn>\n`);
-      continue;
-    }
-
-    throw new Error('TranslateGemma template only supports user and assistant roles.');
-  }
-
-  parts.push('<start_of_turn>model\n');
-  return parts.join('');
-}
-
-function formatPlaintext(messages) {
-  // Simple plaintext format for unknown templates
-  return messages
-    .map((message) => {
-      const role = normalizeChatRole(message?.role);
-      const content = normalizeChatMessageContent(message?.content);
-      if (role === 'system') return `System: ${content}`;
-      if (role === 'user') return `User: ${content}`;
-      if (role === 'assistant') return `Assistant: ${content}`;
-      return content;
-    })
-    .join('\n') + '\nAssistant:';
-}
-
-// Template type to formatter mapping.
-// Add new template types here rather than adding switch cases.
-const CHAT_FORMATTERS = {
-  'gemma': formatTurnBased,
-  'llama3': formatHeaderBased,
-  'gpt-oss': formatChannelBased,
-  'chatml': formatChatML,
-  'qwen': formatQwen,
-  'translategemma': formatTranslateGemma,
-};
-
-export function formatChatMessages(messages, templateType) {
-  if (!Array.isArray(messages)) {
-    throw new Error('formatChatMessages expects an array of messages.');
-  }
-  const formatter = CHAT_FORMATTERS[templateType];
-  if (formatter) {
-    return formatter(messages);
-  }
-  return formatPlaintext(messages);
-}
-
-export const formatGemmaChat = formatTurnBased;
-export const formatLlama3Chat = formatHeaderBased;
-export const formatGptOssChat = formatChannelBased;
-export const formatQwenChat = formatQwen;
-export const formatTranslateGemmaChat = formatTranslateGemma;

package/src/inference/pipelines/text/config.d.ts

@@ -1,244 +0,0 @@
-/**
- * Model configuration parsing and normalization.
- * Handles HuggingFace, GGUF, and llama.cpp config formats.
- *
- * Architecture: Manifest-First Config Resolution
- * - manifest.inference is the source of truth (populated by converter)
- * - mergeConfig() merges manifest with runtime overrides
- * - toParsedConfigFromMerged() adapts MergedConfig to ParsedModelConfig
- *
- * See: config/merge.ts, config/schema/manifest.schema.ts
- */
-
-import type {
-  LayerPipelineSchema,
-  KernelPathRef,
-  ManifestInferenceSchema,
-  ArchitectureSchema,
-  LinearNormMode,
-} from '../../../config/schema/index.js';
-import type { MergedConfig, RuntimeInferenceOverrides } from '../../../config/merge.js';
-
-export type ActivationType = 'silu' | 'gelu';
-export type ParsedLayerType =
-  | 'full_attention'
-  | 'sliding_attention'
-  | 'linear_attention'
-  | 'conv'
-  | 'moe'
-  | 'mamba'
-  | 'rwkv';
-
-export interface RawConfig {
-  model_type?: string;
-  text_config?: RawConfig;
-  architectures?: string[];
-  hidden_size?: number;
-  n_embd?: number;
-  embeddingLength?: number;
-  num_hidden_layers?: number;
-  n_layer?: number;
-  blockCount?: number;
-  num_attention_heads?: number;
-  n_head?: number;
-  attentionHeadCount?: number;
-  num_key_value_heads?: number;
-  attentionHeadCountKV?: number;
-  head_dim?: number;
-  intermediate_size?: number;
-  n_inner?: number;
-  feedForwardLength?: number;
-  vocab_size?: number;
-  max_position_embeddings?: number;
-  contextLength?: number;
-  rope_theta?: number;
-  rope_local_base_freq?: number;
-  ropeFreqBase?: number;
-  rms_norm_eps?: number;
-  attentionLayerNormRMSEpsilon?: number;
-  hidden_activation?: string;
-  hidden_act?: string;
-  eos_token_id?: number | number[];
-  rope_scaling?: RopeScalingConfig;
-  sliding_window?: number;
-  sliding_window_pattern?: number;
-  num_local_experts?: number;
-  num_experts?: number;
-  experts_per_token?: number;
-  num_experts_per_tok?: number;
-  top_k?: number;
-  layer_types?: string[];
-  linear_num_key_heads?: number;
-  linear_num_value_heads?: number;
-  linear_key_head_dim?: number;
-  linear_value_head_dim?: number;
-  linear_conv_kernel_dim?: number;
-  linear_norm_mode?: LinearNormMode;
-  linear_norm_shared?: boolean;
-  attention_bias?: boolean;
-  quantization_config?: { quant_method?: string };
-  scale_embeddings?: boolean;
-  rms_norm_weight_offset?: boolean;
-  final_logit_softcapping?: number;
-  attn_logit_softcapping?: number;
-  query_pre_attn_scalar?: number;
-  attn_output_gate?: boolean;
-}
-
-export interface RopeScalingConfig {
-  type?: string;
-  rope_type?: string;
-  factor?: number;
-  beta_fast?: number;
-  beta_slow?: number;
-  original_max_position_embeddings?: number;
-}
-
-export interface TensorInfo {
-  shape?: number[];
-  dtype?: string;
-}
-
-export interface Manifest {
-  architecture?: ArchitectureSchema;
-  config?: RawConfig | Record<string, unknown>;
-  tensors?: Record<string, TensorInfo>;
-  tokenizer?: Record<string, unknown> & { vocab_size?: number };
-  quantization?: string;
-  eos_token_id?: number | number[];
-  modelId?: string;
-  draftModel?: { numTokens?: number };
-  optimizations?: {
-    useBatching?: boolean;
-    debug?: boolean;
-    kernelPath?: KernelPathRef;
-  };
-  runtime?: {
-    useBatching?: boolean;
-    debug?: boolean;
-  };
-  quantizationInfo?: {
-    weights?: string;
-    embeddings?: string;
-    lmHead?: string;
-    compute?: string;
-  };
-  inference?: ManifestInferenceSchema;
-}
-
-export interface AttentionParams {
-  numHeads: number;
-  numKVHeads: number;
-  headDim: number;
-}
-
-export interface ParsedModelConfig {
-  numLayers: number;
-  hiddenSize: number;
-  intermediateSize: number;
-  numHeads: number;
-  numKVHeads: number;
-  headDim: number;
-  vocabSize: number;
-  maxSeqLen: number;
-  useMoE: boolean;
-  numExperts: number;
-  moeTopK: number;
-  expertFormat: 'mixtral' | 'gpt-oss' | null;
-  slidingWindow: number | null;
-  ropeTheta: number;
-  ropeLocalTheta: number | null;
-  ropeRotaryDim: number;
-  ropeInterleaved: boolean;
-  mropeSection: number[] | null;
-  partialRotaryFactor: number | null;
-  ropeScale: number;
-  ropeLocalScale: number;
-  ropeScalingType: string | null;
-  ropeLocalScalingType: string | null;
-  ropeScaling: RopeScalingConfig | null;
-  ropeLocalScaling: RopeScalingConfig | null;
-  quantization: string;
-  quantMethod: string | null;
-  rmsNormEps: number;
-  rmsNormWeightOffset: boolean;
-  postAttentionNorm: boolean;
-  preFeedforwardNorm: boolean;
-  postFeedforwardNorm: boolean;
-  scaleEmbeddings: boolean;
-  useTiedEmbeddings: boolean;
-  embeddingTranspose: boolean;
-  embeddingVocabSize: number | null;
-  hiddenActivation: ActivationType;
-  swigluLimit: number | null;
-  stopTokenIds: number[];
-  layerTypes: ParsedLayerType[] | null;
-  linearNumKeyHeads: number | null;
-  linearNumValueHeads: number | null;
-  linearKeyHeadDim: number | null;
-  linearValueHeadDim: number | null;
-  linearConvKernelDim: number | null;
-  linearNormMode: LinearNormMode | null;
-  attentionBias: boolean;
-  causalAttention: boolean;
-  embeddingScale?: number;
-  finalLogitSoftcapping: number | null;
-  attnLogitSoftcapping: number | null;
-  queryKeyNorm: boolean;
-  attentionOutputGate: boolean;
-  queryPreAttnScalar: number;
-  layerPipeline?: LayerPipelineSchema | null;
-  chatTemplateType?: string | null;
-  chatTemplateEnabled: boolean;
-  kernelPath?: KernelPathRef;
-}
-
-export function getStopTokenIds(manifest: Manifest): number[];
-
-/**
- * Extended manifest with inference config for manifest-first parsing.
- */
-export interface ManifestWithInference {
-  inference: ManifestInferenceSchema;
-  architecture: ArchitectureSchema;
-  config?: RawConfig | Record<string, unknown>;
-  tensors?: Record<string, TensorInfo>;
-  tokenizer?: Record<string, unknown> & { vocab_size?: number };
-  quantization?: string;
-  modelId?: string;
-  eos_token_id: number | number[];
-}
-
-/**
- * Check if manifest has inference config for manifest-first parsing.
- */
-export function hasManifestInference(manifest: Manifest): manifest is Manifest & { inference: ManifestInferenceSchema };
-
-export function validateRequiredInferenceFields(
-  inf: ManifestInferenceSchema,
-  modelId: string
-): void;
-
-/**
- * Convert MergedConfig to ParsedModelConfig.
- */
-export function toParsedConfigFromMerged(
-  merged: MergedConfig,
-  manifest: ManifestWithInference
-): ParsedModelConfig;
-
-/**
- * Parse model config from manifest using manifest-first resolution.
- */
-export function parseModelConfigFromManifest(
-  manifest: ManifestWithInference,
-  runtimeOverrides?: RuntimeInferenceOverrides
-): ParsedModelConfig;
-
-/**
- * Parse model configuration from manifest.
- */
-export function parseModelConfig(
-  manifest: Manifest,
-  runtimeOverrides?: RuntimeInferenceOverrides
-): ParsedModelConfig;