@providerprotocol/ai 0.0.34 → 0.0.35

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

@@ -0,0 +1,278 @@
+import { M as Message, J as JSONSchema, H as ToolMetadata, T as Turn, i as StreamResult, d as Tool } from '../../../stream-CecfVCPO.js';
+import { n as Image, E as EmbeddingInput, N as ImageResult } from '../../../llm-DwbUK7un.js';
+import { d as EmbeddingResult } from '../../../embedding-CW6SaOOz.js';
+import { I as ImageStreamLike } from '../../../image-stream-C0ciACM2.js';
+
+/**
+ * @fileoverview Media serialization utilities for proxy transport.
+ *
+ * Handles converting embedding inputs and image results/events to/from JSON
+ * for HTTP transport. These are pure functions with no side effects.
+ *
+ * @module providers/proxy/serialization.media
+ */
+
+type SerializedImageSource = {
+    type: 'base64';
+    data: string;
+} | {
+    type: 'url';
+    url: string;
+} | {
+    type: 'bytes';
+    data: number[] | string;
+};
+interface SerializedImage {
+    source: SerializedImageSource;
+    mimeType: string;
+    width?: number;
+    height?: number;
+}
+/**
+ * Deserialize an Image from JSON transport.
+ */
+declare function deserializeImage(image: SerializedImage): Image;
+
+/**
+ * @fileoverview Web API adapter for proxy server.
+ *
+ * Provides utilities for using PP proxy with Web API native frameworks
+ * (Bun, Deno, Next.js App Router, Cloudflare Workers).
+ *
+ * These utilities return standard Web API Response objects that work
+ * directly with modern runtimes.
+ *
+ * @module providers/proxy/server/webapi
+ */
+
+/**
+ * Parsed request body from a proxy HTTP request.
+ * This is just the deserialized PP data from the request body.
+ */
+interface ParsedRequest {
+    messages: Message[];
+    system?: string | unknown[];
+    params?: Record<string, unknown>;
+    model?: string;
+    tools?: Array<{
+        name: string;
+        description: string;
+        parameters: JSONSchema;
+        metadata?: ToolMetadata;
+    }>;
+    structure?: JSONSchema;
+}
+/**
+ * Parsed request body for embedding endpoints.
+ */
+interface ParsedEmbeddingRequest {
+    inputs: EmbeddingInput[];
+    params?: Record<string, unknown>;
+    model?: string;
+}
+/**
+ * Parsed request body for image endpoints.
+ */
+interface ParsedImageRequest {
+    prompt: string;
+    params?: Record<string, unknown>;
+    model?: string;
+    image?: ReturnType<typeof deserializeImage>;
+    mask?: ReturnType<typeof deserializeImage>;
+}
+/**
+ * Parse an HTTP request body into PP types.
+ *
+ * @param body - The JSON-parsed request body
+ * @returns Deserialized PP data
+ *
+ * @example
+ * ```typescript
+ * const body = await req.json();
+ * const { messages, system, params } = parseBody(body);
+ *
+ * const instance = llm({ model: anthropic('...'), system, params });
+ * const turn = await instance.generate(messages);
+ * ```
+ */
+declare function parseBody(body: unknown): ParsedRequest;
+/**
+ * Parse an HTTP request body into embedding inputs.
+ *
+ * @param body - The JSON-parsed request body
+ * @returns Parsed embedding request data
+ */
+declare function parseEmbeddingBody(body: unknown): ParsedEmbeddingRequest;
+/**
+ * Parse an HTTP request body into image request data.
+ *
+ * @param body - The JSON-parsed request body
+ * @returns Parsed image request data
+ */
+declare function parseImageBody(body: unknown): ParsedImageRequest;
+/**
+ * Create a JSON Response from a Turn.
+ *
+ * @param turn - The completed inference turn
+ * @returns HTTP Response with JSON body
+ *
+ * @example
+ * ```typescript
+ * const turn = await instance.generate(messages);
+ * return toJSON(turn);
+ * ```
+ */
+declare function toJSON(turn: Turn): Response;
+/**
+ * Create a JSON Response from an embedding result.
+ *
+ * @param result - The embedding result
+ * @returns HTTP Response with JSON body
+ */
+declare function toEmbeddingJSON(result: EmbeddingResult): Response;
+/**
+ * Create a JSON Response from an image result.
+ *
+ * @param result - The image result
+ * @returns HTTP Response with JSON body
+ */
+declare function toImageJSON(result: ImageResult): Response;
+/**
+ * Create an SSE Response from a StreamResult.
+ *
+ * Streams PP StreamEvents as SSE, then sends the final Turn data.
+ *
+ * @param stream - The StreamResult from instance.stream()
+ * @returns HTTP Response with SSE body
+ *
+ * @example
+ * ```typescript
+ * const stream = instance.stream(messages);
+ * return toSSE(stream);
+ * ```
+ */
+declare function toSSE(stream: StreamResult): Response;
+/**
+ * Create an SSE Response from an ImageStreamResult.
+ *
+ * Streams image events as SSE, then sends the final image result.
+ *
+ * @param stream - The ImageStreamResult or ImageProviderStreamResult from image().stream()
+ * @returns HTTP Response with SSE body
+ */
+declare function toImageSSE(stream: ImageStreamLike): Response;
+/**
+ * Create an error Response.
+ *
+ * @param message - Error message
+ * @param status - HTTP status code (default: 500)
+ * @returns HTTP Response with error body
+ */
+declare function toError(message: string, status?: number): Response;
+/**
+ * Bind tool schemas to implementation functions.
+ *
+ * Takes tool schemas from the request and binds them to your
+ * server-side implementations.
+ *
+ * @param schemas - Tool schemas from the request
+ * @param implementations - Map of tool name to implementation
+ * @returns Array of complete Tool objects
+ *
+ * @example
+ * ```typescript
+ * const { tools: schemas } = parseBody(body);
+ *
+ * const tools = bindTools(schemas, {
+ *   get_weather: async ({ location }) => fetchWeather(location),
+ *   search: async ({ query }) => searchDB(query),
+ * });
+ *
+ * const instance = llm({ model, tools });
+ * ```
+ */
+declare function bindTools(schemas: ParsedRequest['tools'], implementations: Record<string, (params: unknown) => unknown | Promise<unknown>>): Tool[];
+/**
+ * Web API adapter utilities.
+ *
+ * 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;
+    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;
+};
+
+export { type ParsedEmbeddingRequest, type ParsedImageRequest, type ParsedRequest, bindTools, parseBody, parseEmbeddingBody, parseImageBody, toEmbeddingJSON, toError, toImageJSON, toImageSSE, toJSON, toSSE, webapi };

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

@@ -0,0 +1,32 @@
+import {
+  bindTools,
+  parseBody,
+  parseEmbeddingBody,
+  parseImageBody,
+  toEmbeddingJSON,
+  toError,
+  toImageJSON,
+  toImageSSE,
+  toJSON,
+  toSSE,
+  webapi
+} from "../../../chunk-VGKZIGVI.js";
+import "../../../chunk-C4JP64VW.js";
+import "../../../chunk-ETBFOLQN.js";
+import "../../../chunk-N5DX5JW3.js";
+import "../../../chunk-BRP5XJ6Q.js";
+import "../../../chunk-COS4ON4G.js";
+export {
+  bindTools,
+  parseBody,
+  parseEmbeddingBody,
+  parseImageBody,
+  toEmbeddingJSON,
+  toError,
+  toImageJSON,
+  toImageSSE,
+  toJSON,
+  toSSE,
+  webapi
+};
+//# sourceMappingURL=index.js.map

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

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