nuxt-edge-ai 0.1.2 → 0.1.3

package/README.md

@@ -1,17 +1,35 @@
 # nuxt-edge-ai
 
-`nuxt-edge-ai` is a Nuxt module for building local-first AI applications with a real server-side WASM inference runtime.
+[![npm version](https://img.shields.io/npm/v/nuxt-edge-ai/latest.svg)](https://www.npmjs.com/package/nuxt-edge-ai)
+[![npm downloads](https://img.shields.io/npm/dm/nuxt-edge-ai.svg)](https://www.npmjs.com/package/nuxt-edge-ai)
+[![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)
+
+`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.
 
 It ships:
 
 - a Nuxt module install surface
 - Nitro API routes for health, model pull, and generation
 - a client composable for app-side usage
+- an `EdgeAI` SDK with an OpenAI-like `chat.completions.create()` surface
+- switchable `local`, `remote`, and `mock` providers behind one module API
 - a vendored `transformers.js` + `onnxruntime-web` runtime inside the package
 - no Ollama, no `llama.cpp`, no Rust/C++/native runtime dependency for consumers
 
 The model weights are not bundled. Users either point the module at a local model directory or allow it to download and cache the model on first run.
 
+## Features
+
+- Nuxt module install surface designed for app integration
+- Nitro endpoints for health, pull, and generate workflows
+- local-first server-side inference with bundled WASM runtime assets
+- optional OpenAI-compatible remote provider for stronger hosted models
+- OpenAI-compatible `chat/completions` endpoint for SDK-style integration
+- published package includes vendored inference runtime files
+- no consumer requirement for Ollama, Rust, C++, Python, or native AI runtimes
+
 ## Why this exists
 
 The goal is to make `nuxt-edge-ai` a credible, publishable Nuxt module:
@@ -19,23 +37,20 @@ The goal is to make `nuxt-edge-ai` a credible, publishable Nuxt module:
 - installable in a regular Nuxt app
 - able to run a real local model
 - packaged as JS/TS + WASM only
-- suitable as a strong portfolio / resume project
 
 ## Current runtime
 
-Current real runtime path:
+Current local runtime path:
 
 - `transformers.js` web build
 - `onnxruntime-web` WASM backend
 - server-side execution through Nitro
 
-Recommended first demo model:
+Built-in local preset:
 
-- `Xenova/distilgpt2` for quick validation
+- `distilgpt2`
 
-Recommended next upgrade target:
-
-- `onnx-community/Qwen2.5-0.5B-Instruct-ONNX`
+The local path is intentionally conservative now. When local inference is not enough, the module can fall back to a remote OpenAI-compatible API.
 
 ## Install
 
@@ -48,20 +63,15 @@ pnpm add nuxt-edge-ai
 export default defineNuxtConfig({
   modules: ['nuxt-edge-ai'],
   edgeAI: {
-    runtime: 'transformers-wasm',
+    provider: 'local',
     cacheDir: './.cache/nuxt-edge-ai',
-    model: {
-      id: 'Xenova/distilgpt2',
-      task: 'text-generation',
-      allowRemote: true,
-      dtype: 'q8',
-      generation: {
-        maxNewTokens: 96,
-        temperature: 0.7,
-        topP: 0.9,
-        doSample: true,
-        repetitionPenalty: 1.05,
-      },
+    preset: 'distilgpt2',
+    remote: {
+      enabled: true,
+      fallback: true,
+      baseUrl: 'https://api.openai.com/v1',
+      apiKey: process.env.OPENAI_API_KEY,
+      model: 'gpt-4o-mini',
     },
   },
 })
@@ -79,6 +89,110 @@ const result = await edgeAI.generate({
 </script>
 ```
 
+## Configuration
+
+Top-level module options:
+
+| Option | Type | Default | Notes |
+| --- | --- | --- | --- |
+| `routeBase` | `string` | `/api/edge-ai` | Base path for module endpoints |
+| `provider` | `'local' \| 'remote' \| 'mock'` | `local` | Runtime backend selector |
+| `runtime` | `'transformers-wasm' \| 'mock'` | legacy | Backward-compatible alias for older configs |
+| `cacheDir` | `string` | `./.cache/nuxt-edge-ai` | Cache and model asset directory |
+| `warmup` | `boolean` | `false` | Warm the runtime on health checks |
+| `preset` | `string` | `distilgpt2` | Local model preset |
+| `presets` | `Record<string, ...>` | `undefined` | Register additional local presets |
+| `model` | `object` | see below | Override the local model preset |
+| `remote` | `object` | see below | Remote provider and fallback settings |
+
+Local model options:
+
+| Option | Type | Default | Notes |
+| --- | --- | --- | --- |
+| `id` | `string` | `Xenova/distilgpt2` | Model identifier used when no local path is set |
+| `task` | `'text-generation'` | `text-generation` | Current supported task |
+| `localPath` | `string \| undefined` | `undefined` | Local model directory |
+| `allowRemote` | `boolean` | `true` | Allow first-run download from remote model source |
+| `dtype` | `string \| undefined` | `q8` | Runtime dtype passed to Transformers.js |
+| `generation.maxNewTokens` | `number` | `96` | Max generated tokens |
+| `generation.temperature` | `number` | `0.7` | Sampling temperature |
+| `generation.topP` | `number` | `0.9` | Top-p sampling |
+| `generation.doSample` | `boolean` | `true` | Enable sampling |
+| `generation.repetitionPenalty` | `number` | `1.05` | Repetition penalty |
+
+Remote provider options:
+
+| Option | Type | Default | Notes |
+| --- | --- | --- | --- |
+| `enabled` | `boolean` | `false` | Enable remote provider settings |
+| `fallback` | `boolean` | `true` | Fall back to remote if local pull/generate fails |
+| `baseUrl` | `string` | `https://api.openai.com/v1` | Remote API base URL |
+| `path` | `string` | `/chat/completions` | OpenAI-compatible endpoint path |
+| `model` | `string` | `gpt-4o-mini` | Default remote model ID |
+| `apiKey` | `string \| undefined` | `undefined` | Inline API key |
+| `headers` | `Record<string, string> \| undefined` | `undefined` | Extra request headers |
+| `systemPrompt` | `string \| undefined` | `undefined` | Optional system instruction |
+
+## Provider examples
+
+Local-only mode:
+
+```ts
+export default defineNuxtConfig({
+  modules: ['nuxt-edge-ai'],
+  edgeAI: {
+    provider: 'local',
+    preset: 'distilgpt2',
+    remote: {
+      enabled: false,
+    },
+  },
+})
+```
+
+Local with automatic remote fallback:
+
+```ts
+export default defineNuxtConfig({
+  modules: ['nuxt-edge-ai'],
+  edgeAI: {
+    provider: 'local',
+    preset: 'distilgpt2',
+    remote: {
+      enabled: true,
+      fallback: true,
+      baseUrl: 'https://api.openai.com/v1',
+      apiKey: process.env.OPENAI_API_KEY,
+      model: 'gpt-4o-mini',
+    },
+  },
+})
+```
+
+Custom preset registration:
+
+```ts
+export default defineNuxtConfig({
+  modules: ['nuxt-edge-ai'],
+  edgeAI: {
+    presets: {
+      'team-default': {
+        label: 'Team Default',
+        description: 'Project-specific local preset',
+        model: {
+          id: 'Xenova/distilgpt2',
+          dtype: 'q8',
+          generation: {
+            maxNewTokens: 120,
+          },
+        },
+      },
+    },
+    preset: 'team-default',
+  },
+})
+```
+
 ## Consumer runtime guarantees
 
 Consumers do not need to install:
@@ -100,9 +214,97 @@ What consumers do need:
 - `GET /api/edge-ai/health`
 - `POST /api/edge-ai/pull`
 - `POST /api/edge-ai/generate`
+- `POST /api/edge-ai/chat/completions`
 - `useEdgeAI().health()`
 - `useEdgeAI().pull()`
 - `useEdgeAI().generate()`
+- `useEdgeAI().chatCompletions()`
+
+Health responses also expose:
+
+- `provider`
+- `presets`
+- `remoteFallback`
+- `engine.ready`
+- `engine.lastError`
+
+## OpenAI-compatible chat completions
+
+You can either point the official OpenAI client at the module's Nitro route, or use the package's own `EdgeAI` client with the same calling style.
+
+Using `EdgeAI` directly:
+
+```ts
+import { EdgeAI } from 'nuxt-edge-ai'
+
+const client = new EdgeAI({
+  baseURL: 'http://localhost:3000/api/edge-ai',
+})
+
+const response = await client.chat.completions.create({
+  model: 'openai/gpt-oss-20b:free',
+  messages: [
+    {
+      role: 'user',
+      content: "How many r's are in strawberry?",
+    },
+  ],
+  reasoning: { enabled: true },
+})
+```
+
+Using the OpenAI SDK against the same route:
+
+```ts
+import OpenAI from 'openai'
+
+const client = new OpenAI({
+  baseURL: 'http://localhost:3000/api/edge-ai',
+  apiKey: 'local-dev-token',
+})
+
+const response = await client.chat.completions.create({
+  model: 'openai/gpt-oss-20b:free',
+  messages: [
+    {
+      role: 'user',
+      content: "How many r's are in strawberry?",
+    },
+  ],
+  reasoning: { enabled: true },
+})
+```
+
+Inside a Nuxt app you can also use `useEdgeAI().client.chat.completions.create(...)`.
+
+When the module is using a remote OpenAI-compatible backend, it forwards `messages`, `reasoning`, and any extra `remoteBody` fields. If the upstream provider returns `reasoning_details`, the module preserves them on `choices[0].message`.
+
+Example OpenRouter-style config:
+
+```ts
+export default defineNuxtConfig({
+  modules: ['nuxt-edge-ai'],
+  edgeAI: {
+    provider: 'remote',
+    remote: {
+      enabled: true,
+      baseUrl: 'https://openrouter.ai/api/v1',
+      apiKey: process.env.OPENROUTER_API_KEY,
+      model: 'openai/gpt-oss-20b:free',
+    },
+  },
+})
+```
+
+## Troubleshooting
+
+Common checks:
+
+- Run `POST /api/edge-ai/health` first to confirm route wiring and runtime config.
+- Use `provider: 'mock'` to separate module wiring issues from model/runtime issues.
+- Remote fallback requires `edgeAI.remote.enabled: true` plus `edgeAI.remote.apiKey`.
+- If `pull` fails, inspect server logs first. Most early failures are model-path or packaged-runtime issues.
+- After changing vendored runtime files, always run `pnpm prepack` before validating a published-style install.
 
 ## Local development
 
@@ -125,9 +327,15 @@ pnpm prepack
 
 See [`docs/index.md`](./docs/index.md) for the project docs tree.
 
-## Repository shape
+Key docs:
 
-This repository follows a Nuxt modules-style layout:
+- [`docs/getting-started.md`](./docs/getting-started.md)
+- [`docs/api.md`](./docs/api.md)
+- [`docs/models.md`](./docs/models.md)
+- [`docs/architecture.md`](./docs/architecture.md)
+- [`docs/third-party.md`](./docs/third-party.md)
+
+## Repository shape
 
 - `src/module.ts`: module entry and runtime config wiring
 - `src/runtime/`: composables, plugin, and Nitro runtime code
@@ -138,4 +346,4 @@ This repository follows a Nuxt modules-style layout:
 
 ## Status
 
-This is an MVP, but it now runs a real model instead of mock text when `runtime: 'transformers-wasm'` is enabled.
+This is still an MVP, but it now supports three execution modes behind one API: `local`, `remote`, and `mock`.

package/dist/module.d.mts

@@ -1,23 +1,29 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { EdgeAIGenerationOptions } from '../dist/runtime/types.js';
-export { EdgeAIGenerateRequest, EdgeAIGenerateResponse, EdgeAIHealthResponse, EdgeAIPullResponse } from '../dist/runtime/types.js';
+import { EdgeAIModelResolvedConfig, EdgeAIGenerationOptions, EdgeAIRemoteConfig, EdgeAIProvider, EdgeAIModelPresetDefinition } from '../dist/runtime/types.js';
+export { EdgeAIChatCompletionRequest, EdgeAIChatCompletionResponse, EdgeAIGenerateRequest, EdgeAIGenerateResponse, EdgeAIHealthResponse, EdgeAIPullResponse, EdgeAIRemoteMessage, EdgeAIRemoteReasoningOptions } from '../dist/runtime/types.js';
+export { EdgeAI, EdgeAIClientOptions } from '../dist/runtime/client.js';
 
-interface EdgeAIModelOptions {
-    id: string;
-    task: 'text-generation';
-    localPath?: string;
-    allowRemote: boolean;
-    dtype?: string;
-    generation: EdgeAIGenerationOptions;
+interface EdgeAIModelOptions extends Partial<Omit<EdgeAIModelResolvedConfig, 'generation'>> {
+    generation?: Partial<EdgeAIGenerationOptions>;
+}
+interface EdgeAIRemoteOptions extends Partial<EdgeAIRemoteConfig> {
+    baseURL?: string;
+    headers?: Record<string, string>;
 }
 interface ModuleOptions {
-    routeBase: string;
-    runtime: 'transformers-wasm' | 'mock';
-    cacheDir: string;
-    warmup: boolean;
-    model: EdgeAIModelOptions;
+    routeBase?: string;
+    provider?: EdgeAIProvider;
+    runtime?: 'transformers-wasm' | 'mock';
+    cacheDir?: string;
+    warmup?: boolean;
+    preset?: string;
+    presets?: Record<string, Partial<EdgeAIModelPresetDefinition> & {
+        model: EdgeAIModelOptions;
+    }>;
+    model?: EdgeAIModelOptions;
+    remote?: EdgeAIRemoteOptions;
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 
 export { _default as default };
-export type { EdgeAIModelOptions, ModuleOptions };
+export type { EdgeAIModelOptions, EdgeAIRemoteOptions, ModuleOptions };

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-edge-ai",
   "configKey": "edgeAI",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "unknown"

package/dist/module.mjs

@@ -1,5 +1,7 @@
 import { isAbsolute, resolve } from 'node:path';
 import { defineNuxtModule, createResolver, addImportsDir, addPlugin, addServerHandler, addTypeTemplate } from '@nuxt/kit';
+import { mergeModelConfig, builtinModelPresets } from '../dist/runtime/presets.js';
+export { EdgeAI } from '../dist/runtime/client.js';
 
 function resolveMaybeAbsolute(rootDir, value) {
   if (!value) {
@@ -8,9 +10,56 @@ function resolveMaybeAbsolute(rootDir, value) {
   return isAbsolute(value) ? value : resolve(rootDir, value);
 }
 function normalizeRouteBase(routeBase) {
-  const normalized = routeBase.trim().replace(/\/+$/, "");
+  const normalized = routeBase?.trim().replace(/\/+$/, "");
   return normalized || "/api/edge-ai";
 }
+function resolveProvider(options) {
+  if (options.runtime === "mock") {
+    return "mock";
+  }
+  return options.provider || "local";
+}
+function resolveRuntime(provider) {
+  if (provider === "local") {
+    return "transformers-wasm";
+  }
+  return provider;
+}
+function normalizePresetRegistry(presets) {
+  const normalized = { ...builtinModelPresets };
+  for (const [id, preset] of Object.entries(presets || {})) {
+    normalized[id] = {
+      label: preset.label || id,
+      description: preset.description || `Custom preset "${id}".`,
+      model: mergeModelConfig(builtinModelPresets.distilgpt2.model, preset.model)
+    };
+  }
+  return normalized;
+}
+function toPresetSummary(id, preset) {
+  return {
+    id,
+    label: preset.label,
+    description: preset.description,
+    model: {
+      id: preset.model.id,
+      task: preset.model.task,
+      dtype: preset.model.dtype
+    }
+  };
+}
+function resolveRemoteConfig(remote) {
+  return {
+    enabled: remote?.enabled ?? false,
+    fallback: remote?.fallback ?? true,
+    baseUrl: remote?.baseUrl || remote?.baseURL || "https://api.openai.com/v1",
+    apiKey: remote?.apiKey,
+    path: remote?.path || "/chat/completions",
+    model: remote?.model || "gpt-4o-mini",
+    headers: remote?.headers,
+    systemPrompt: remote?.systemPrompt
+  };
+}
 const module$1 = defineNuxtModule({
   meta: {
     name: "nuxt-edge-ai",
@@ -18,53 +67,62 @@ const module$1 = defineNuxtModule({
   },
   defaults: {
     routeBase: "/api/edge-ai",
-    runtime: "transformers-wasm",
+    provider: "local",
     cacheDir: "./.cache/nuxt-edge-ai",
     warmup: false,
-    model: {
-      id: "Xenova/distilgpt2",
-      task: "text-generation",
-      allowRemote: true,
-      dtype: "q8",
-      generation: {
-        maxNewTokens: 96,
-        temperature: 0.7,
-        topP: 0.9,
-        doSample: true,
-        repetitionPenalty: 1.05
-      }
+    preset: "distilgpt2",
+    model: {},
+    remote: {
+      enabled: false,
+      fallback: true,
+      baseUrl: "https://api.openai.com/v1",
+      path: "/chat/completions",
+      model: "gpt-4o-mini"
     }
   },
   setup(options, nuxt) {
     const resolver = createResolver(import.meta.url);
     const routeBase = normalizeRouteBase(options.routeBase);
-    const cacheDir = resolveMaybeAbsolute(nuxt.options.rootDir, options.cacheDir) ?? options.cacheDir;
-    const modelLocalPath = resolveMaybeAbsolute(nuxt.options.rootDir, options.model.localPath);
+    const provider = resolveProvider(options);
+    const runtime = resolveRuntime(provider);
+    const cacheDir = resolveMaybeAbsolute(nuxt.options.rootDir, options.cacheDir) ?? "./.cache/nuxt-edge-ai";
+    const presetRegistry = normalizePresetRegistry(options.presets);
+    const presetId = options.preset || "distilgpt2";
+    const preset = presetRegistry[presetId];
+    if (!preset) {
+      throw new Error(
+        `Unknown edgeAI preset "${presetId}". Available presets: ${Object.keys(presetRegistry).join(", ")}`
+      );
+    }
+    const model = mergeModelConfig(preset.model, options.model);
     const runtimeConfig = nuxt.options.runtimeConfig;
-    runtimeConfig.edgeAI = {
+    const presets = Object.entries(presetRegistry).map(([id, entry]) => toPresetSummary(id, entry));
+    const serverModel = {
+      ...model,
+      localPath: resolveMaybeAbsolute(nuxt.options.rootDir, model.localPath)
+    };
+    const remote = resolveRemoteConfig(options.remote);
+    const serverRuntimeConfig = {
       routeBase,
-      runtime: options.runtime,
+      provider,
+      runtime,
       cacheDir,
-      warmup: options.warmup,
-      model: {
-        id: options.model.id,
-        task: options.model.task,
-        localPath: modelLocalPath,
-        allowRemote: options.model.allowRemote,
-        dtype: options.model.dtype,
-        generation: {
-          maxNewTokens: options.model.generation.maxNewTokens,
-          temperature: options.model.generation.temperature,
-          topP: options.model.generation.topP,
-          doSample: options.model.generation.doSample,
-          repetitionPenalty: options.model.generation.repetitionPenalty
-        }
-      }
+      warmup: Boolean(options.warmup),
+      preset: provider === "local" ? presetId : void 0,
+      model: serverModel,
+      remote,
+      presets
     };
+    runtimeConfig.edgeAI = serverRuntimeConfig;
     runtimeConfig.public.edgeAI = {
       routeBase,
-      runtime: options.runtime,
-      defaultModel: options.model.id
+      provider,
+      runtime,
+      defaultModel: provider === "remote" ? remote.model : serverModel.id,
+      remoteModel: remote.model,
+      preset: provider === "local" ? presetId : void 0,
+      presets,
+      remoteFallback: remote.fallback
     };
     addImportsDir(resolver.resolve("./runtime/composables"));
     addPlugin(resolver.resolve("./runtime/plugin"));
@@ -83,24 +141,39 @@ const module$1 = defineNuxtModule({
       method: "post",
       handler: resolver.resolve("./runtime/server/api/generate.post")
     });
+    addServerHandler({
+      route: `${routeBase}/chat/completions`,
+      method: "post",
+      handler: resolver.resolve("./runtime/server/api/chat-completions.post")
+    });
     addTypeTemplate({
       filename: "types/nuxt-edge-ai.d.ts",
       getContents: () => `import type { NuxtApp } from '#app'
 import type {
-  EdgeAIPullResponse,
+  EdgeAIChatCompletionRequest,
+  EdgeAIChatCompletionResponse,
+  EdgeAIClientOptions,
   EdgeAIGenerateRequest,
   EdgeAIGenerateResponse,
-  EdgeAIHealthResponse
+  EdgeAIHealthResponse,
+  EdgeAIPullResponse
 } from 'nuxt-edge-ai'
+import type { EdgeAI } from 'nuxt-edge-ai'
 
 declare module '#app' {
   interface NuxtApp {
     $edgeAI: {
       routeBase: string
-      runtime: 'transformers-wasm' | 'mock'
+      provider: 'local' | 'remote' | 'mock'
+      runtime: 'transformers-wasm' | 'remote' | 'mock'
       defaultModel: string
+      remoteModel: string
+      preset?: string
+      remoteFallback: boolean
+      client: EdgeAI
       pull: () => Promise<EdgeAIPullResponse>
       generate: (payload: EdgeAIGenerateRequest) => Promise<EdgeAIGenerateResponse>
+      chatCompletions: (payload: EdgeAIChatCompletionRequest) => Promise<EdgeAIChatCompletionResponse>
       health: () => Promise<EdgeAIHealthResponse>
     }
   }

package/dist/runtime/client.d.ts

@@ -0,0 +1,26 @@
+import type { EdgeAIChatCompletionRequest, EdgeAIChatCompletionResponse, EdgeAIGenerateRequest, EdgeAIGenerateResponse, EdgeAIHealthResponse, EdgeAIPullResponse } from './types.js';
+export interface EdgeAIClientOptions {
+    baseURL: string;
+    apiKey?: string;
+    headers?: Record<string, string>;
+    fetch?: typeof globalThis.fetch;
+}
+export declare class EdgeAI {
+    private readonly baseURL;
+    private readonly apiKey?;
+    private readonly headers?;
+    private readonly fetchImpl;
+    readonly chat: {
+        completions: {
+            create: (payload: EdgeAIChatCompletionRequest) => Promise<EdgeAIChatCompletionResponse>;
+        };
+    };
+    constructor(options: EdgeAIClientOptions);
+    responses: {
+        create: (payload: EdgeAIChatCompletionRequest) => Promise<EdgeAIChatCompletionResponse>;
+    };
+    health(): Promise<EdgeAIHealthResponse>;
+    pull(): Promise<EdgeAIPullResponse>;
+    generate(payload: EdgeAIGenerateRequest): Promise<EdgeAIGenerateResponse>;
+    private request;
+}

package/dist/runtime/client.js

@@ -0,0 +1,62 @@
+function joinUrl(baseURL, path) {
+  const normalizedBase = baseURL.replace(/\/+$/, "");
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  return `${normalizedBase}${normalizedPath}`;
+}
+export class EdgeAI {
+  baseURL;
+  apiKey;
+  headers;
+  fetchImpl;
+  chat = {
+    completions: {
+      create: (payload) => this.request("/chat/completions", {
+        method: "POST",
+        body: payload
+      })
+    }
+  };
+  constructor(options) {
+    this.baseURL = options.baseURL;
+    this.apiKey = options.apiKey;
+    this.headers = options.headers;
+    const resolvedFetch = options.fetch || globalThis.fetch;
+    this.fetchImpl = resolvedFetch.bind(globalThis);
+    if (!this.fetchImpl) {
+      throw new Error("Fetch is not available. Provide EdgeAI({ fetch }) in this runtime.");
+    }
+  }
+  responses = {
+    create: async (payload) => this.chat.completions.create(payload)
+  };
+  health() {
+    return this.request("/health");
+  }
+  pull() {
+    return this.request("/pull", {
+      method: "POST"
+    });
+  }
+  generate(payload) {
+    return this.request("/generate", {
+      method: "POST",
+      body: payload
+    });
+  }
+  async request(path, options = {}) {
+    const response = await this.fetchImpl(joinUrl(this.baseURL, path), {
+      method: options.method || "GET",
+      headers: {
+        "content-type": "application/json",
+        ...this.apiKey ? { authorization: `Bearer ${this.apiKey}` } : {},
+        ...this.headers
+      },
+      body: options.body === void 0 ? void 0 : JSON.stringify(options.body)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`EdgeAI request failed with ${response.status}: ${errorText}`);
+    }
+    return await response.json();
+  }
+}