@providerprotocol/ai 0.0.1

package/src/http/sse.ts

@@ -0,0 +1,136 @@
+/**
+ * Server-Sent Events (SSE) stream parser
+ */
+
+/**
+ * Parse a Server-Sent Events stream into JSON objects
+ * Handles standard SSE format with "data:" prefix
+ * Yields parsed JSON for each event
+ * Terminates on "[DONE]" message (OpenAI style)
+ *
+ * @param body - ReadableStream from fetch response
+ */
+export async function* parseSSEStream(
+  body: ReadableStream<Uint8Array>
+): AsyncGenerator<unknown, void, unknown> {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+
+      if (done) {
+        // Process any remaining data in buffer
+        if (buffer.trim()) {
+          const event = parseSSEEvent(buffer);
+          if (event !== null && event !== undefined) {
+            yield event;
+          }
+        }
+        break;
+      }
+
+      buffer += decoder.decode(value, { stream: true });
+
+      // Process complete events (separated by double newlines or \r\n\r\n)
+      const events = buffer.split(/\r?\n\r?\n/);
+
+      // Keep the last partial event in the buffer
+      buffer = events.pop() ?? '';
+
+      for (const eventText of events) {
+        if (!eventText.trim()) continue;
+
+        const event = parseSSEEvent(eventText);
+        if (event === 'DONE') {
+          return;
+        }
+        if (event !== null && event !== undefined) {
+          yield event;
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+/**
+ * Parse a single SSE event
+ * Returns 'DONE' for [DONE] terminator
+ * Returns null for empty or unparseable events
+ * Returns parsed JSON otherwise
+ */
+function parseSSEEvent(eventText: string): unknown | 'DONE' | null {
+  const lines = eventText.split('\n');
+  let data = '';
+  let eventType = '';
+
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+    if (trimmedLine.startsWith('event:')) {
+      eventType = trimmedLine.slice(6).trim();
+    } else if (trimmedLine.startsWith('data:')) {
+      // Append data (some providers send multi-line data)
+      const lineData = trimmedLine.slice(5).trim();
+      data += (data ? '\n' : '') + lineData;
+    } else if (trimmedLine.startsWith(':')) {
+      // Comment line, ignore (often used for keep-alive)
+      continue;
+    } else if (trimmedLine.startsWith('{') || trimmedLine.startsWith('[')) {
+      // Some providers (like Google) may send raw JSON without data: prefix
+      data += (data ? '\n' : '') + trimmedLine;
+    }
+  }
+
+  if (!data) {
+    return null;
+  }
+
+  // Check for OpenAI-style termination
+  if (data === '[DONE]') {
+    return 'DONE';
+  }
+
+  try {
+    const parsed = JSON.parse(data);
+
+    // If we have an event type, include it
+    if (eventType) {
+      return { _eventType: eventType, ...parsed };
+    }
+
+    return parsed;
+  } catch {
+    // Failed to parse JSON - could be a ping or malformed event
+    return null;
+  }
+}
+
+/**
+ * Create a simple SSE reader that handles basic text streaming
+ * For providers that just stream text deltas
+ */
+export async function* parseSimpleTextStream(
+  body: ReadableStream<Uint8Array>
+): AsyncGenerator<string, void, unknown> {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+
+      if (done) break;
+
+      const text = decoder.decode(value, { stream: true });
+      if (text) {
+        yield text;
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}

package/src/index.ts

@@ -0,0 +1,32 @@
+// Core entry points
+export { llm } from './core/llm.ts';
+export { createProvider } from './core/provider.ts';
+export { Image } from './core/image.ts';
+
+// Namespace object for alternative import style
+import { llm } from './core/llm.ts';
+
+/**
+ * UPP namespace object
+ * Provides ai.llm(), ai.embedding(), ai.image() style access
+ */
+export const ai = {
+  llm,
+  // embedding, // Coming soon
+  // image,     // Coming soon
+};
+
+// Re-export all types from types/index.ts
+export * from './types/index.ts';
+
+// Re-export HTTP utilities
+export {
+  RoundRobinKeys,
+  WeightedKeys,
+  DynamicKey,
+  ExponentialBackoff,
+  LinearBackoff,
+  NoRetry,
+  TokenBucket,
+  RetryAfterStrategy,
+} from './http/index.ts';

package/src/openai/index.ts

@@ -0,0 +1,9 @@
+// Re-export from providers/openai
+export { openai } from '../providers/openai/index.ts';
+export type {
+  OpenAILLMParams,
+  OpenAIConfig,
+  OpenAIAPIMode,
+  OpenAIModelOptions,
+  OpenAIModelReference,
+} from '../providers/openai/index.ts';

package/src/providers/anthropic/index.ts

@@ -0,0 +1,17 @@
+import { createProvider } from '../../core/provider.ts';
+import { createLLMHandler } from './llm.ts';
+
+/**
+ * Anthropic provider
+ * Supports LLM modality with Claude models
+ */
+export const anthropic = createProvider({
+  name: 'anthropic',
+  version: '1.0.0',
+  modalities: {
+    llm: createLLMHandler(),
+  },
+});
+
+// Re-export types
+export type { AnthropicLLMParams } from './types.ts';

package/src/providers/anthropic/llm.ts

@@ -0,0 +1,196 @@
+import type { LLMHandler, BoundLLMModel, LLMRequest, LLMResponse, LLMStreamResult, LLMCapabilities } from '../../types/llm.ts';
+import type { StreamEvent } from '../../types/stream.ts';
+import type { LLMProvider } from '../../types/provider.ts';
+import { UPPError } from '../../types/errors.ts';
+import { resolveApiKey } from '../../http/keys.ts';
+import { doFetch, doStreamFetch } from '../../http/fetch.ts';
+import { parseSSEStream } from '../../http/sse.ts';
+import { normalizeHttpError } from '../../http/errors.ts';
+import type { AnthropicLLMParams, AnthropicResponse, AnthropicStreamEvent } from './types.ts';
+import {
+  transformRequest,
+  transformResponse,
+  transformStreamEvent,
+  createStreamState,
+  buildResponseFromState,
+} from './transform.ts';
+
+const ANTHROPIC_API_URL = 'https://api.anthropic.com/v1/messages';
+const ANTHROPIC_VERSION = '2023-06-01';
+
+/**
+ * Anthropic API capabilities
+ */
+const ANTHROPIC_CAPABILITIES: LLMCapabilities = {
+  streaming: true,
+  tools: true,
+  structuredOutput: true,
+  imageInput: true,
+  videoInput: false,
+  audioInput: false,
+};
+
+/**
+ * Create Anthropic LLM handler
+ */
+export function createLLMHandler(): LLMHandler<AnthropicLLMParams> {
+  // Provider reference injected by createProvider() after construction
+  let providerRef: LLMProvider<AnthropicLLMParams> | null = null;
+
+  return {
+    _setProvider(provider: LLMProvider<AnthropicLLMParams>) {
+      providerRef = provider;
+    },
+
+    bind(modelId: string): BoundLLMModel<AnthropicLLMParams> {
+      // Use the injected provider reference (set by createProvider)
+      if (!providerRef) {
+        throw new UPPError(
+          'Provider reference not set. Handler must be used with createProvider().',
+          'INVALID_REQUEST',
+          'anthropic',
+          'llm'
+        );
+      }
+
+      const model: BoundLLMModel<AnthropicLLMParams> = {
+        modelId,
+        capabilities: ANTHROPIC_CAPABILITIES,
+
+        get provider(): LLMProvider<AnthropicLLMParams> {
+          return providerRef!;
+        },
+
+        async complete(request: LLMRequest<AnthropicLLMParams>): Promise<LLMResponse> {
+          const apiKey = await resolveApiKey(
+            request.config,
+            'ANTHROPIC_API_KEY',
+            'anthropic',
+            'llm'
+          );
+
+          const baseUrl = request.config.baseUrl ?? ANTHROPIC_API_URL;
+          const body = transformRequest(request, modelId);
+
+          const response = await doFetch(
+            baseUrl,
+            {
+              method: 'POST',
+              headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': apiKey,
+                'anthropic-version': request.config.apiVersion ?? ANTHROPIC_VERSION,
+              },
+              body: JSON.stringify(body),
+              signal: request.signal,
+            },
+            request.config,
+            'anthropic',
+            'llm'
+          );
+
+          const data = (await response.json()) as AnthropicResponse;
+          return transformResponse(data);
+        },
+
+        stream(request: LLMRequest<AnthropicLLMParams>): LLMStreamResult {
+          const state = createStreamState();
+          let responseResolve: (value: LLMResponse) => void;
+          let responseReject: (error: Error) => void;
+
+          const responsePromise = new Promise<LLMResponse>((resolve, reject) => {
+            responseResolve = resolve;
+            responseReject = reject;
+          });
+
+          async function* generateEvents(): AsyncGenerator<StreamEvent, void, unknown> {
+            try {
+              const apiKey = await resolveApiKey(
+                request.config,
+                'ANTHROPIC_API_KEY',
+                'anthropic',
+                'llm'
+              );
+
+              const baseUrl = request.config.baseUrl ?? ANTHROPIC_API_URL;
+              const body = transformRequest(request, modelId);
+              body.stream = true;
+
+              const response = await doStreamFetch(
+                baseUrl,
+                {
+                  method: 'POST',
+                  headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': apiKey,
+                    'anthropic-version': request.config.apiVersion ?? ANTHROPIC_VERSION,
+                  },
+                  body: JSON.stringify(body),
+                  signal: request.signal,
+                },
+                request.config,
+                'anthropic',
+                'llm'
+              );
+
+              if (!response.ok) {
+                const error = await normalizeHttpError(response, 'anthropic', 'llm');
+                responseReject(error);
+                throw error;
+              }
+
+              if (!response.body) {
+                const error = new UPPError(
+                  'No response body for streaming request',
+                  'PROVIDER_ERROR',
+                  'anthropic',
+                  'llm'
+                );
+                responseReject(error);
+                throw error;
+              }
+
+              for await (const data of parseSSEStream(response.body)) {
+                // Check for Anthropic error event
+                if (typeof data === 'object' && data !== null && 'type' in data) {
+                  const event = data as AnthropicStreamEvent;
+
+                  if (event.type === 'error') {
+                    const error = new UPPError(
+                      event.error.message,
+                      'PROVIDER_ERROR',
+                      'anthropic',
+                      'llm'
+                    );
+                    responseReject(error);
+                    throw error;
+                  }
+
+                  const uppEvent = transformStreamEvent(event, state);
+                  if (uppEvent) {
+                    yield uppEvent;
+                  }
+                }
+              }
+
+              // Build final response
+              responseResolve(buildResponseFromState(state));
+            } catch (error) {
+              responseReject(error as Error);
+              throw error;
+            }
+          }
+
+          return {
+            [Symbol.asyncIterator]() {
+              return generateEvents();
+            },
+            response: responsePromise,
+          };
+        },
+      };
+
+      return model;
+    },
+  };
+}