@providerprotocol/ai 0.0.19 → 0.0.21

package/dist/proxy/index.d.ts

@@ -1,6 +1,5 @@
-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';
+import { g as Provider, M as ModelReference } from '../provider-DGQHYE6I.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-Di9acos2.js';
 
 /**
  * @fileoverview Proxy provider types.
@@ -149,10 +148,11 @@ declare function sendError$2(message: string, status: number, event: H3Event): {
 /**
  * H3/Nitro/Nuxt adapter utilities.
  *
- * @example
+ * @example Basic usage
  * ```typescript
  * // Nuxt server route: server/api/ai.post.ts
- * import { llm, anthropic } from '@providerprotocol/ai';
+ * 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';
  *
@@ -170,6 +170,49 @@ declare function sendError$2(message: string, status: number, event: H3Event): {
  *   }
  * });
  * ```
+ *
+ * @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;
@@ -236,10 +279,11 @@ declare function sendError$1(message: string, status: number, reply: FastifyRepl
 /**
  * Fastify adapter utilities.
  *
- * @example
+ * @example Basic usage
  * ```typescript
  * import Fastify from 'fastify';
- * import { llm, anthropic } from '@providerprotocol/ai';
+ * 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';
  *
@@ -257,6 +301,51 @@ declare function sendError$1(message: string, status: number, reply: FastifyRepl
  *   }
  * });
  * ```
+ *
+ * @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;
@@ -320,11 +409,12 @@ declare function sendError(message: string, status: number, res: ExpressResponse
 /**
  * Express adapter utilities.
  *
- * @example
+ * @example Basic usage
  * ```typescript
  * import express from 'express';
- * import { llm, anthropic } from '@providerprotocol/ai';
- * import { parseBody, bindTools } from '@providerprotocol/ai/proxy';
+ * 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();
@@ -342,6 +432,51 @@ declare function sendError(message: string, status: number, res: ExpressResponse
  *   }
  * });
  * ```
+ *
+ * @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;
@@ -458,9 +593,13 @@ 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.
  *
- * @example
+ * **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, anthropic } from '@providerprotocol/ai';
+ * 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
@@ -474,6 +613,49 @@ declare function bindTools(schemas: ParsedRequest['tools'], implementations: Rec
  *   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;

package/dist/proxy/index.js

@@ -1,17 +1,18 @@
 import {
   emptyUsage
 } from "../chunk-SKY2JLA7.js";
-import {
-  createProvider
-} from "../chunk-MSR5P65T.js";
 import {
   AssistantMessage,
   ToolResultMessage,
-  UserMessage
-} from "../chunk-UMKWXGO3.js";
+  UserMessage,
+  createProvider
+} from "../chunk-M4BMM5IB.js";
 import {
-  UPPError
-} from "../chunk-DZQHVGNV.js";
+  UPPError,
+  doFetch,
+  doStreamFetch,
+  normalizeHttpError
+} from "../chunk-EDENPF3E.js";
 
 // src/providers/proxy/serialization.ts
 function serializeMessage(m) {
@@ -98,12 +99,7 @@ var PROXY_CAPABILITIES = {
   audioInput: true
 };
 function createLLMHandler(options) {
-  const {
-    endpoint,
-    headers: defaultHeaders = {},
-    fetch: customFetch = fetch,
-    timeout = 12e4
-  } = options;
+  const { endpoint, headers: defaultHeaders = {} } = options;
   let providerRef = null;
   return {
     _setProvider(provider) {
@@ -127,10 +123,9 @@ function createLLMHandler(options) {
         async complete(request) {
           const body = serializeRequest(request);
           const headers = mergeHeaders(request.config.headers, defaultHeaders);
-          const controller = new AbortController();
-          const timeoutId = setTimeout(() => controller.abort(), timeout);
-          try {
-            const response = await customFetch(endpoint, {
+          const response = await doFetch(
+            endpoint,
+            {
               method: "POST",
               headers: {
                 ...headers,
@@ -138,30 +133,18 @@ function createLLMHandler(options) {
                 Accept: "application/json"
               },
               body: JSON.stringify(body),
-              signal: request.signal ? combineSignals(request.signal, controller.signal) : controller.signal
-            });
-            clearTimeout(timeoutId);
-            if (!response.ok) {
-              const text = await response.text();
-              throw new UPPError(
-                text || `HTTP ${response.status}`,
-                "PROVIDER_ERROR",
-                "proxy",
-                "llm"
-              );
-            }
-            const data = await response.json();
-            return turnJSONToLLMResponse(data);
-          } catch (error) {
-            clearTimeout(timeoutId);
-            throw error;
-          }
+              signal: request.signal
+            },
+            request.config,
+            "proxy",
+            "llm"
+          );
+          const data = await response.json();
+          return turnJSONToLLMResponse(data);
         },
         stream(request) {
           const body = serializeRequest(request);
           const headers = mergeHeaders(request.config.headers, defaultHeaders);
-          const controller = new AbortController();
-          const timeoutId = setTimeout(() => controller.abort(), timeout);
           let resolveResponse;
           let rejectResponse;
           const responsePromise = new Promise((resolve, reject) => {
@@ -170,25 +153,24 @@ function createLLMHandler(options) {
           });
           const generator = async function* () {
             try {
-              const response = await customFetch(endpoint, {
-                method: "POST",
-                headers: {
-                  ...headers,
-                  "Content-Type": "application/json",
-                  Accept: "text/event-stream"
+              const response = await doStreamFetch(
+                endpoint,
+                {
+                  method: "POST",
+                  headers: {
+                    ...headers,
+                    "Content-Type": "application/json",
+                    Accept: "text/event-stream"
+                  },
+                  body: JSON.stringify(body),
+                  signal: request.signal
                 },
-                body: JSON.stringify(body),
-                signal: request.signal ? combineSignals(request.signal, controller.signal) : controller.signal
-              });
-              clearTimeout(timeoutId);
+                request.config,
+                "proxy",
+                "llm"
+              );
               if (!response.ok) {
-                const text = await response.text();
-                throw new UPPError(
-                  text || `HTTP ${response.status}`,
-                  "PROVIDER_ERROR",
-                  "proxy",
-                  "llm"
-                );
+                throw await normalizeHttpError(response, "proxy", "llm");
               }
               if (!response.body) {
                 throw new UPPError(
@@ -274,16 +256,6 @@ function turnJSONToLLMResponse(data) {
     data: data.data
   };
 }
-function combineSignals(signal1, signal2) {
-  const controller = new AbortController();
-  const onAbort = () => controller.abort();
-  signal1.addEventListener("abort", onAbort);
-  signal2.addEventListener("abort", onAbort);
-  if (signal1.aborted || signal2.aborted) {
-    controller.abort();
-  }
-  return controller.signal;
-}
 
 // src/providers/proxy/server/express.ts
 function sendJSON(turn, res) {
@@ -535,7 +507,7 @@ function proxy(options) {
   return createProvider({
     name: "proxy",
     version: "1.0.0",
-    modalities: {
+    handlers: {
       llm: createLLMHandler(options)
     }
   });