@providerprotocol/ai 0.0.34 → 0.0.35

package/dist/proxy/server/fastify/index.d.ts

@@ -0,0 +1,162 @@
+import { T as Turn, i as StreamResult } from '../../../stream-CecfVCPO.js';
+import { d as EmbeddingResult } from '../../../embedding-CW6SaOOz.js';
+import { N as ImageResult } from '../../../llm-DwbUK7un.js';
+import { I as ImageStreamLike } from '../../../image-stream-C0ciACM2.js';
+
+/**
+ * @fileoverview Fastify adapter for proxy server.
+ *
+ * Provides utilities for using PP proxy with Fastify servers.
+ * These adapters convert PP types to Fastify-compatible responses.
+ *
+ * @module providers/proxy/server/fastify
+ */
+
+/**
+ * Fastify Reply interface (minimal type to avoid dependency).
+ */
+interface FastifyReply {
+    header(name: string, value: string): FastifyReply;
+    status(code: number): FastifyReply;
+    send(payload: unknown): FastifyReply;
+    raw: {
+        write(chunk: string): boolean;
+        end(): void;
+    };
+}
+/**
+ * Send a Turn as JSON response.
+ *
+ * @param turn - The completed inference turn
+ * @param reply - Fastify reply object
+ *
+ * @example
+ * ```typescript
+ * const turn = await instance.generate(messages);
+ * return fastifyAdapter.sendJSON(turn, reply);
+ * ```
+ */
+declare function sendJSON(turn: Turn, reply: FastifyReply): FastifyReply;
+/**
+ * Send an EmbeddingResult as JSON response.
+ *
+ * @param result - The embedding result
+ * @param reply - Fastify reply object
+ */
+declare function sendEmbeddingJSON(result: EmbeddingResult, reply: FastifyReply): FastifyReply;
+/**
+ * Send an ImageResult as JSON response.
+ *
+ * @param result - The image result
+ * @param reply - Fastify reply object
+ */
+declare function sendImageJSON(result: ImageResult, reply: FastifyReply): FastifyReply;
+/**
+ * Stream a StreamResult as Server-Sent Events.
+ *
+ * @param stream - The StreamResult from instance.stream()
+ * @param reply - Fastify reply object
+ *
+ * @example
+ * ```typescript
+ * const stream = instance.stream(messages);
+ * return fastifyAdapter.streamSSE(stream, reply);
+ * ```
+ */
+declare function streamSSE(stream: StreamResult, reply: FastifyReply): FastifyReply;
+/**
+ * Stream an ImageStreamResult as Server-Sent Events.
+ *
+ * @param stream - The ImageStreamResult or ImageProviderStreamResult from image().stream()
+ * @param reply - Fastify reply object
+ */
+declare function streamImageSSE(stream: ImageStreamLike, reply: FastifyReply): FastifyReply;
+/**
+ * Send an error response.
+ *
+ * @param message - Error message
+ * @param status - HTTP status code
+ * @param reply - Fastify reply object
+ */
+declare function sendError(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;
+    sendEmbeddingJSON: typeof sendEmbeddingJSON;
+    sendImageJSON: typeof sendImageJSON;
+    streamSSE: typeof streamSSE;
+    streamImageSSE: typeof streamImageSSE;
+    sendError: typeof sendError;
+};
+
+export { fastify, sendEmbeddingJSON, sendError, sendImageJSON, sendJSON, streamImageSSE, streamSSE };

package/dist/proxy/server/fastify/index.js

@@ -0,0 +1,24 @@
+import {
+  fastify,
+  sendEmbeddingJSON,
+  sendError,
+  sendImageJSON,
+  sendJSON,
+  streamImageSSE,
+  streamSSE
+} from "../../../chunk-UFFJDYCE.js";
+import "../../../chunk-C4JP64VW.js";
+import "../../../chunk-ETBFOLQN.js";
+import "../../../chunk-N5DX5JW3.js";
+import "../../../chunk-BRP5XJ6Q.js";
+import "../../../chunk-COS4ON4G.js";
+export {
+  fastify,
+  sendEmbeddingJSON,
+  sendError,
+  sendImageJSON,
+  sendJSON,
+  streamImageSSE,
+  streamSSE
+};
+//# sourceMappingURL=index.js.map

package/dist/proxy/server/fastify/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/proxy/server/h3/index.d.ts

@@ -0,0 +1,189 @@
+import { T as Turn, i as StreamResult } from '../../../stream-CecfVCPO.js';
+import { d as EmbeddingResult } from '../../../embedding-CW6SaOOz.js';
+import { N as ImageResult } from '../../../llm-DwbUK7un.js';
+import { I as ImageStreamLike } from '../../../image-stream-C0ciACM2.js';
+
+/**
+ * @fileoverview H3/Nitro/Nuxt adapter for proxy server.
+ *
+ * Provides utilities for using PP proxy with H3-based servers
+ * (Nuxt, Nitro, or standalone H3).
+ *
+ * @module providers/proxy/server/h3
+ */
+
+/**
+ * H3 Event interface (minimal type to avoid dependency).
+ */
+interface H3Event {
+    node: {
+        res: {
+            setHeader(name: string, value: string): void;
+            write(chunk: string): boolean;
+            end(): void;
+        };
+    };
+}
+/**
+ * Send a Turn as JSON response.
+ *
+ * @param turn - The completed inference turn
+ * @param event - H3 event object
+ * @returns Serialized turn data
+ *
+ * @example
+ * ```typescript
+ * const turn = await instance.generate(messages);
+ * return h3Adapter.sendJSON(turn, event);
+ * ```
+ */
+declare function sendJSON(turn: Turn, event: H3Event): unknown;
+/**
+ * Send an EmbeddingResult as JSON response.
+ *
+ * @param result - The embedding result
+ * @param event - H3 event object
+ * @returns Serialized result data
+ */
+declare function sendEmbeddingJSON(result: EmbeddingResult, event: H3Event): unknown;
+/**
+ * Send an ImageResult as JSON response.
+ *
+ * @param result - The image result
+ * @param event - H3 event object
+ * @returns Serialized image result data
+ */
+declare function sendImageJSON(result: ImageResult, event: H3Event): unknown;
+/**
+ * Stream a StreamResult as Server-Sent Events.
+ *
+ * @param stream - The StreamResult from instance.stream()
+ * @param event - H3 event object
+ *
+ * @example
+ * ```typescript
+ * const stream = instance.stream(messages);
+ * return h3Adapter.streamSSE(stream, event);
+ * ```
+ */
+declare function streamSSE(stream: StreamResult, event: H3Event): void;
+/**
+ * Stream an ImageStreamResult as Server-Sent Events.
+ *
+ * @param stream - The ImageStreamResult or ImageProviderStreamResult from image().stream()
+ * @param event - H3 event object
+ */
+declare function streamImageSSE(stream: ImageStreamLike, event: H3Event): void;
+/**
+ * Create a ReadableStream for H3's sendStream utility.
+ *
+ * Use this with H3's sendStream for better integration:
+ * ```typescript
+ * import { sendStream } from 'h3';
+ * return sendStream(event, h3Adapter.createSSEStream(stream));
+ * ```
+ *
+ * @param stream - The StreamResult from instance.stream()
+ * @returns A ReadableStream of SSE data
+ */
+declare function createSSEStream(stream: StreamResult): ReadableStream<Uint8Array>;
+/**
+ * Create a ReadableStream for image SSE data.
+ *
+ * @param stream - The ImageStreamResult or ImageProviderStreamResult from image().stream()
+ * @returns A ReadableStream of SSE data
+ */
+declare function createImageSSEStream(stream: ImageStreamLike): ReadableStream<Uint8Array>;
+/**
+ * Send an error response.
+ *
+ * @param message - Error message
+ * @param status - HTTP status code
+ * @param event - H3 event object
+ * @returns Error object for H3 to serialize
+ */
+declare function sendError(message: string, status: number, event: H3Event): {
+    error: string;
+    statusCode: number;
+};
+/**
+ * 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;
+    sendEmbeddingJSON: typeof sendEmbeddingJSON;
+    sendImageJSON: typeof sendImageJSON;
+    streamSSE: typeof streamSSE;
+    streamImageSSE: typeof streamImageSSE;
+    createSSEStream: typeof createSSEStream;
+    createImageSSEStream: typeof createImageSSEStream;
+    sendError: typeof sendError;
+};
+
+export { createImageSSEStream, createSSEStream, h3, sendEmbeddingJSON, sendError, sendImageJSON, sendJSON, streamImageSSE, streamSSE };

package/dist/proxy/server/h3/index.js

@@ -0,0 +1,28 @@
+import {
+  createImageSSEStream,
+  createSSEStream,
+  h3,
+  sendEmbeddingJSON,
+  sendError,
+  sendImageJSON,
+  sendJSON,
+  streamImageSSE,
+  streamSSE
+} from "../../../chunk-4OGB7JZA.js";
+import "../../../chunk-C4JP64VW.js";
+import "../../../chunk-ETBFOLQN.js";
+import "../../../chunk-N5DX5JW3.js";
+import "../../../chunk-BRP5XJ6Q.js";
+import "../../../chunk-COS4ON4G.js";
+export {
+  createImageSSEStream,
+  createSSEStream,
+  h3,
+  sendEmbeddingJSON,
+  sendError,
+  sendImageJSON,
+  sendJSON,
+  streamImageSSE,
+  streamSSE
+};
+//# sourceMappingURL=index.js.map

package/dist/proxy/server/h3/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/proxy/server/index.d.ts

@@ -0,0 +1,151 @@
+import { sendJSON as sendJSON$2, sendEmbeddingJSON as sendEmbeddingJSON$2, sendImageJSON as sendImageJSON$2, streamSSE as streamSSE$2, streamImageSSE as streamImageSSE$2, createSSEStream, createImageSSEStream, sendError as sendError$2 } from './h3/index.js';
+export { h3 } from './h3/index.js';
+import { sendJSON as sendJSON$1, sendEmbeddingJSON as sendEmbeddingJSON$1, sendImageJSON as sendImageJSON$1, streamSSE as streamSSE$1, streamImageSSE as streamImageSSE$1, sendError as sendError$1 } from './fastify/index.js';
+export { fastify } from './fastify/index.js';
+import { sendJSON, sendEmbeddingJSON, sendImageJSON, streamSSE, streamImageSSE, sendError } from './express/index.js';
+export { express } from './express/index.js';
+import { parseBody, parseEmbeddingBody, parseImageBody, toJSON, toEmbeddingJSON, toImageJSON, toSSE, toImageSSE, toError, bindTools } from './webapi/index.js';
+export { ParsedEmbeddingRequest, ParsedImageRequest, ParsedRequest, webapi } from './webapi/index.js';
+import { M as Message, J as JSONSchema, H as ToolMetadata, T as Turn, i as StreamResult } from '../../stream-CecfVCPO.js';
+import '../../embedding-CW6SaOOz.js';
+import '../../llm-DwbUK7un.js';
+import '../../image-stream-C0ciACM2.js';
+
+/**
+ * @fileoverview Shared types for proxy server adapters.
+ *
+ * @module providers/proxy/server/types
+ */
+
+/**
+ * Parsed request body from a proxy HTTP request.
+ */
+interface ParsedBody {
+    messages: Message[];
+    system?: string | unknown[];
+    params?: Record<string, unknown>;
+    model?: string;
+    tools?: Array<{
+        name: string;
+        description: string;
+        parameters: JSONSchema;
+        metadata?: ToolMetadata;
+    }>;
+    structure?: JSONSchema;
+}
+/**
+ * Handler function signature for proxy endpoints.
+ * Takes parsed request data and returns either a Turn or StreamResult.
+ */
+type ProxyHandler = (body: ParsedBody, meta: RequestMeta) => Promise<Turn> | StreamResult | Promise<StreamResult>;
+/**
+ * Metadata about the incoming request.
+ */
+interface RequestMeta {
+    /** Whether the client wants a streaming response */
+    wantsStream: boolean;
+    /** Raw headers from the request */
+    headers: Record<string, string | undefined>;
+}
+/**
+ * Options for adapter middleware.
+ */
+interface AdapterOptions {
+    /** Custom error handler */
+    onError?: (error: Error) => {
+        message: string;
+        status: number;
+    };
+}
+
+/**
+ * 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) */
+    webapi: {
+        parseBody: typeof parseBody;
+        parseEmbeddingBody: typeof parseEmbeddingBody;
+        parseImageBody: typeof parseImageBody;
+        toJSON: typeof toJSON;
+        toEmbeddingJSON: typeof toEmbeddingJSON;
+        toImageJSON: typeof toImageJSON;
+        toSSE: typeof toSSE;
+        toImageSSE: typeof toImageSSE;
+        toError: typeof toError;
+        bindTools: typeof bindTools;
+    };
+    /** Express/Connect adapter */
+    express: {
+        sendJSON: typeof sendJSON;
+        sendEmbeddingJSON: typeof sendEmbeddingJSON;
+        sendImageJSON: typeof sendImageJSON;
+        streamSSE: typeof streamSSE;
+        streamImageSSE: typeof streamImageSSE;
+        sendError: typeof sendError;
+    };
+    /** Fastify adapter */
+    fastify: {
+        sendJSON: typeof sendJSON$1;
+        sendEmbeddingJSON: typeof sendEmbeddingJSON$1;
+        sendImageJSON: typeof sendImageJSON$1;
+        streamSSE: typeof streamSSE$1;
+        streamImageSSE: typeof streamImageSSE$1;
+        sendError: typeof sendError$1;
+    };
+    /** H3/Nitro/Nuxt adapter */
+    h3: {
+        sendJSON: typeof sendJSON$2;
+        sendEmbeddingJSON: typeof sendEmbeddingJSON$2;
+        sendImageJSON: typeof sendImageJSON$2;
+        streamSSE: typeof streamSSE$2;
+        streamImageSSE: typeof streamImageSSE$2;
+        createSSEStream: typeof createSSEStream;
+        createImageSSEStream: typeof createImageSSEStream;
+        sendError: typeof sendError$2;
+    };
+};
+
+export { type AdapterOptions, type ParsedBody, type ProxyHandler, type RequestMeta, bindTools, parseBody, parseEmbeddingBody, parseImageBody, server, toEmbeddingJSON, toError, toImageJSON, toImageSSE, toJSON, toSSE };

package/dist/proxy/server/index.js

@@ -0,0 +1,48 @@
+import {
+  server
+} from "../../chunk-IDZOVWP3.js";
+import {
+  fastify
+} from "../../chunk-UFFJDYCE.js";
+import {
+  bindTools,
+  parseBody,
+  parseEmbeddingBody,
+  parseImageBody,
+  toEmbeddingJSON,
+  toError,
+  toImageJSON,
+  toImageSSE,
+  toJSON,
+  toSSE,
+  webapi
+} from "../../chunk-VGKZIGVI.js";
+import {
+  express
+} from "../../chunk-OIEWDFQU.js";
+import {
+  h3
+} from "../../chunk-4OGB7JZA.js";
+import "../../chunk-C4JP64VW.js";
+import "../../chunk-ETBFOLQN.js";
+import "../../chunk-N5DX5JW3.js";
+import "../../chunk-BRP5XJ6Q.js";
+import "../../chunk-COS4ON4G.js";
+export {
+  bindTools,
+  express,
+  fastify,
+  h3,
+  parseBody,
+  parseEmbeddingBody,
+  parseImageBody,
+  server,
+  toEmbeddingJSON,
+  toError,
+  toImageJSON,
+  toImageSSE,
+  toJSON,
+  toSSE,
+  webapi
+};
+//# sourceMappingURL=index.js.map

package/dist/proxy/server/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}