@webmcp-auto-ui/agent 2.5.11 → 2.5.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webmcp-auto-ui/agent",
-  "version": "2.5.11",
+  "version": "2.5.12",
   "description": "LLM agent loop + Anthropic/Gemma LiteRT providers + MCP wrapper",
   "license": "AGPL-3.0-or-later",
   "type": "module",

package/src/discovery-cache.ts

@@ -41,6 +41,39 @@ export class DiscoveryCache {
     this.servers.clear();
   }
 
+  /** All registered server prefixes */
+  serverPrefixes(): string[] {
+    return [...this.servers.keys()];
+  }
+
+  /** All recipes across all servers, tagged with their server prefix */
+  allRecipes(): Array<CachedRecipe & { server: string }> {
+    const result: Array<CachedRecipe & { server: string }> = [];
+    for (const [prefix, cache] of this.servers) {
+      for (const r of cache.recipes) result.push({ ...r, server: prefix });
+    }
+    return result;
+  }
+
+  /** All tools across all servers, tagged with their server prefix */
+  allTools(): Array<{ name: string; description?: string; inputSchema?: Record<string, unknown>; server: string }> {
+    const result: Array<{ name: string; description?: string; inputSchema?: Record<string, unknown>; server: string }> = [];
+    for (const [prefix, cache] of this.servers) {
+      for (const t of cache.tools) result.push({ ...t, server: prefix });
+    }
+    return result;
+  }
+
+  /** Recipe count for a specific server */
+  recipeCount(serverPrefix: string): number {
+    return this.servers.get(serverPrefix)?.recipes.length ?? 0;
+  }
+
+  /** Tool count for a specific server */
+  toolCount(serverPrefix: string): number {
+    return this.servers.get(serverPrefix)?.tools.length ?? 0;
+  }
+
   /**
    * Try to resolve a discovery tool call from cache.
    * Returns the result string if handled, or null if not a discovery tool.

package/src/index.ts

@@ -38,6 +38,11 @@ export type { WebMcpServer, WebMcpToolDef, WidgetEntry } from '@webmcp-auto-ui/c
 // Recipes
 export { WEBMCP_RECIPES, parseRecipe, parseRecipes } from './recipes/index.js';
 export { recipeRegistry, registerRecipes, filterRecipesByServer, formatRecipesForPrompt, formatMcpRecipesForPrompt } from './recipe-registry.js';
+export { filterRecipes, sortRecipes, recipeToMarkdown, recipeToDownloadBlob } from './recipe-browser.js';
+
+// Tool browser
+export { groupToolsByServer, formatToolSchema } from './tool-browser.js';
+export type { BrowsableTool } from './tool-browser.js';
 
 // Summarize
 export { summarizeChat } from './summarize.js';

package/src/recipe-browser.ts

@@ -0,0 +1,85 @@
+// recipe-browser — pure utility functions for browsing/filtering/exporting recipes
+
+/**
+ * Case-insensitive filter on name and description fields.
+ * Empty query returns all recipes.
+ */
+export function filterRecipes<T extends { name: string; description?: string }>(
+  recipes: T[],
+  query: string,
+): T[] {
+  const q = query.trim().toLowerCase();
+  if (!q) return recipes;
+  return recipes.filter(
+    (r) =>
+      r.name.toLowerCase().includes(q) ||
+      (r.description && r.description.toLowerCase().includes(q)),
+  );
+}
+
+/**
+ * Returns a new array sorted alphabetically by name (case-insensitive).
+ * Does NOT mutate the input array.
+ */
+export function sortRecipes<T extends { name: string }>(recipes: T[]): T[] {
+  return [...recipes].sort((a, b) =>
+    a.name.toLowerCase().localeCompare(b.name.toLowerCase()),
+  );
+}
+
+// Keys that belong in Recipe frontmatter (order matters for readability)
+const RECIPE_FM_KEYS = ['id', 'name', 'description', 'when', 'components_used', 'servers', 'layout'] as const;
+// Keys for McpRecipe frontmatter
+const MCP_FM_KEYS = ['name', 'description'] as const;
+
+function yamlValue(value: unknown): string {
+  if (value === null || value === undefined) return '""';
+  if (typeof value === 'string') return value.includes(':') || value.includes('#') || value.includes('\n') ? JSON.stringify(value) : value;
+  if (Array.isArray(value)) return `[${value.map((v) => JSON.stringify(v)).join(', ')}]`;
+  if (typeof value === 'object') return JSON.stringify(value);
+  return String(value);
+}
+
+/**
+ * Reconstructs a markdown file from a recipe object.
+ * Handles both Recipe (id, when, components_used, servers, layout, body)
+ * and McpRecipe (name, description, body?) shapes.
+ */
+export function recipeToMarkdown(recipe: Record<string, unknown>): string {
+  const isFullRecipe = 'id' in recipe || 'when' in recipe;
+  const fmKeys = isFullRecipe ? RECIPE_FM_KEYS : MCP_FM_KEYS;
+
+  const lines: string[] = ['---'];
+  for (const key of fmKeys) {
+    if (key in recipe && recipe[key] !== undefined) {
+      lines.push(`${key}: ${yamlValue(recipe[key])}`);
+    }
+  }
+  lines.push('---');
+
+  const body = typeof recipe.body === 'string' ? recipe.body.trim() : '';
+  if (body) {
+    lines.push('', body);
+  }
+
+  return lines.join('\n') + '\n';
+}
+
+function sanitizeFilename(raw: string): string {
+  return raw.replace(/\s+/g, '-').toLowerCase().replace(/[^a-z0-9_.-]/g, '');
+}
+
+/**
+ * Creates a downloadable Blob from a recipe object.
+ * Filename is derived from name or id, sanitized.
+ */
+export function recipeToDownloadBlob(
+  recipe: Record<string, unknown>,
+): { blob: Blob; filename: string } {
+  const md = recipeToMarkdown(recipe);
+  const rawName = (typeof recipe.name === 'string' && recipe.name)
+    || (typeof recipe.id === 'string' && recipe.id)
+    || 'recipe';
+  const filename = sanitizeFilename(rawName) + '.md';
+  return { blob: new Blob([md], { type: 'text/markdown' }), filename };
+}

package/src/tool-browser.ts

@@ -0,0 +1,36 @@
+// tool-browser — pure utility functions for browsing/filtering tools
+
+export interface BrowsableTool {
+  name: string;
+  description?: string;
+  server?: string;
+  inputSchema?: Record<string, unknown>;
+}
+
+/**
+ * Group tools by server name.
+ * Returns a Map<serverName, tools[]> with alphabetically sorted tools in each group.
+ */
+export function groupToolsByServer(tools: BrowsableTool[]): Map<string, BrowsableTool[]> {
+  const map = new Map<string, BrowsableTool[]>();
+  for (const t of tools) {
+    const key = t.server || 'Unknown';
+    const arr = map.get(key) ?? [];
+    arr.push(t);
+    map.set(key, arr);
+  }
+  // Sort tools within each group
+  for (const [key, arr] of map) {
+    map.set(key, arr.sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase())));
+  }
+  return map;
+}
+
+/**
+ * Format a tool's input schema as a readable string.
+ * Returns pretty-printed JSON, or null if no schema.
+ */
+export function formatToolSchema(tool: BrowsableTool): string | null {
+  if (!tool.inputSchema) return null;
+  return JSON.stringify(tool.inputSchema, null, 2);
+}