@webmcp-auto-ui/agent 2.5.26 → 2.5.28

package/src/prompts/tool-call-parsers.ts

@@ -0,0 +1,322 @@
+// Unified tool-call parser for in-browser providers.
+// Each family of models emits tool calls in a different syntax:
+//   - Gemma 4 native      → <|tool_call>call:name{args}<tool_call|>
+//   - Qwen 3/3.5 (ChatML) → <tool_call>{"name": ..., "arguments": {...}}</tool_call>
+//   - Mistral/Ministral   → [TOOL_CALLS][{"name": ..., "arguments": {...}}]
+//
+// Each parser returns a list of ContentBlocks — tool_use blocks for detected
+// calls, plus a single text block with the remaining prose (tool-call tags
+// stripped, thinking tags stripped for Qwen).
+
+import type { ContentBlock } from '../types.js';
+
+export type ToolCallFormat = 'gemma-native' | 'qwen-json' | 'mistral-toolcalls';
+
+export interface ParseResult {
+  content: ContentBlock[];
+  foundToolCall: boolean;
+}
+
+export function parseToolCalls(text: string, format: ToolCallFormat): ParseResult {
+  switch (format) {
+    case 'gemma-native': return parseGemmaNative(text);
+    case 'qwen-json': return parseQwenJson(text);
+    case 'mistral-toolcalls': return parseMistralToolCalls(text);
+  }
+}
+
+// ──────────────────────────────────────────────────────────────────────────
+// Gemma 4 native — single source of truth (previously also in wasm.ts).
+// Exported so that WasmProvider can import and reuse instead of duplicating.
+// ──────────────────────────────────────────────────────────────────────────
+
+/**
+ * Extract a brace-balanced `{...}` block starting at `text[startIdx]`.
+ * Ignores `{` and `}` that appear inside `<|"|>...<|"|>` string delimiters
+ * or inside standard JSON `"..."` strings.
+ * Returns the full block including outer braces, or null if unbalanced.
+ */
+export function extractArgsBlock(text: string, startIdx: number): string | null {
+  if (text[startIdx] !== '{') return null;
+  const DELIM = '<|"|>';
+  let depth = 0;
+  let i = startIdx;
+  while (i < text.length) {
+    if (text.startsWith(DELIM, i)) {
+      i += DELIM.length;
+      const end = text.indexOf(DELIM, i);
+      if (end === -1) return null;
+      i = end + DELIM.length;
+      continue;
+    }
+    if (text[i] === '"') {
+      i++;
+      while (i < text.length && text[i] !== '"') {
+        if (text[i] === '\\' && i + 1 < text.length) { i += 2; continue; }
+        i++;
+      }
+      i++;
+      continue;
+    }
+    if (text[i] === '{') depth++;
+    else if (text[i] === '}') {
+      depth--;
+      if (depth === 0) return text.slice(startIdx, i + 1);
+    }
+    i++;
+  }
+  return null;
+}
+
+/**
+ * Skip "noise" chars that Gemma sometimes hallucinates between the end of a
+ * balanced args block and the `<tool_call|>` closing tag. Observed in prod:
+ * excess `}` braces, trailing commas, whitespace. Without this tolerance the
+ * strict scanner rejects the whole tool call silently (no tool_use produced),
+ * which breaks widget rendering.
+ */
+function skipNoise(text: string, pos: number): number {
+  while (pos < text.length) {
+    const c = text[pos];
+    if (c === '}' || c === ' ' || c === '\n' || c === '\r' || c === '\t' || c === ',') {
+      pos++;
+      continue;
+    }
+    break;
+  }
+  return pos;
+}
+
+/**
+ * Scan `fullText` for Gemma native tool calls and return the list of
+ * `{ name, argsBlock }` pairs found. Tolerates hallucinated noise
+ * (excess `}`, whitespace, trailing commas) between the balanced args
+ * block and the `<tool_call|>` closing tag.
+ */
+export function extractGemmaToolCalls(fullText: string): Array<{ name: string; argsBlock: string }> {
+  const START_TAG = '<|tool_call>call:';
+  const END_TAG = '<tool_call|>';
+  const out: Array<{ name: string; argsBlock: string }> = [];
+  let scanIdx = 0;
+  while (true) {
+    const startIdx = fullText.indexOf(START_TAG, scanIdx);
+    if (startIdx === -1) break;
+    const nameStart = startIdx + START_TAG.length;
+    const braceIdx = fullText.indexOf('{', nameStart);
+    if (braceIdx === -1) break;
+    const name = fullText.slice(nameStart, braceIdx);
+    if (!/^\w+$/.test(name)) { scanIdx = nameStart; continue; }
+    const argsBlock = extractArgsBlock(fullText, braceIdx);
+    if (!argsBlock) break;
+    const afterArgsRaw = braceIdx + argsBlock.length;
+    const afterArgs = skipNoise(fullText, afterArgsRaw);
+    if (!fullText.startsWith(END_TAG, afterArgs)) { scanIdx = afterArgsRaw; continue; }
+    out.push({ name, argsBlock });
+    scanIdx = afterArgs + END_TAG.length;
+  }
+  return out;
+}
+
+/**
+ * Parse Gemma native tool call args by normalizing to strict JSON.
+ * Handles both `<|"|>...<|"|>` (Gemma native) and `"..."` (JSON-style, emitted
+ * when the model copies JS-syntax examples from recipe bodies). Raw newlines
+ * inside JSON strings are escaped. Unquoted keys are quoted.
+ */
+export function parseGemmaArgs(raw: string): Record<string, unknown> {
+  const DELIM = '<|"|>';
+  let out = '';
+  let i = 0;
+  while (i < raw.length) {
+    if (raw.startsWith(DELIM, i)) {
+      i += DELIM.length;
+      const end = raw.indexOf(DELIM, i);
+      if (end === -1) return {};
+      // Decode standard backslash escapes inside <|"|>…<|"|> strings so that
+      // a recipe-copied `\n` becomes a real newline, not the two-char
+      // sequence `\n` that would then be re-escaped to `\\n` by
+      // JSON.stringify and reach the sandbox as literal text. Other
+      // backslash-x sequences are preserved verbatim (single backslash kept).
+      const body = raw.slice(i, end);
+      let decoded = '';
+      for (let k = 0; k < body.length; k++) {
+        const ch = body[k];
+        if (ch === '\\' && k + 1 < body.length) {
+          const nxt = body[k + 1];
+          if (nxt === 'n') { decoded += '\n'; k++; continue; }
+          if (nxt === 't') { decoded += '\t'; k++; continue; }
+          if (nxt === 'r') { decoded += '\r'; k++; continue; }
+          if (nxt === '"') { decoded += '"'; k++; continue; }
+          if (nxt === '\\') { decoded += '\\'; k++; continue; }
+          // Unknown escape — keep the backslash verbatim
+          decoded += ch;
+          continue;
+        }
+        decoded += ch;
+      }
+      out += JSON.stringify(decoded);
+      i = end + DELIM.length;
+      continue;
+    }
+    const c = raw[i];
+    if (c === '"') {
+      let content = '';
+      i++;
+      while (i < raw.length && raw[i] !== '"') {
+        const ch = raw[i];
+        if (ch === '\\' && i + 1 < raw.length) { content += ch + raw[i + 1]; i += 2; continue; }
+        if (ch === '\n') content += '\\n';
+        else if (ch === '\r') content += '\\r';
+        else if (ch === '\t') content += '\\t';
+        else content += ch;
+        i++;
+      }
+      if (i >= raw.length) return {};
+      out += '"' + content + '"';
+      i++;
+      continue;
+    }
+    if (c === '{' || c === ',') {
+      out += c;
+      i++;
+      while (i < raw.length && /\s/.test(raw[i])) { out += raw[i++]; }
+      const keyStart = i;
+      while (i < raw.length && /[a-zA-Z0-9_$]/.test(raw[i])) i++;
+      if (i > keyStart) {
+        let j = i;
+        while (j < raw.length && /\s/.test(raw[j])) j++;
+        if (raw[j] === ':') out += '"' + raw.slice(keyStart, i) + '"';
+        else out += raw.slice(keyStart, i);
+      }
+      continue;
+    }
+    out += c;
+    i++;
+  }
+  try {
+    const parsed = JSON.parse(out);
+    return (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function parseGemmaNative(text: string): ParseResult {
+  const calls = extractGemmaToolCalls(text);  // uses the exported helper above
+  const content: ContentBlock[] = [];
+  for (let idx = 0; idx < calls.length; idx++) {
+    const c = calls[idx];
+    content.push({
+      type: 'tool_use',
+      id: `tc-${Date.now()}-${idx}`,
+      name: c.name,
+      input: parseGemmaArgs(c.argsBlock),
+    });
+  }
+  if (calls.length === 0) {
+    const cleanText = text.replace(/<\|tool_call>[\s\S]*?<tool_call\|>/g, '').trim();
+    content.push({ type: 'text', text: cleanText || text });
+    return { content, foundToolCall: false };
+  }
+  // Preserve any prose around the tool calls (strip the call blocks).
+  const prose = text.replace(/<\|tool_call>[\s\S]*?<tool_call\|>/g, '').trim();
+  if (prose) {
+    content.unshift({ type: 'text', text: prose });
+  }
+  return { content, foundToolCall: true };
+}
+
+// ──────────────────────────────────────────────────────────────────────────
+// Qwen 3/3.5 ChatML tool-call format
+// ──────────────────────────────────────────────────────────────────────────
+
+function parseQwenJson(text: string): ParseResult {
+  // Strip <think>...</think> thinking tokens from prose (they shouldn't leak).
+  const noThink = text.replace(/<think>[\s\S]*?<\/think>/g, '');
+
+  const re = /<tool_call>\s*([\s\S]*?)\s*<\/tool_call>/g;
+  const content: ContentBlock[] = [];
+  const matches: Array<{ name: string; input: Record<string, unknown> }> = [];
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(noThink)) !== null) {
+    try {
+      const obj = JSON.parse(m[1]);
+      if (obj && typeof obj === 'object' && typeof obj.name === 'string') {
+        matches.push({
+          name: obj.name,
+          input: (obj.arguments ?? {}) as Record<string, unknown>,
+        });
+      }
+    } catch {
+      // Skip unparseable tool_call blocks.
+    }
+  }
+
+  const prose = noThink.replace(/<tool_call>[\s\S]*?<\/tool_call>/g, '').trim();
+
+  if (matches.length === 0) {
+    content.push({ type: 'text', text: prose || noThink.trim() });
+    return { content, foundToolCall: false };
+  }
+
+  if (prose) {
+    content.push({ type: 'text', text: prose });
+  }
+  for (let i = 0; i < matches.length; i++) {
+    content.push({
+      type: 'tool_use',
+      id: `tc-${Date.now()}-${i}`,
+      name: matches[i].name,
+      input: matches[i].input,
+    });
+  }
+  return { content, foundToolCall: true };
+}
+
+// ──────────────────────────────────────────────────────────────────────────
+// Mistral [TOOL_CALLS][...] format
+// ──────────────────────────────────────────────────────────────────────────
+
+function parseMistralToolCalls(text: string): ParseResult {
+  const re = /\[TOOL_CALLS\]\s*(\[[\s\S]*?\])/g;
+  const content: ContentBlock[] = [];
+  const matches: Array<{ name: string; input: Record<string, unknown> }> = [];
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(text)) !== null) {
+    try {
+      const arr = JSON.parse(m[1]);
+      if (Array.isArray(arr)) {
+        for (const entry of arr) {
+          if (entry && typeof entry === 'object' && typeof entry.name === 'string') {
+            matches.push({
+              name: entry.name,
+              input: (entry.arguments ?? {}) as Record<string, unknown>,
+            });
+          }
+        }
+      }
+    } catch {
+      // Skip unparseable [TOOL_CALLS] blocks.
+    }
+  }
+
+  const prose = text.replace(/\[TOOL_CALLS\]\s*\[[\s\S]*?\]/g, '').trim();
+
+  if (matches.length === 0) {
+    content.push({ type: 'text', text: prose || text.trim() });
+    return { content, foundToolCall: false };
+  }
+
+  if (prose) {
+    content.push({ type: 'text', text: prose });
+  }
+  for (let i = 0; i < matches.length; i++) {
+    content.push({
+      type: 'tool_use',
+      id: `tc-${Date.now()}-${i}`,
+      name: matches[i].name,
+      input: matches[i].input,
+    });
+  }
+  return { content, foundToolCall: true };
+}

package/src/prompts/tool-refs.ts

@@ -0,0 +1,196 @@
+// Collect per-layer prompt references (tool names formatted for the LLM).
+
+import type { ProviderTool } from '../types.js';
+import {
+  buildToolsFromLayers,
+  protocolToken,
+  resolveCanonicalTools,
+  sanitizeServerName,
+  type McpLayer,
+  type ProviderKind,
+  type ToolLayer,
+  type WebMcpLayer,
+} from '../tool-layers.js';
+import { formatGemmaToolDeclaration } from './gemma4-prompt-builder.js';
+
+/** Short descriptions for discovery pseudo-tools (used in inline Gemma decls). */
+const shortSearchToolsDesc = (serverName: string) =>
+  `Search tools by keyword on the ${serverName} server.`;
+const shortListToolsDesc = (serverName: string) =>
+  `List ALL tools on the ${serverName} server.`;
+
+/** First parameter name from a tool's input schema (for arg hints). */
+function firstParamName(tool?: ProviderTool, fallback = 'query'): string {
+  if (!tool?.input_schema) return fallback;
+  const schema = tool.input_schema as Record<string, unknown>;
+  const required = (schema.required as string[] | undefined) ?? [];
+  if (required.length > 0) return required[0];
+  const props = (schema.properties as Record<string, unknown> | undefined) ?? {};
+  return Object.keys(props)[0] ?? fallback;
+}
+
+/** Format a tool reference for the system prompt (generic or inline Gemma decl). */
+function fmtToolRef(
+  prefixedName: string,
+  args: string[] = [],
+  kind: ProviderKind = 'generic',
+  tool?: ProviderTool,
+): string {
+  if (kind === 'gemma' && tool) {
+    return formatGemmaToolDeclaration({ ...tool, name: prefixedName });
+  }
+  if (kind === 'gemma' || kind === 'qwen' || kind === 'mistral') {
+    return args.length ? `\`${prefixedName}(${args.join(', ')})\`` : `\`${prefixedName}\``;
+  }
+  return args.length ? `${prefixedName}(${args.join(', ')})` : `${prefixedName}()`;
+}
+
+export interface PromptRefs {
+  searchRecipes: string[];
+  listRecipes: string[];
+  getRecipes: string[];
+  searchTools: string[];
+  listTools: string[];
+  actionTools: string[];
+  listRecipesByCat: { data: string[]; display: string[] };
+  searchRecipesByCat: { data: string[]; display: string[] };
+  getRecipesByCat: { data: string[]; display: string[] };
+  aliasMap: Map<string, string>;
+}
+
+export function collectPromptRefs(
+  layers: ToolLayer[],
+  providerKind: ProviderKind,
+): PromptRefs {
+  const kind = providerKind;
+  const mcpLayers = layers.filter((l): l is McpLayer => l.protocol === 'mcp');
+  const webmcpLayers = layers.filter((l): l is WebMcpLayer => l.protocol === 'webmcp');
+
+  const displayLayers = webmcpLayers.filter(l => l.tools.some(t => t.name === 'widget_display'));
+  const dataLayers = layers.filter(l => !displayLayers.includes(l as WebMcpLayer));
+
+  const providerToolsByName = new Map<string, ProviderTool>(
+    buildToolsFromLayers(layers, { sanitize: true }).tools.map(t => [t.name, t]),
+  );
+
+  const aliasMap = new Map<string, string>();
+  const searchRecipes: string[] = [];
+  const listRecipes: string[] = [];
+  const getRecipes: string[] = [];
+  const searchTools: string[] = [];
+  const listTools: string[] = [];
+
+  for (const l of webmcpLayers) {
+    const prefix = `${sanitizeServerName(l.serverName)}_ui_`;
+    for (const t of l.tools) {
+      if (t.name === 'search_recipes') {
+        const name = `${prefix}search_recipes`;
+        const toolDef = providerToolsByName.get(name);
+        searchRecipes.push(fmtToolRef(name, [firstParamName(toolDef, 'query')], kind, toolDef));
+      }
+      if (t.name === 'list_recipes') {
+        const name = `${prefix}list_recipes`;
+        const toolDef = providerToolsByName.get(name);
+        listRecipes.push(fmtToolRef(name, [], kind, toolDef));
+      }
+      if (t.name === 'get_recipe') {
+        const name = `${prefix}get_recipe`;
+        const toolDef = providerToolsByName.get(name);
+        getRecipes.push(fmtToolRef(name, [firstParamName(toolDef, 'id')], kind, toolDef));
+      }
+    }
+    const searchToolsPseudo: ProviderTool = {
+      name: `${prefix}search_tools`,
+      description: shortSearchToolsDesc(l.serverName),
+      input_schema: { type: 'object', properties: { query: { type: 'string', description: 'Keyword to search for.' } }, required: ['query'] },
+    };
+    searchTools.push(fmtToolRef(`${prefix}search_tools`, ['query'], kind, searchToolsPseudo));
+    const listToolsPseudo: ProviderTool = {
+      name: `${prefix}list_tools`,
+      description: shortListToolsDesc(l.serverName),
+      input_schema: { type: 'object', properties: {} },
+    };
+    listTools.push(fmtToolRef(`${prefix}list_tools`, [], kind, listToolsPseudo));
+  }
+
+  for (const l of mcpLayers) {
+    const prefix = `${sanitizeServerName(l.serverName)}_data_`;
+    const matches = resolveCanonicalTools(l.tools);
+
+    for (const m of matches) {
+      const canonicalPrefixed = `${prefix}${m.role}`;
+      const realPrefixed = `${prefix}${m.realToolName}`;
+
+      if (m.role !== m.realToolName) {
+        aliasMap.set(canonicalPrefixed, realPrefixed);
+      }
+
+      const realToolDef = providerToolsByName.get(realPrefixed);
+
+      if (m.role === 'search_recipes') {
+        searchRecipes.push(fmtToolRef(canonicalPrefixed, [firstParamName(realToolDef, 'query')], kind, realToolDef));
+      }
+      if (m.role === 'list_recipes') {
+        listRecipes.push(fmtToolRef(canonicalPrefixed, [], kind, realToolDef));
+      }
+      if (m.role === 'get_recipe') {
+        getRecipes.push(fmtToolRef(canonicalPrefixed, [firstParamName(realToolDef, 'id')], kind, realToolDef));
+      }
+    }
+
+    const searchToolsPseudo: ProviderTool = {
+      name: `${prefix}search_tools`,
+      description: shortSearchToolsDesc(l.serverName),
+      input_schema: { type: 'object', properties: { query: { type: 'string', description: 'Keyword to search for.' } }, required: ['query'] },
+    };
+    searchTools.push(fmtToolRef(`${prefix}search_tools`, ['query'], kind, searchToolsPseudo));
+    const listToolsPseudo: ProviderTool = {
+      name: `${prefix}list_tools`,
+      description: shortListToolsDesc(l.serverName),
+      input_schema: { type: 'object', properties: {} },
+    };
+    listTools.push(fmtToolRef(`${prefix}list_tools`, [], kind, listToolsPseudo));
+  }
+
+  const actionTools: string[] = [];
+  const ACTION_NAMES = ['widget_display', 'canvas', 'recall'];
+  for (const l of webmcpLayers) {
+    const prefix = `${sanitizeServerName(l.serverName)}_ui_`;
+    for (const actionName of ACTION_NAMES) {
+      if (l.tools.some(t => t.name === actionName)) {
+        const prefixedName = `${prefix}${actionName}`;
+        const toolDef = providerToolsByName.get(prefixedName);
+        const args = actionName === 'widget_display' ? ['name', 'params'] : [];
+        actionTools.push(fmtToolRef(prefixedName, args, kind, toolDef));
+      }
+    }
+  }
+
+  const dataPrefixes = new Set(dataLayers.map(l => `${sanitizeServerName(l.serverName)}_${protocolToken(l.protocol)}_`));
+  const displayPrefixes = new Set(displayLayers.map(l => `${sanitizeServerName(l.serverName)}_ui_`));
+  void dataPrefixes;
+
+  function splitByCategory(refs: string[]): { data: string[]; display: string[] } {
+    const data: string[] = [];
+    const display: string[] = [];
+    for (const ref of refs) {
+      const isDisplay = [...displayPrefixes].some(p => ref.includes(p));
+      if (isDisplay) display.push(ref);
+      else data.push(ref);
+    }
+    return { data, display };
+  }
+
+  return {
+    searchRecipes,
+    listRecipes,
+    getRecipes,
+    searchTools,
+    listTools,
+    actionTools,
+    listRecipesByCat: splitByCategory(listRecipes),
+    searchRecipesByCat: splitByCategory(searchRecipes),
+    getRecipesByCat: splitByCategory(getRecipes),
+    aliasMap,
+  };
+}

package/src/providers/factory.ts

@@ -2,15 +2,36 @@ import type { LLMProvider, RemoteModelId, WasmModelId } from '../types.js';
 import { RemoteLLMProvider } from './remote.js';
 import { WasmProvider } from './wasm.js';
 import { LocalLLMProvider, type LocalBackend } from './local.js';
+import { TransformersProvider } from './transformers.js';
+import { HawkProvider } from './hawk.js';
 
 export type LLMConfig =
-  | { type: 'remote'; model?: RemoteModelId; proxyUrl?: string; apiKey?: string }
-  | { type: 'wasm';   model?: WasmModelId;   onProgress?: (loaded: number, total: number) => void }
-  | { type: 'local';  model: string;         baseUrl: string; backend?: LocalBackend };
+  | { type: 'remote';       model?: RemoteModelId; proxyUrl?: string; apiKey?: string }
+  | { type: 'wasm';         model?: WasmModelId;   onProgress?: (loaded: number, total: number) => void }
+  | { type: 'transformers'; model: string;         onProgress?: (loaded: number, total: number) => void }
+  | { type: 'local';        model: string;         baseUrl: string; backend?: LocalBackend }
+  | { type: 'hawk';         model: string;         proxyUrl?: string };
 
 export function createProvider(config: LLMConfig): LLMProvider {
   const base = typeof window !== 'undefined' ? (document.querySelector('base') as HTMLBaseElement | null)?.href ?? '' : '';
 
+  // Prefix-based dispatch: a `transformers-*` model routes to TransformersProvider
+  // regardless of the declared type (defensive).
+  if ('model' in config && typeof config.model === 'string' && config.model.startsWith('hawk-')) {
+    return new HawkProvider({
+      proxyUrl: (config as { proxyUrl?: string }).proxyUrl ?? `${base}api/hawk`,
+      model: config.model.slice(5),
+    });
+  }
+
+  if ('model' in config && typeof config.model === 'string' && config.model.startsWith('transformers-')) {
+    const onProgress = (config as { onProgress?: (loaded: number, total: number) => void }).onProgress;
+    return new TransformersProvider({
+      model: config.model,
+      onProgress: onProgress ? (_progress, _status, loaded, total) => onProgress(loaded ?? 0, total ?? 0) : undefined,
+    });
+  }
+
   switch (config.type) {
     case 'remote':
       return new RemoteLLMProvider({
@@ -23,11 +44,21 @@ export function createProvider(config: LLMConfig): LLMProvider {
         model: config.model,
         onProgress: config.onProgress ? (progress, _status, loaded, total) => config.onProgress!(loaded ?? 0, total ?? 0) : undefined,
       });
+    case 'transformers':
+      return new TransformersProvider({
+        model: config.model,
+        onProgress: config.onProgress ? (_progress, _status, loaded, total) => config.onProgress!(loaded ?? 0, total ?? 0) : undefined,
+      });
     case 'local':
       return new LocalLLMProvider({
         baseUrl: config.baseUrl,
         model: config.model,
         backend: config.backend,
       });
+    case 'hawk':
+      return new HawkProvider({
+        proxyUrl: config.proxyUrl ?? `${base}api/hawk`,
+        model: config.model,
+      });
   }
 }

package/src/providers/hawk-models.ts

@@ -0,0 +1,22 @@
+export interface HawkModelEntry {
+  id: string;      // ID Hawk (sans préfixe)
+  label: string;   // Label humain pour le selector
+  tokps?: number;  // Tokens/sec estimés (warm, indicatif)
+}
+
+export const HAWK_MODELS: HawkModelEntry[] = [
+  { id: 'qwen35-2b',       label: 'Qwen 3.5 2B — 49 tok/s',       tokps: 49 },
+  { id: 'bielik-1.5b-v3',  label: 'Bielik 1.5B — 47 tok/s',       tokps: 47 },
+  { id: 'gemma4-e2b',      label: 'Gemma 4 E2B — 43 tok/s',       tokps: 43 },
+  { id: 'ministral3-3b',   label: 'Ministral 3B — 35 tok/s',      tokps: 35 },
+  { id: 'qwen3-4b',        label: 'Qwen 3 4B — 28 tok/s',         tokps: 28 },
+  { id: 'gemma4-e4b',      label: 'Gemma 4 E4B — 26 tok/s',       tokps: 26 },
+  { id: 'qwen35-4b',       label: 'Qwen 3.5 4B — 23 tok/s',       tokps: 23 },
+  { id: 'qwen36-35b-a3b',  label: 'Qwen 3.6 35B MoE — 22 tok/s',  tokps: 22 },
+  { id: 'gemma4-26b-a4b',  label: 'Gemma 4 26B MoE — 20 tok/s',   tokps: 20 },
+  { id: 'ministral-8b',    label: 'Ministral 8B — 16 tok/s',      tokps: 16 },
+];
+
+export function listHawkModels(): HawkModelEntry[] {
+  return HAWK_MODELS;
+}