@providerprotocol/ai 0.0.18 → 0.0.20

package/dist/openrouter/index.d.ts

@@ -1,4 +1,4 @@
-import { d as Provider, f as ModelReference, b as LLMHandler, c as EmbeddingHandler } from '../provider-D5MO3-pS.js';
+import { d as Provider, f as ModelReference, b as LLMHandler, c as EmbeddingHandler } from '../provider-BBMBZuGn.js';
 
 /**
  * @fileoverview OpenRouter Embeddings API Handler

package/dist/openrouter/index.js

@@ -8,14 +8,14 @@ import {
   parseSSEStream
 } from "../chunk-Z7RBRCRN.js";
 import {
-  doFetch,
-  doStreamFetch,
-  normalizeHttpError,
   resolveApiKey
-} from "../chunk-5FEAOEXV.js";
+} from "../chunk-P5IRTEM5.js";
 import {
-  UPPError
-} from "../chunk-DZQHVGNV.js";
+  UPPError,
+  doFetch,
+  doStreamFetch,
+  normalizeHttpError
+} from "../chunk-U3FZWV4U.js";
 
 // src/providers/openrouter/transform.completions.ts
 function transformRequest(request, modelId) {

package/dist/{provider-D5MO3-pS.d.ts → provider-BBMBZuGn.d.ts}

@@ -308,7 +308,7 @@ interface ModelReference<TOptions = unknown> {
  * @typeParam TParams - Provider-specific parameter type
  * @internal
  */
-interface LLMHandler<TParams = any> {
+interface LLMHandler<TParams = unknown> {
     /**
      * Binds a model ID to create an executable model instance.
      *
@@ -333,7 +333,7 @@ interface LLMHandler<TParams = any> {
  * @typeParam TParams - Provider-specific parameter type
  * @internal
  */
-interface EmbeddingHandler<TParams = any> {
+interface EmbeddingHandler<TParams = unknown> {
     /** Supported input types for embeddings */
     readonly supportedInputs: ('text' | 'image')[];
     /**
@@ -359,7 +359,7 @@ interface EmbeddingHandler<TParams = any> {
  * @typeParam TParams - Provider-specific parameter type
  * @internal
  */
-interface ImageHandler<TParams = any> {
+interface ImageHandler<TParams = unknown> {
     /**
      * Binds a model ID to create an executable image model.
      *
@@ -382,7 +382,7 @@ interface ImageHandler<TParams = any> {
  *
  * @typeParam TParams - Provider-specific parameter type
  */
-interface BoundLLMModel<TParams = any> {
+interface BoundLLMModel<TParams = unknown> {
     /** The model identifier */
     readonly modelId: string;
     /** Reference to the parent provider */
@@ -396,7 +396,7 @@ interface BoundLLMModel<TParams = any> {
  *
  * @typeParam TParams - Provider-specific parameter type
  */
-interface BoundEmbeddingModel<TParams = any> {
+interface BoundEmbeddingModel<TParams = unknown> {
     /** The model identifier */
     readonly modelId: string;
     /** Reference to the parent provider */
@@ -419,7 +419,7 @@ interface BoundEmbeddingModel<TParams = any> {
  * Request passed to provider's embed method.
  * @internal
  */
-interface EmbeddingRequest<TParams = any> {
+interface EmbeddingRequest<TParams = unknown> {
     /** Inputs to embed */
     inputs: EmbeddingInput[];
     /** Provider-specific parameters (passed through unchanged) */
@@ -480,7 +480,7 @@ type EmbeddingInput = string | {
  *
  * @typeParam TParams - Provider-specific parameter type
  */
-interface BoundImageModel<TParams = any> {
+interface BoundImageModel<TParams = unknown> {
     /** The model identifier */
     readonly modelId: string;
     /** Reference to the parent provider */
@@ -535,7 +535,7 @@ interface Provider<TOptions = unknown> {
  * @typeParam TParams - Model-specific parameters type
  * @typeParam TOptions - Provider-specific options type
  */
-type LLMProvider<TParams = any, TOptions = unknown> = Provider<TOptions> & {
+type LLMProvider<TParams = unknown, TOptions = unknown> = Provider<TOptions> & {
     readonly modalities: {
         llm: LLMHandler<TParams>;
     };
@@ -548,7 +548,7 @@ type LLMProvider<TParams = any, TOptions = unknown> = Provider<TOptions> & {
  * @typeParam TParams - Model-specific parameters type
  * @typeParam TOptions - Provider-specific options type
  */
-type EmbeddingProvider<TParams = any, TOptions = unknown> = Provider<TOptions> & {
+type EmbeddingProvider<TParams = unknown, TOptions = unknown> = Provider<TOptions> & {
     readonly modalities: {
         embedding: EmbeddingHandler<TParams>;
     };
@@ -561,10 +561,10 @@ type EmbeddingProvider<TParams = any, TOptions = unknown> = Provider<TOptions> &
  * @typeParam TParams - Model-specific parameters type
  * @typeParam TOptions - Provider-specific options type
  */
-type ImageProvider<TParams = any, TOptions = unknown> = Provider<TOptions> & {
+type ImageProvider<TParams = unknown, TOptions = unknown> = Provider<TOptions> & {
     readonly modalities: {
         image: ImageHandler<TParams>;
     };
 };
 
-export { type BoundEmbeddingModel as B, type EmbeddingInput as E, type ImageHandler as I, type KeyStrategy as K, type LLMProvider as L, type Modality as M, type ProviderConfig as P, type RetryStrategy as R, UPPError as U, type EmbeddingUsage as a, type LLMHandler as b, type EmbeddingHandler as c, type Provider as d, type ErrorCode as e, type ModelReference as f, type EmbeddingProvider as g, type ImageProvider as h, type BoundImageModel as i, type EmbeddingRequest as j, type EmbeddingResponse as k, type EmbeddingVector as l };
+export { type BoundEmbeddingModel as B, type EmbeddingInput as E, type ImageHandler as I, type KeyStrategy as K, type LLMProvider as L, type Modality as M, type ProviderConfig as P, type RetryStrategy as R, UPPError as U, type EmbeddingUsage as a, type LLMHandler as b, type EmbeddingHandler as c, type Provider as d, type ErrorCode as e, type ModelReference as f, type EmbeddingProvider as g, type ImageProvider as h, type EmbeddingRequest as i, type EmbeddingResponse as j, type EmbeddingVector as k };

package/dist/proxy/index.d.ts

@@ -1,5 +1,6 @@
-import { d as Provider, f as ModelReference } from '../provider-D5MO3-pS.js';
-import { M as Message, b as MessageJSON, T as Turn, $ as TurnJSON, g as StreamEvent, S as StreamResult, J as JSONSchema, u as ToolMetadata, c as Tool } from '../stream-BjyVzBxV.js';
+import { d as Provider, f as ModelReference } from '../provider-BBMBZuGn.js';
+import { M as Message, b as MessageJSON, T as Turn, H as TurnJSON, f as StreamEvent, S as StreamResult, J as JSONSchema, k as ToolMetadata, c as Tool } from '../stream-DRHy6q1a.js';
+import '../content-DEl3z_W2.js';
 
 /**
  * @fileoverview Proxy provider types.
@@ -78,28 +79,6 @@ declare function deserializeStreamEvent(event: StreamEvent): StreamEvent;
  * Provides utilities for using PP proxy with H3-based servers
  * (Nuxt, Nitro, or standalone H3).
  *
- * @example
- * ```typescript
- * // Nuxt server route: server/api/ai.post.ts
- * import { llm, anthropic } from '@providerprotocol/ai';
- * import { parseBody } from '@providerprotocol/ai/proxy';
- * import { h3 as h3Adapter } from '@providerprotocol/ai/proxy/server';
- *
- * export default defineEventHandler(async (event) => {
- *   const body = await readBody(event);
- *   const { messages, system, params } = parseBody(body);
- *   const instance = llm({ model: anthropic('claude-sonnet-4-20250514'), system });
- *
- *   const wantsStream = getHeader(event, 'accept')?.includes('text/event-stream');
- *   if (wantsStream) {
- *     return h3Adapter.streamSSE(instance.stream(messages), event);
- *   } else {
- *     const turn = await instance.generate(messages);
- *     return h3Adapter.sendJSON(turn, event);
- *   }
- * });
- * ```
- *
  * @module providers/proxy/server/h3
  */
 
@@ -169,6 +148,72 @@ declare function sendError$2(message: string, status: number, event: H3Event): {
 };
 /**
  * H3/Nitro/Nuxt adapter utilities.
+ *
+ * @example Basic usage
+ * ```typescript
+ * // Nuxt server route: server/api/ai.post.ts
+ * import { llm } from '@providerprotocol/ai';
+ * import { anthropic } from '@providerprotocol/ai/anthropic';
+ * import { parseBody } from '@providerprotocol/ai/proxy';
+ * import { h3 as h3Adapter } from '@providerprotocol/ai/proxy/server';
+ *
+ * export default defineEventHandler(async (event) => {
+ *   const body = await readBody(event);
+ *   const { messages, system, params } = parseBody(body);
+ *   const instance = llm({ model: anthropic('claude-sonnet-4-20250514'), system });
+ *
+ *   const wantsStream = getHeader(event, 'accept')?.includes('text/event-stream');
+ *   if (wantsStream) {
+ *     return h3Adapter.streamSSE(instance.stream(messages), event);
+ *   } else {
+ *     const turn = await instance.generate(messages);
+ *     return h3Adapter.sendJSON(turn, event);
+ *   }
+ * });
+ * ```
+ *
+ * @example API Gateway with authentication (Nuxt)
+ * ```typescript
+ * // server/api/ai.post.ts
+ * import { llm } from '@providerprotocol/ai';
+ * import { anthropic } from '@providerprotocol/ai/anthropic';
+ * import { ExponentialBackoff, RoundRobinKeys } from '@providerprotocol/ai/http';
+ * import { parseBody } from '@providerprotocol/ai/proxy';
+ * import { h3 as h3Adapter } from '@providerprotocol/ai/proxy/server';
+ *
+ * // Server manages AI provider keys - users never see them
+ * const claude = llm({
+ *   model: anthropic('claude-sonnet-4-20250514'),
+ *   config: {
+ *     apiKey: new RoundRobinKeys([
+ *       process.env.ANTHROPIC_KEY_1!,
+ *       process.env.ANTHROPIC_KEY_2!,
+ *     ]),
+ *     retryStrategy: new ExponentialBackoff({ maxAttempts: 3 }),
+ *   },
+ * });
+ *
+ * export default defineEventHandler(async (event) => {
+ *   // Authenticate with your platform credentials
+ *   const token = getHeader(event, 'authorization')?.replace('Bearer ', '');
+ *   const user = await validatePlatformToken(token);
+ *   if (!user) {
+ *     throw createError({ statusCode: 401, message: 'Unauthorized' });
+ *   }
+ *
+ *   // Track usage per user
+ *   // await trackUsage(user.id);
+ *
+ *   const body = await readBody(event);
+ *   const { messages, system, params } = parseBody(body);
+ *
+ *   if (params?.stream) {
+ *     return h3Adapter.streamSSE(claude.stream(messages, { system }), event);
+ *   }
+ *   const turn = await claude.generate(messages, { system });
+ *   return h3Adapter.sendJSON(turn, event);
+ * });
+ * ```
  */
 declare const h3: {
     sendJSON: typeof sendJSON$2;
@@ -183,28 +228,6 @@ declare const h3: {
  * Provides utilities for using PP proxy with Fastify servers.
  * These adapters convert PP types to Fastify-compatible responses.
  *
- * @example
- * ```typescript
- * import Fastify from 'fastify';
- * import { llm, anthropic } from '@providerprotocol/ai';
- * import { parseBody } from '@providerprotocol/ai/proxy';
- * import { fastify as fastifyAdapter } from '@providerprotocol/ai/proxy/server';
- *
- * const app = Fastify();
- *
- * app.post('/api/ai', async (request, reply) => {
- *   const { messages, system, params } = parseBody(request.body);
- *   const instance = llm({ model: anthropic('claude-sonnet-4-20250514'), system });
- *
- *   if (request.headers.accept?.includes('text/event-stream')) {
- *     return fastifyAdapter.streamSSE(instance.stream(messages), reply);
- *   } else {
- *     const turn = await instance.generate(messages);
- *     return fastifyAdapter.sendJSON(turn, reply);
- *   }
- * });
- * ```
- *
  * @module providers/proxy/server/fastify
  */
 
@@ -256,6 +279,74 @@ declare function streamSSE$1(stream: StreamResult, reply: FastifyReply): Fastify
 declare function sendError$1(message: string, status: number, reply: FastifyReply): FastifyReply;
 /**
  * Fastify adapter utilities.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import Fastify from 'fastify';
+ * import { llm } from '@providerprotocol/ai';
+ * import { anthropic } from '@providerprotocol/ai/anthropic';
+ * import { parseBody } from '@providerprotocol/ai/proxy';
+ * import { fastify as fastifyAdapter } from '@providerprotocol/ai/proxy/server';
+ *
+ * const app = Fastify();
+ *
+ * app.post('/api/ai', async (request, reply) => {
+ *   const { messages, system, params } = parseBody(request.body);
+ *   const instance = llm({ model: anthropic('claude-sonnet-4-20250514'), system });
+ *
+ *   if (request.headers.accept?.includes('text/event-stream')) {
+ *     return fastifyAdapter.streamSSE(instance.stream(messages), reply);
+ *   } else {
+ *     const turn = await instance.generate(messages);
+ *     return fastifyAdapter.sendJSON(turn, reply);
+ *   }
+ * });
+ * ```
+ *
+ * @example API Gateway with authentication
+ * ```typescript
+ * import Fastify from 'fastify';
+ * import { llm } from '@providerprotocol/ai';
+ * import { anthropic } from '@providerprotocol/ai/anthropic';
+ * import { ExponentialBackoff, RoundRobinKeys } from '@providerprotocol/ai/http';
+ * import { parseBody } from '@providerprotocol/ai/proxy';
+ * import { fastify as fastifyAdapter } from '@providerprotocol/ai/proxy/server';
+ *
+ * const app = Fastify();
+ *
+ * // Server manages AI provider keys - users never see them
+ * const claude = llm({
+ *   model: anthropic('claude-sonnet-4-20250514'),
+ *   config: {
+ *     apiKey: new RoundRobinKeys([process.env.ANTHROPIC_KEY_1!, process.env.ANTHROPIC_KEY_2!]),
+ *     retryStrategy: new ExponentialBackoff({ maxAttempts: 3 }),
+ *   },
+ * });
+ *
+ * // Auth hook for your platform
+ * app.addHook('preHandler', async (request, reply) => {
+ *   const token = request.headers.authorization?.replace('Bearer ', '');
+ *   const user = await validatePlatformToken(token);
+ *   if (!user) {
+ *     reply.status(401).send({ error: 'Unauthorized' });
+ *     return;
+ *   }
+ *   request.user = user;
+ * });
+ *
+ * app.post('/api/ai', async (request, reply) => {
+ *   // Track usage per user
+ *   // await trackUsage(request.user.id);
+ *
+ *   const { messages, system, params } = parseBody(request.body);
+ *
+ *   if (params?.stream) {
+ *     return fastifyAdapter.streamSSE(claude.stream(messages, { system }), reply);
+ *   }
+ *   const turn = await claude.generate(messages, { system });
+ *   return fastifyAdapter.sendJSON(turn, reply);
+ * });
+ * ```
  */
 declare const fastify: {
     sendJSON: typeof sendJSON$1;
@@ -269,29 +360,6 @@ declare const fastify: {
  * Provides utilities for using PP proxy with Express.js or Connect-based servers.
  * These adapters convert PP types to Express-compatible responses.
  *
- * @example
- * ```typescript
- * import express from 'express';
- * import { llm, anthropic } from '@providerprotocol/ai';
- * import { parseBody, bindTools } from '@providerprotocol/ai/proxy';
- * import { express as expressAdapter } from '@providerprotocol/ai/proxy/server';
- *
- * const app = express();
- * app.use(express.json());
- *
- * app.post('/api/ai', async (req, res) => {
- *   const { messages, system, params } = parseBody(req.body);
- *   const instance = llm({ model: anthropic('claude-sonnet-4-20250514'), system });
- *
- *   if (req.headers.accept?.includes('text/event-stream')) {
- *     expressAdapter.streamSSE(instance.stream(messages), res);
- *   } else {
- *     const turn = await instance.generate(messages);
- *     expressAdapter.sendJSON(turn, res);
- *   }
- * });
- * ```
- *
  * @module providers/proxy/server/express
  */
 
@@ -341,6 +409,75 @@ declare function streamSSE(stream: StreamResult, res: ExpressResponse): void;
 declare function sendError(message: string, status: number, res: ExpressResponse): void;
 /**
  * Express adapter utilities.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import express from 'express';
+ * import { llm } from '@providerprotocol/ai';
+ * import { anthropic } from '@providerprotocol/ai/anthropic';
+ * import { parseBody } from '@providerprotocol/ai/proxy';
+ * import { express as expressAdapter } from '@providerprotocol/ai/proxy/server';
+ *
+ * const app = express();
+ * app.use(express.json());
+ *
+ * app.post('/api/ai', async (req, res) => {
+ *   const { messages, system, params } = parseBody(req.body);
+ *   const instance = llm({ model: anthropic('claude-sonnet-4-20250514'), system });
+ *
+ *   if (req.headers.accept?.includes('text/event-stream')) {
+ *     expressAdapter.streamSSE(instance.stream(messages), res);
+ *   } else {
+ *     const turn = await instance.generate(messages);
+ *     expressAdapter.sendJSON(turn, res);
+ *   }
+ * });
+ * ```
+ *
+ * @example API Gateway with authentication
+ * ```typescript
+ * import express from 'express';
+ * import { llm } from '@providerprotocol/ai';
+ * import { anthropic } from '@providerprotocol/ai/anthropic';
+ * import { ExponentialBackoff, RoundRobinKeys } from '@providerprotocol/ai/http';
+ * import { parseBody } from '@providerprotocol/ai/proxy';
+ * import { express as expressAdapter } from '@providerprotocol/ai/proxy/server';
+ *
+ * const app = express();
+ * app.use(express.json());
+ *
+ * // Your platform's auth middleware
+ * async function authMiddleware(req, res, next) {
+ *   const token = req.headers.authorization?.replace('Bearer ', '');
+ *   const user = await validatePlatformToken(token);
+ *   if (!user) return res.status(401).json({ error: 'Unauthorized' });
+ *   req.user = user;
+ *   next();
+ * }
+ *
+ * // Server manages AI provider keys - users never see them
+ * const claude = llm({
+ *   model: anthropic('claude-sonnet-4-20250514'),
+ *   config: {
+ *     apiKey: new RoundRobinKeys([process.env.ANTHROPIC_KEY_1!, process.env.ANTHROPIC_KEY_2!]),
+ *     retryStrategy: new ExponentialBackoff({ maxAttempts: 3 }),
+ *   },
+ * });
+ *
+ * app.post('/api/ai', authMiddleware, async (req, res) => {
+ *   // Track usage per user
+ *   // await trackUsage(req.user.id);
+ *
+ *   const { messages, system, params } = parseBody(req.body);
+ *
+ *   if (params?.stream) {
+ *     expressAdapter.streamSSE(claude.stream(messages, { system }), res);
+ *   } else {
+ *     const turn = await claude.generate(messages, { system });
+ *     expressAdapter.sendJSON(turn, res);
+ *   }
+ * });
+ * ```
  */
 declare const express: {
     sendJSON: typeof sendJSON;
@@ -357,23 +494,6 @@ declare const express: {
  * These utilities return standard Web API Response objects that work
  * directly with modern runtimes.
  *
- * @example
- * ```typescript
- * import { llm, anthropic } from '@providerprotocol/ai';
- * import { parseBody, toJSON, toSSE } from '@providerprotocol/ai/proxy';
- *
- * // Bun.serve / Deno.serve / Next.js App Router
- * export async function POST(req: Request) {
- *   const { messages, system } = parseBody(await req.json());
- *   const instance = llm({ model: anthropic('claude-sonnet-4-20250514'), system });
- *
- *   if (req.headers.get('accept')?.includes('text/event-stream')) {
- *     return toSSE(instance.stream(messages));
- *   }
- *   return toJSON(await instance.generate(messages));
- * }
- * ```
- *
  * @module providers/proxy/server/webapi
  */
 
@@ -473,6 +593,70 @@ declare function bindTools(schemas: ParsedRequest['tools'], implementations: Rec
  *
  * For use with Bun, Deno, Next.js App Router, Cloudflare Workers,
  * and other frameworks that support Web API Response.
+ *
+ * **Security Note:** The proxy works without configuration, meaning no
+ * authentication by default. Always add your own auth layer in production.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { llm } from '@providerprotocol/ai';
+ * import { anthropic } from '@providerprotocol/ai/anthropic';
+ * import { parseBody, toJSON, toSSE } from '@providerprotocol/ai/proxy';
+ *
+ * // Bun.serve / Deno.serve / Next.js App Router
+ * export async function POST(req: Request) {
+ *   const { messages, system } = parseBody(await req.json());
+ *   const instance = llm({ model: anthropic('claude-sonnet-4-20250514'), system });
+ *
+ *   if (req.headers.get('accept')?.includes('text/event-stream')) {
+ *     return toSSE(instance.stream(messages));
+ *   }
+ *   return toJSON(await instance.generate(messages));
+ * }
+ * ```
+ *
+ * @example API Gateway with authentication
+ * ```typescript
+ * import { llm } from '@providerprotocol/ai';
+ * import { anthropic } from '@providerprotocol/ai/anthropic';
+ * import { ExponentialBackoff, RoundRobinKeys } from '@providerprotocol/ai/http';
+ * import { parseBody, toJSON, toSSE, toError } from '@providerprotocol/ai/proxy';
+ *
+ * // Your platform's user validation
+ * async function validateToken(token: string): Promise<{ id: string } | null> {
+ *   // Verify JWT, check database, etc.
+ *   return token ? { id: 'user-123' } : null;
+ * }
+ *
+ * // Server manages AI provider keys - users never see them
+ * const claude = llm({
+ *   model: anthropic('claude-sonnet-4-20250514'),
+ *   config: {
+ *     apiKey: new RoundRobinKeys([process.env.ANTHROPIC_KEY_1!, process.env.ANTHROPIC_KEY_2!]),
+ *     retryStrategy: new ExponentialBackoff({ maxAttempts: 3 }),
+ *   },
+ * });
+ *
+ * Bun.serve({
+ *   port: 3000,
+ *   async fetch(req) {
+ *     // Authenticate with YOUR platform credentials
+ *     const token = req.headers.get('Authorization')?.replace('Bearer ', '');
+ *     const user = await validateToken(token ?? '');
+ *     if (!user) return toError('Unauthorized', 401);
+ *
+ *     // Rate limit, track usage, bill user, etc.
+ *     // await trackUsage(user.id);
+ *
+ *     const { messages, system, params } = parseBody(await req.json());
+ *
+ *     if (params?.stream) {
+ *       return toSSE(claude.stream(messages, { system }));
+ *     }
+ *     return toJSON(await claude.generate(messages, { system }));
+ *   },
+ * });
+ * ```
  */
 declare const webapi: {
     parseBody: typeof parseBody;
@@ -532,6 +716,46 @@ interface AdapterOptions {
  * Server adapters namespace.
  *
  * Contains framework-specific adapters for Web API, Express, Fastify, and H3.
+ *
+ * @example Express
+ * ```typescript
+ * import { express } from '@providerprotocol/ai/proxy/server';
+ *
+ * app.post('/api/ai', async (req, res) => {
+ *   const { messages } = parseBody(req.body);
+ *   if (req.headers.accept?.includes('text/event-stream')) {
+ *     express.streamSSE(instance.stream(messages), res);
+ *   } else {
+ *     express.sendJSON(await instance.generate(messages), res);
+ *   }
+ * });
+ * ```
+ *
+ * @example Fastify
+ * ```typescript
+ * import { fastify } from '@providerprotocol/ai/proxy/server';
+ *
+ * app.post('/api/ai', async (request, reply) => {
+ *   const { messages } = parseBody(request.body);
+ *   if (request.headers.accept?.includes('text/event-stream')) {
+ *     return fastify.streamSSE(instance.stream(messages), reply);
+ *   }
+ *   return fastify.sendJSON(await instance.generate(messages), reply);
+ * });
+ * ```
+ *
+ * @example H3/Nuxt
+ * ```typescript
+ * import { h3 } from '@providerprotocol/ai/proxy/server';
+ *
+ * export default defineEventHandler(async (event) => {
+ *   const { messages } = parseBody(await readBody(event));
+ *   if (getHeader(event, 'accept')?.includes('text/event-stream')) {
+ *     return h3.streamSSE(instance.stream(messages), event);
+ *   }
+ *   return h3.sendJSON(await instance.generate(messages), event);
+ * });
+ * ```
  */
 declare const server: {
     /** Web API adapter (Bun, Deno, Next.js, Workers) */