nuxt-edge-ai 0.1.4 → 0.2.0

package/README.md

@@ -5,6 +5,8 @@
 [![license](https://img.shields.io/npm/l/nuxt-edge-ai.svg)](./LICENSE)
 [![nuxt](https://img.shields.io/badge/Nuxt-4.x-00DC82?logo=nuxt.js&logoColor=white)](https://nuxt.com/)
 [![ci](https://github.com/otadk/nuxt-edge-ai/actions/workflows/ci.yml/badge.svg)](https://github.com/otadk/nuxt-edge-ai/actions/workflows/ci.yml)
+[![oosmetrics](https://api.oosmetrics.com/api/v1/badge/achievement/69a77845-965e-4d85-a153-e43023059704.svg)](https://oosmetrics.com/repo/otadk/nuxt-edge-ai)
+[![oosmetrics](https://api.oosmetrics.com/api/v1/badge/achievement/5e00ff2f-b279-4ba3-a4de-4f53d9ca2c0c.svg)](https://oosmetrics.com/repo/otadk/nuxt-edge-ai)
 
 `nuxt-edge-ai` is a Nuxt module for building local-first AI applications with a real server-side WASM inference runtime and an optional remote API fallback.
 

package/dist/module.mjs

@@ -150,17 +150,52 @@ const module$1 = defineNuxtModule({
       method: "post",
       handler: resolver.resolve("./runtime/server/api/chat-completions.post")
     });
+    addServerHandler({
+      route: `${routeBase}/classify`,
+      method: "post",
+      handler: resolver.resolve("./runtime/server/api/classify.post")
+    });
+    addServerHandler({
+      route: `${routeBase}/embed`,
+      method: "post",
+      handler: resolver.resolve("./runtime/server/api/embed.post")
+    });
+    addServerHandler({
+      route: `${routeBase}/summarize`,
+      method: "post",
+      handler: resolver.resolve("./runtime/server/api/summarize.post")
+    });
+    addServerHandler({
+      route: `${routeBase}/translate`,
+      method: "post",
+      handler: resolver.resolve("./runtime/server/api/translate.post")
+    });
+    addServerHandler({
+      route: `${routeBase}/fill-mask`,
+      method: "post",
+      handler: resolver.resolve("./runtime/server/api/fill-mask.post")
+    });
     addTypeTemplate({
       filename: "types/nuxt-edge-ai.d.ts",
       getContents: () => `import type { NuxtApp } from '#app'
 import type {
   EdgeAIChatCompletionRequest,
   EdgeAIChatCompletionResponse,
+  EdgeAIClassifyRequest,
+  EdgeAIClassifyResponse,
   EdgeAIClientOptions,
+  EdgeAIEmbedRequest,
+  EdgeAIEmbedResponse,
+  EdgeAIFillMaskRequest,
+  EdgeAIFillMaskResponse,
   EdgeAIGenerateRequest,
   EdgeAIGenerateResponse,
   EdgeAIHealthResponse,
-  EdgeAIPullResponse
+  EdgeAIPullResponse,
+  EdgeAISummarizeRequest,
+  EdgeAISummarizeResponse,
+  EdgeAITranslateRequest,
+  EdgeAITranslateResponse,
 } from 'nuxt-edge-ai'
 import type { EdgeAI } from 'nuxt-edge-ai'
 
@@ -179,6 +214,11 @@ declare module '#app' {
       generate: (payload: EdgeAIGenerateRequest) => Promise<EdgeAIGenerateResponse>
       chatCompletions: (payload: EdgeAIChatCompletionRequest) => Promise<EdgeAIChatCompletionResponse>
       health: () => Promise<EdgeAIHealthResponse>
+      classify: (payload: EdgeAIClassifyRequest) => Promise<EdgeAIClassifyResponse>
+      embed: (payload: EdgeAIEmbedRequest) => Promise<EdgeAIEmbedResponse>
+      summarize: (payload: EdgeAISummarizeRequest) => Promise<EdgeAISummarizeResponse>
+      translate: (payload: EdgeAITranslateRequest) => Promise<EdgeAITranslateResponse>
+      fillMask: (payload: EdgeAIFillMaskRequest) => Promise<EdgeAIFillMaskResponse>
     }
   }
 }

package/dist/runtime/client.d.ts

@@ -1,4 +1,4 @@
-import type { EdgeAIChatCompletionRequest, EdgeAIChatCompletionResponse, EdgeAIGenerateRequest, EdgeAIGenerateResponse, EdgeAIHealthResponse, EdgeAIPullResponse, EdgeAIStreamCallbacks, EdgeAIStreamState, StreamPart } from './types.js';
+import type { EdgeAIChatCompletionRequest, EdgeAIChatCompletionResponse, EdgeAIClassifyRequest, EdgeAIClassifyResponse, EdgeAIEmbedRequest, EdgeAIEmbedResponse, EdgeAIFillMaskRequest, EdgeAIFillMaskResponse, EdgeAIGenerateRequest, EdgeAIGenerateResponse, EdgeAIHealthResponse, EdgeAIPullResponse, EdgeAIStreamCallbacks, EdgeAIStreamState, EdgeAISummarizeRequest, EdgeAISummarizeResponse, EdgeAITranslateRequest, EdgeAITranslateResponse, StreamPart } from './types.js';
 export interface EdgeAIClientOptions {
     baseURL: string;
     apiKey?: string;
@@ -23,6 +23,11 @@ export declare class EdgeAI {
     health(): Promise<EdgeAIHealthResponse>;
     pull(): Promise<EdgeAIPullResponse>;
     generate(payload: EdgeAIGenerateRequest): Promise<EdgeAIGenerateResponse>;
+    classify(payload: EdgeAIClassifyRequest): Promise<EdgeAIClassifyResponse>;
+    embed(payload: EdgeAIEmbedRequest): Promise<EdgeAIEmbedResponse>;
+    summarize(payload: EdgeAISummarizeRequest): Promise<EdgeAISummarizeResponse>;
+    translate(payload: EdgeAITranslateRequest): Promise<EdgeAITranslateResponse>;
+    fillMask(payload: EdgeAIFillMaskRequest): Promise<EdgeAIFillMaskResponse>;
     private streamChatCompletion;
     streamChatCompletionGenerator(payload: EdgeAIChatCompletionRequest): AsyncGenerator<string, EdgeAIStreamState, unknown>;
     stop(state: EdgeAIStreamState): void;

package/dist/runtime/client.js

@@ -124,6 +124,36 @@ export class EdgeAI {
       body: payload
     });
   }
+  classify(payload) {
+    return this.request("/classify", {
+      method: "POST",
+      body: payload
+    });
+  }
+  embed(payload) {
+    return this.request("/embed", {
+      method: "POST",
+      body: payload
+    });
+  }
+  summarize(payload) {
+    return this.request("/summarize", {
+      method: "POST",
+      body: payload
+    });
+  }
+  translate(payload) {
+    return this.request("/translate", {
+      method: "POST",
+      body: payload
+    });
+  }
+  fillMask(payload) {
+    return this.request("/fill-mask", {
+      method: "POST",
+      body: payload
+    });
+  }
   // Streaming chat completion with callbacks
   async streamChatCompletion(payload, callbacks) {
     const abortController = new AbortController();

package/dist/runtime/composables/useEdgeAI.d.ts

@@ -1,5 +1,5 @@
 import type { EdgeAI } from '../client.js';
-import type { EdgeAIChatCompletionRequest, EdgeAIChatCompletionResponse, EdgeAIGenerateRequest, EdgeAIGenerateResponse, EdgeAIHealthResponse, EdgeAIPullResponse } from '../types.js';
+import type { EdgeAIChatCompletionRequest, EdgeAIChatCompletionResponse, EdgeAIClassifyRequest, EdgeAIEmbedRequest, EdgeAIFillMaskRequest, EdgeAIGenerateRequest, EdgeAIGenerateResponse, EdgeAIHealthResponse, EdgeAIPullResponse, EdgeAISummarizeRequest, EdgeAITranslateRequest } from '../types.js';
 export interface UseEdgeAIOptions {
     onStreamStart?: () => void;
     onStreamToken?: (token: string) => void;
@@ -29,6 +29,11 @@ export declare function useEdgeAI(options?: UseEdgeAIOptions): {
     generate(payload: EdgeAIGenerateRequest): Promise<EdgeAIGenerateResponse>;
     chatCompletions(payload: EdgeAIChatCompletionRequest): Promise<EdgeAIChatCompletionResponse>;
     health(): Promise<EdgeAIHealthResponse>;
+    classify(payload: EdgeAIClassifyRequest): Promise<import("../types.js").EdgeAIClassifyResponse>;
+    embed(payload: EdgeAIEmbedRequest): Promise<import("../types.js").EdgeAIEmbedResponse>;
+    summarize(payload: EdgeAISummarizeRequest): Promise<import("../types.js").EdgeAISummarizeResponse>;
+    translate(payload: EdgeAITranslateRequest): Promise<import("../types.js").EdgeAITranslateResponse>;
+    fillMask(payload: EdgeAIFillMaskRequest): Promise<import("../types.js").EdgeAIFillMaskResponse>;
     isLoading: import("vue").Ref<boolean, boolean>;
     isStreaming: import("vue").Ref<boolean, boolean>;
     streamedContent: import("vue").Ref<string, string>;

package/dist/runtime/composables/useEdgeAI.js

@@ -194,19 +194,17 @@ export function useEdgeAI(options = {}) {
       model: payload.model || defaultModel
     };
     try {
-      const response = await fetch(
-        routeBase.startsWith("http") ? `${routeBase}/chat/completions` : new URL(`${routeBase}/chat/completions`, window.location.origin).toString(),
-        {
-          method: "POST",
-          headers: {
-            "content-type": "application/json",
-            "accept": "text/event-stream",
-            "x-vercel-ai-ui-message-stream": "v1"
-          },
-          body: JSON.stringify({ ...payload, stream: true }),
-          signal: abortController.value.signal
-        }
-      );
+      const fetchUrl = routeBase.startsWith("http") ? `${routeBase}/chat/completions` : new URL(`${routeBase}/chat/completions`, window.location.origin).toString();
+      const response = await fetch(fetchUrl, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "accept": "text/event-stream",
+          "x-vercel-ai-ui-message-stream": "v1"
+        },
+        body: JSON.stringify({ ...payload, stream: true }),
+        signal: abortController.value.signal
+      });
       if (!response.ok) {
         const errorText = await response.text();
         throw new Error(`Stream request failed with ${response.status}: ${errorText}`);
@@ -263,10 +261,15 @@ export function useEdgeAI(options = {}) {
                 case "error": {
                   throw new Error(part.errorText || "Stream error");
                 }
+                default: {
+                  break;
+                }
               }
             }
           }
-          if (done) break;
+          if (done) {
+            break;
+          }
         }
       } finally {
         reader.releaseLock();
@@ -311,6 +314,22 @@ export function useEdgeAI(options = {}) {
     health() {
       return edgeAIService.health();
     },
+    // Task-specific methods
+    classify(payload) {
+      return edgeAIService.client.classify(payload);
+    },
+    embed(payload) {
+      return edgeAIService.client.embed(payload);
+    },
+    summarize(payload) {
+      return edgeAIService.client.summarize(payload);
+    },
+    translate(payload) {
+      return edgeAIService.client.translate(payload);
+    },
+    fillMask(payload) {
+      return edgeAIService.client.fillMask(payload);
+    },
     // Streaming state (reactive refs)
     isLoading,
     isStreaming,

package/dist/runtime/plugin.d.ts

@@ -1,5 +1,5 @@
 import { EdgeAI } from './client.js';
-import type { EdgeAIChatCompletionRequest, EdgeAIChatCompletionResponse, EdgeAIGenerateRequest, EdgeAIGenerateResponse, EdgeAIHealthResponse, EdgeAIPullResponse } from './types.js';
+import type { EdgeAIChatCompletionRequest, EdgeAIChatCompletionResponse, EdgeAIClassifyRequest, EdgeAIClassifyResponse, EdgeAIEmbedRequest, EdgeAIEmbedResponse, EdgeAIFillMaskRequest, EdgeAIFillMaskResponse, EdgeAIGenerateRequest, EdgeAIGenerateResponse, EdgeAIHealthResponse, EdgeAIPullResponse, EdgeAISummarizeRequest, EdgeAISummarizeResponse, EdgeAITranslateRequest, EdgeAITranslateResponse } from './types.js';
 declare const _default: import("nuxt/app").Plugin<{
     edgeAI: {
         routeBase: string;
@@ -14,6 +14,11 @@ declare const _default: import("nuxt/app").Plugin<{
         generate(payload: EdgeAIGenerateRequest): Promise<EdgeAIGenerateResponse>;
         chatCompletions(payload: EdgeAIChatCompletionRequest): Promise<EdgeAIChatCompletionResponse>;
         health(): Promise<EdgeAIHealthResponse>;
+        classify(payload: EdgeAIClassifyRequest): Promise<EdgeAIClassifyResponse>;
+        embed(payload: EdgeAIEmbedRequest): Promise<EdgeAIEmbedResponse>;
+        summarize(payload: EdgeAISummarizeRequest): Promise<EdgeAISummarizeResponse>;
+        translate(payload: EdgeAITranslateRequest): Promise<EdgeAITranslateResponse>;
+        fillMask(payload: EdgeAIFillMaskRequest): Promise<EdgeAIFillMaskResponse>;
     };
 }> & import("nuxt/app").ObjectPlugin<{
     edgeAI: {
@@ -29,6 +34,11 @@ declare const _default: import("nuxt/app").Plugin<{
         generate(payload: EdgeAIGenerateRequest): Promise<EdgeAIGenerateResponse>;
         chatCompletions(payload: EdgeAIChatCompletionRequest): Promise<EdgeAIChatCompletionResponse>;
         health(): Promise<EdgeAIHealthResponse>;
+        classify(payload: EdgeAIClassifyRequest): Promise<EdgeAIClassifyResponse>;
+        embed(payload: EdgeAIEmbedRequest): Promise<EdgeAIEmbedResponse>;
+        summarize(payload: EdgeAISummarizeRequest): Promise<EdgeAISummarizeResponse>;
+        translate(payload: EdgeAITranslateRequest): Promise<EdgeAITranslateResponse>;
+        fillMask(payload: EdgeAIFillMaskRequest): Promise<EdgeAIFillMaskResponse>;
     };
 }>;
 export default _default;

package/dist/runtime/plugin.js

@@ -44,6 +44,36 @@ export default defineNuxtPlugin(() => {
         },
         health() {
           return $fetch(`${routeBase}/health`);
+        },
+        classify(payload) {
+          return $fetch(`${routeBase}/classify`, {
+            method: "POST",
+            body: payload
+          });
+        },
+        embed(payload) {
+          return $fetch(`${routeBase}/embed`, {
+            method: "POST",
+            body: payload
+          });
+        },
+        summarize(payload) {
+          return $fetch(`${routeBase}/summarize`, {
+            method: "POST",
+            body: payload
+          });
+        },
+        translate(payload) {
+          return $fetch(`${routeBase}/translate`, {
+            method: "POST",
+            body: payload
+          });
+        },
+        fillMask(payload) {
+          return $fetch(`${routeBase}/fill-mask`, {
+            method: "POST",
+            body: payload
+          });
         }
       }
     }

package/dist/runtime/presets.js

@@ -6,7 +6,7 @@ const defaultGeneration = {
   repetitionPenalty: 1.05
 };
 export const builtinModelPresets = {
-  distilgpt2: {
+  "distilgpt2": {
     label: "DistilGPT2",
     description: "Small baseline text-generation model for quick smoke tests.",
     model: {
@@ -18,6 +18,78 @@ export const builtinModelPresets = {
         ...defaultGeneration
       }
     }
+  },
+  "distilbert-sst2": {
+    label: "DistilBERT Sentiment",
+    description: "Sentiment analysis (positive/negative) using DistilBERT fine-tuned on SST-2.",
+    model: {
+      id: "Xenova/distilbert-base-uncased-finetuned-sst-2-english",
+      task: "text-classification",
+      allowRemote: true,
+      dtype: "fp32"
+    }
+  },
+  "minilm-l6-v2": {
+    label: "MiniLM Embedding",
+    description: "384-dimensional text embeddings using all-MiniLM-L6-v2. Ideal for semantic search and RAG.",
+    model: {
+      id: "Xenova/all-MiniLM-L6-v2",
+      task: "feature-extraction",
+      allowRemote: true,
+      dtype: "fp32"
+    }
+  },
+  "distilbart-cnn": {
+    label: "DistilBART Summarization",
+    description: "Text summarization using DistilBART fine-tuned on CNN/DailyMail.",
+    model: {
+      id: "Xenova/distilbart-cnn-6-6",
+      task: "summarization",
+      allowRemote: true,
+      dtype: "fp32",
+      generation: {
+        ...defaultGeneration,
+        maxNewTokens: 128
+      }
+    }
+  },
+  "opus-mt-en-zh": {
+    label: "Opus-MT en\u2192zh",
+    description: "English to Chinese translation using Helsinki-NLP Opus-MT.",
+    model: {
+      id: "Xenova/opus-mt-en-zh",
+      task: "translation",
+      allowRemote: true,
+      dtype: "fp32",
+      generation: {
+        ...defaultGeneration,
+        maxNewTokens: 256
+      }
+    }
+  },
+  "opus-mt-zh-en": {
+    label: "Opus-MT zh\u2192en",
+    description: "Chinese to English translation using Helsinki-NLP Opus-MT.",
+    model: {
+      id: "Xenova/opus-mt-zh-en",
+      task: "translation",
+      allowRemote: true,
+      dtype: "fp32",
+      generation: {
+        ...defaultGeneration,
+        maxNewTokens: 256
+      }
+    }
+  },
+  "bert-base-uncased": {
+    label: "BERT Fill-Mask",
+    description: "Masked token prediction using BERT base uncased. Use [MASK] token in your text.",
+    model: {
+      id: "Xenova/bert-base-uncased",
+      task: "fill-mask",
+      allowRemote: true,
+      dtype: "fp32"
+    }
   }
 };
 export function resolveGenerationDefaults(defaults, overrides) {
@@ -30,11 +102,11 @@ export function resolveGenerationDefaults(defaults, overrides) {
   };
 }
 export function mergeModelConfig(base, overrides) {
-  const fallbackPreset = builtinModelPresets.distilgpt2;
-  const source = overrides?.id || base?.id || fallbackPreset.model.id;
+  const resolvedId = overrides?.id || base?.id || builtinModelPresets.distilgpt2.model.id;
+  const resolvedTask = overrides?.task ?? base?.task ?? "text-generation";
   return {
-    id: source,
-    task: overrides?.task ?? base?.task ?? "text-generation",
+    id: resolvedId,
+    task: resolvedTask,
     localPath: overrides?.localPath ?? base?.localPath,
     allowRemote: overrides?.allowRemote ?? base?.allowRemote ?? true,
     dtype: overrides?.dtype ?? base?.dtype,

package/dist/runtime/server/api/chat-completions.post.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../../types.js").EdgeAIChatCompletionResponse | undefined>>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../../types.js").EdgeAIChatCompletionResponse | null>>;
 export default _default;

package/dist/runtime/server/api/chat-completions.post.js

@@ -21,6 +21,7 @@ export default defineEventHandler(async (event) => {
   const wantsStreaming = body.stream === true || wantsEventStream;
   if (wantsStreaming) {
     const streamResponse = !body.stream || wantsUIMessageStream ? createEdgeAIChatCompletionStream(config, body) : createEdgeAIChatCompletionOpenAIStream(config, body);
+    event.node.res.statusCode = 200;
     for (const [key, value] of Object.entries(streamResponse.headers)) {
       event.node.res.setHeader(key, value);
     }
@@ -35,7 +36,7 @@ export default defineEventHandler(async (event) => {
       reader.releaseLock();
       event.node.res.end();
     }
-    return;
+    return null;
   }
   return createEdgeAIChatCompletion(config, body);
 });

package/dist/runtime/server/api/classify.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../../types.js").EdgeAIClassifyResponse>>;
+export default _default;

package/dist/runtime/server/api/classify.post.js

@@ -0,0 +1,14 @@
+import { createError, defineEventHandler, readBody } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { classifyEdgeAIText } from "../utils/edge-ai-engine.js";
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event);
+  if (!body?.text?.trim()) {
+    throw createError({ statusCode: 400, statusMessage: "Text is required." });
+  }
+  const config = useRuntimeConfig().edgeAI;
+  return classifyEdgeAIText(config, {
+    text: body.text.trim(),
+    model: body.model
+  });
+});

package/dist/runtime/server/api/embed.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../../types.js").EdgeAIEmbedResponse>>;
+export default _default;

package/dist/runtime/server/api/embed.post.js

@@ -0,0 +1,15 @@
+import { createError, defineEventHandler, readBody } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { embedEdgeAIText } from "../utils/edge-ai-engine.js";
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event);
+  if (!body?.texts || (Array.isArray(body.texts) ? body.texts.length === 0 : !body.texts.trim())) {
+    throw createError({ statusCode: 400, statusMessage: "Texts (string or string array) is required." });
+  }
+  const config = useRuntimeConfig().edgeAI;
+  return embedEdgeAIText(config, {
+    texts: body.texts,
+    pooling: body.pooling,
+    model: body.model
+  });
+});

package/dist/runtime/server/api/fill-mask.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../../types.js").EdgeAIFillMaskResponse>>;
+export default _default;

package/dist/runtime/server/api/fill-mask.post.js

@@ -0,0 +1,15 @@
+import { createError, defineEventHandler, readBody } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { fillMaskEdgeAIText } from "../utils/edge-ai-engine.js";
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event);
+  if (!body?.text?.trim()) {
+    throw createError({ statusCode: 400, statusMessage: "Text with [MASK] token is required." });
+  }
+  const config = useRuntimeConfig().edgeAI;
+  return fillMaskEdgeAIText(config, {
+    text: body.text.trim(),
+    model: body.model,
+    topK: body.topK
+  });
+});

package/dist/runtime/server/api/generate.post.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../../types.js").EdgeAIGenerateResponse>>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../../types.js").EdgeAIGenerateResponse | import("../../types.js").EdgeAIClassifyResponse | import("../../types.js").EdgeAIEmbedResponse | import("../../types.js").EdgeAISummarizeResponse | import("../../types.js").EdgeAITranslateResponse | import("../../types.js").EdgeAIFillMaskResponse>>;
 export default _default;

package/dist/runtime/server/api/generate.post.js

@@ -1,8 +1,56 @@
 import { createError, defineEventHandler, readBody } from "h3";
 import { useRuntimeConfig } from "#imports";
-import { generateEdgeAIText } from "../utils/edge-ai-engine.js";
+import {
+  classifyEdgeAIText,
+  embedEdgeAIText,
+  fillMaskEdgeAIText,
+  generateEdgeAIText,
+  resolvePromptFromMessages,
+  summarizeEdgeAIText,
+  translateEdgeAIText
+} from "../utils/edge-ai-engine.js";
 export default defineEventHandler(async (event) => {
   const body = await readBody(event);
+  const config = useRuntimeConfig().edgeAI;
+  if (body?.task && body.task !== "text-generation") {
+    switch (body.task) {
+      case "text-classification": {
+        const text = body.prompt?.trim();
+        if (!text) {
+          throw createError({ statusCode: 400, statusMessage: "Text (prompt) is required for classification." });
+        }
+        return classifyEdgeAIText(config, { text, model: body.model });
+      }
+      case "feature-extraction": {
+        const texts = body.prompt?.trim() || body.messages && resolvePromptFromMessages(body.messages);
+        if (!texts) {
+          throw createError({ statusCode: 400, statusMessage: "Text (prompt or messages) is required for embedding." });
+        }
+        return embedEdgeAIText(config, { texts, model: body.model });
+      }
+      case "summarization": {
+        const text = body.prompt?.trim();
+        if (!text) {
+          throw createError({ statusCode: 400, statusMessage: "Text (prompt) is required for summarization." });
+        }
+        return summarizeEdgeAIText(config, { text, model: body.model, generation: body.generation });
+      }
+      case "translation": {
+        const text = body.prompt?.trim();
+        if (!text) {
+          throw createError({ statusCode: 400, statusMessage: "Text (prompt) is required for translation." });
+        }
+        return translateEdgeAIText(config, { text, model: body.model });
+      }
+      case "fill-mask": {
+        const text = body.prompt?.trim();
+        if (!text) {
+          throw createError({ statusCode: 400, statusMessage: "Text (prompt) with [MASK] is required for fill-mask." });
+        }
+        return fillMaskEdgeAIText(config, { text, model: body.model });
+      }
+    }
+  }
   const prompt = body?.prompt?.trim();
   const hasMessages = Array.isArray(body?.messages) && body.messages.length > 0;
   if (!prompt && !hasMessages) {
@@ -11,7 +59,6 @@ export default defineEventHandler(async (event) => {
       statusMessage: "Prompt or messages are required."
     });
   }
-  const config = useRuntimeConfig().edgeAI;
   return generateEdgeAIText(config, {
     prompt,
     remote: body.remote,

package/dist/runtime/server/api/summarize.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../../types.js").EdgeAISummarizeResponse>>;
+export default _default;

package/dist/runtime/server/api/summarize.post.js

@@ -0,0 +1,15 @@
+import { createError, defineEventHandler, readBody } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { summarizeEdgeAIText } from "../utils/edge-ai-engine.js";
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event);
+  if (!body?.text?.trim()) {
+    throw createError({ statusCode: 400, statusMessage: "Text is required." });
+  }
+  const config = useRuntimeConfig().edgeAI;
+  return summarizeEdgeAIText(config, {
+    text: body.text.trim(),
+    model: body.model,
+    generation: body.generation
+  });
+});

package/dist/runtime/server/api/translate.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../../types.js").EdgeAITranslateResponse>>;
+export default _default;

package/dist/runtime/server/api/translate.post.js

@@ -0,0 +1,14 @@
+import { createError, defineEventHandler, readBody } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { translateEdgeAIText } from "../utils/edge-ai-engine.js";
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event);
+  if (!body?.text?.trim()) {
+    throw createError({ statusCode: 400, statusMessage: "Text is required." });
+  }
+  const config = useRuntimeConfig().edgeAI;
+  return translateEdgeAIText(config, {
+    text: body.text.trim(),
+    model: body.model
+  });
+});

package/dist/runtime/server/utils/edge-ai-engine.d.ts

@@ -1,4 +1,58 @@
-import type { EdgeAIChatCompletionRequest, EdgeAIChatCompletionResponse, EdgeAIGenerateRequest, EdgeAIGenerateResponse, EdgeAIHealthResponse, EdgeAIServerRuntimeConfig, EdgeAIPullResponse } from '../../types.js';
+import type { EdgeAIChatCompletionRequest, EdgeAIChatCompletionResponse, EdgeAIChatCompletionStreamResponse, EdgeAIClassifyRequest, EdgeAIClassifyResponse, EdgeAIEmbedRequest, EdgeAIEmbedResponse, EdgeAIFillMaskRequest, EdgeAIFillMaskResponse, EdgeAIGenerateRequest, EdgeAIGenerateResponse, EdgeAIGenerationOptions, EdgeAIHealthResponse, EdgeAIModelInfo, EdgeAIRemoteMessage, EdgeAIRemoteConfig, EdgeAIServerRuntimeConfig, EdgeAISummarizeRequest, EdgeAISummarizeResponse, EdgeAITranslateRequest, EdgeAITranslateResponse, EdgeAIPullResponse } from '../../types.js';
+interface RemoteChatCompletionResponse {
+    id?: string;
+    model?: string;
+    choices?: Array<{
+        message?: {
+            role?: string;
+            content?: string | Array<{
+                type?: string;
+                text?: string;
+            }>;
+            reasoning_details?: unknown;
+            [key: string]: unknown;
+        };
+        text?: string;
+        delta?: {
+            role?: string;
+            content?: string;
+        };
+        finish_reason?: string | null;
+    }>;
+    output_text?: string;
+    output?: Array<{
+        content?: Array<{
+            text?: string;
+            type?: string;
+        }>;
+    }>;
+}
+export declare function resolveLocalModelSource(config: EdgeAIServerRuntimeConfig, modelOverride?: string): EdgeAIModelInfo;
+export declare function resolveRemoteModelSource(config: EdgeAIServerRuntimeConfig, modelOverride?: string): EdgeAIModelInfo;
+export declare function resolveGenerationOptions(defaults?: EdgeAIGenerationOptions, overrides?: EdgeAIGenerateRequest['generation']): {
+    maxNewTokens: number;
+    temperature: number;
+    topP: number;
+    doSample: boolean;
+    repetitionPenalty: number;
+};
+export declare function extractGeneratedText(prompt: string, output: unknown): string;
+export declare function extractTextFromMessageContent(content: unknown): string;
+export declare function resolvePromptFromMessages(messages?: EdgeAIRemoteMessage[]): string;
+export declare function resolvePrompt(input: EdgeAIGenerateRequest): string;
+export declare function buildRemoteMessages(config: EdgeAIServerRuntimeConfig, input: EdgeAIGenerateRequest): EdgeAIRemoteMessage[];
+export declare function buildAssistantMessage(payload: RemoteChatCompletionResponse, text: string): EdgeAIRemoteMessage;
+export declare function estimateTokenCount(text: string): number;
+export declare function toChatCompletionResponse(request: EdgeAIChatCompletionRequest, result: EdgeAIGenerateResponse): EdgeAIChatCompletionResponse;
+export declare function toChatCompletionStreamChunk(id: string, model: string, delta: Partial<EdgeAIRemoteMessage>, finishReason?: 'stop' | null): EdgeAIChatCompletionStreamResponse;
+export declare function resolveRemoteApiKey(config: EdgeAIRemoteConfig): string | undefined;
+export declare function joinUrl(baseURL: string, path: string): string;
+export declare function extractRemoteText(payload: RemoteChatCompletionResponse): string;
+export declare function classifyEdgeAIText(config: EdgeAIServerRuntimeConfig, request: EdgeAIClassifyRequest): Promise<EdgeAIClassifyResponse>;
+export declare function embedEdgeAIText(config: EdgeAIServerRuntimeConfig, request: EdgeAIEmbedRequest): Promise<EdgeAIEmbedResponse>;
+export declare function summarizeEdgeAIText(config: EdgeAIServerRuntimeConfig, request: EdgeAISummarizeRequest): Promise<EdgeAISummarizeResponse>;
+export declare function translateEdgeAIText(config: EdgeAIServerRuntimeConfig, request: EdgeAITranslateRequest): Promise<EdgeAITranslateResponse>;
+export declare function fillMaskEdgeAIText(config: EdgeAIServerRuntimeConfig, request: EdgeAIFillMaskRequest): Promise<EdgeAIFillMaskResponse>;
 export declare function getEdgeAIHealth(config: EdgeAIServerRuntimeConfig): Promise<EdgeAIHealthResponse>;
 export declare function pullEdgeAIModel(config: EdgeAIServerRuntimeConfig): Promise<EdgeAIPullResponse>;
 export declare function generateEdgeAIText(config: EdgeAIServerRuntimeConfig, input: EdgeAIGenerateRequest): Promise<EdgeAIGenerateResponse>;
@@ -11,3 +65,4 @@ export declare function createEdgeAIChatCompletionOpenAIStream(config: EdgeAISer
     stream: ReadableStream<string>;
     headers: Record<string, string>;
 };
+export {};