@providerprotocol/ai 0.0.11 → 0.0.12

package/src/http/retry.ts

@@ -1,205 +0,0 @@
-import type { RetryStrategy } from '../types/provider.ts';
-import type { UPPError } from '../types/errors.ts';
-
-/**
- * Exponential backoff retry strategy
- */
-export class ExponentialBackoff implements RetryStrategy {
-  private maxAttempts: number;
-  private baseDelay: number;
-  private maxDelay: number;
-  private jitter: boolean;
-
-  constructor(options: {
-    maxAttempts?: number;
-    baseDelay?: number;
-    maxDelay?: number;
-    jitter?: boolean;
-  } = {}) {
-    this.maxAttempts = options.maxAttempts ?? 3;
-    this.baseDelay = options.baseDelay ?? 1000;
-    this.maxDelay = options.maxDelay ?? 30000;
-    this.jitter = options.jitter ?? true;
-  }
-
-  onRetry(error: UPPError, attempt: number): number | null {
-    if (attempt > this.maxAttempts) {
-      return null;
-    }
-
-    // Only retry on retryable errors
-    if (!this.isRetryable(error)) {
-      return null;
-    }
-
-    // Calculate delay with exponential backoff
-    let delay = this.baseDelay * Math.pow(2, attempt - 1);
-    delay = Math.min(delay, this.maxDelay);
-
-    // Add jitter
-    if (this.jitter) {
-      delay = delay * (0.5 + Math.random());
-    }
-
-    return Math.floor(delay);
-  }
-
-  private isRetryable(error: UPPError): boolean {
-    return (
-      error.code === 'RATE_LIMITED' ||
-      error.code === 'NETWORK_ERROR' ||
-      error.code === 'TIMEOUT' ||
-      error.code === 'PROVIDER_ERROR'
-    );
-  }
-}
-
-/**
- * Linear backoff retry strategy
- */
-export class LinearBackoff implements RetryStrategy {
-  private maxAttempts: number;
-  private delay: number;
-
-  constructor(options: {
-    maxAttempts?: number;
-    delay?: number;
-  } = {}) {
-    this.maxAttempts = options.maxAttempts ?? 3;
-    this.delay = options.delay ?? 1000;
-  }
-
-  onRetry(error: UPPError, attempt: number): number | null {
-    if (attempt > this.maxAttempts) {
-      return null;
-    }
-
-    // Only retry on retryable errors
-    if (!this.isRetryable(error)) {
-      return null;
-    }
-
-    return this.delay * attempt;
-  }
-
-  private isRetryable(error: UPPError): boolean {
-    return (
-      error.code === 'RATE_LIMITED' ||
-      error.code === 'NETWORK_ERROR' ||
-      error.code === 'TIMEOUT' ||
-      error.code === 'PROVIDER_ERROR'
-    );
-  }
-}
-
-/**
- * No retry strategy - fail immediately
- */
-export class NoRetry implements RetryStrategy {
-  onRetry(): null {
-    return null;
-  }
-}
-
-/**
- * Token bucket rate limiter with retry
- */
-export class TokenBucket implements RetryStrategy {
-  private tokens: number;
-  private maxTokens: number;
-  private refillRate: number; // tokens per second
-  private lastRefill: number;
-  private maxAttempts: number;
-
-  constructor(options: {
-    maxTokens?: number;
-    refillRate?: number;
-    maxAttempts?: number;
-  } = {}) {
-    this.maxTokens = options.maxTokens ?? 10;
-    this.refillRate = options.refillRate ?? 1;
-    this.maxAttempts = options.maxAttempts ?? 3;
-    this.tokens = this.maxTokens;
-    this.lastRefill = Date.now();
-  }
-
-  beforeRequest(): number {
-    this.refill();
-
-    if (this.tokens >= 1) {
-      this.tokens -= 1;
-      return 0;
-    }
-
-    // Calculate time until next token
-    const msPerToken = 1000 / this.refillRate;
-    return Math.ceil(msPerToken);
-  }
-
-  onRetry(error: UPPError, attempt: number): number | null {
-    if (attempt > this.maxAttempts) {
-      return null;
-    }
-
-    if (error.code !== 'RATE_LIMITED') {
-      return null;
-    }
-
-    // Wait for token bucket to refill
-    const msPerToken = 1000 / this.refillRate;
-    return Math.ceil(msPerToken * 2); // Wait for 2 tokens
-  }
-
-  reset(): void {
-    this.tokens = this.maxTokens;
-    this.lastRefill = Date.now();
-  }
-
-  private refill(): void {
-    const now = Date.now();
-    const elapsed = (now - this.lastRefill) / 1000;
-    const newTokens = elapsed * this.refillRate;
-
-    this.tokens = Math.min(this.maxTokens, this.tokens + newTokens);
-    this.lastRefill = now;
-  }
-}
-
-/**
- * Retry strategy that respects Retry-After headers
- */
-export class RetryAfterStrategy implements RetryStrategy {
-  private maxAttempts: number;
-  private fallbackDelay: number;
-  private lastRetryAfter?: number;
-
-  constructor(options: {
-    maxAttempts?: number;
-    fallbackDelay?: number;
-  } = {}) {
-    this.maxAttempts = options.maxAttempts ?? 3;
-    this.fallbackDelay = options.fallbackDelay ?? 5000;
-  }
-
-  /**
-   * Set the Retry-After value from response headers
-   * Call this before onRetry when you have a Retry-After header
-   */
-  setRetryAfter(seconds: number): void {
-    this.lastRetryAfter = seconds * 1000;
-  }
-
-  onRetry(error: UPPError, attempt: number): number | null {
-    if (attempt > this.maxAttempts) {
-      return null;
-    }
-
-    if (error.code !== 'RATE_LIMITED') {
-      return null;
-    }
-
-    const delay = this.lastRetryAfter ?? this.fallbackDelay;
-    this.lastRetryAfter = undefined;
-    return delay;
-  }
-}

package/src/http/sse.ts

@@ -1,136 +0,0 @@
-/**
- * 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

@@ -1,32 +0,0 @@
-// 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/ollama/index.ts

@@ -1,3 +0,0 @@
-// Re-export from providers/ollama
-export { ollama } from '../providers/ollama/index.ts';
-export type { OllamaLLMParams } from '../providers/ollama/index.ts';

package/src/openai/index.ts

@@ -1,39 +0,0 @@
-// Re-export from providers/openai
-export {
-  openai,
-  tools,
-  webSearchTool,
-  fileSearchTool,
-  codeInterpreterTool,
-  computerTool,
-  imageGenerationTool,
-  mcpTool,
-} from '../providers/openai/index.ts';
-export type {
-  OpenAICompletionsParams,
-  OpenAIResponsesParams,
-  OpenAIConfig,
-  OpenAIAPIMode,
-  OpenAIModelOptions,
-  OpenAIModelReference,
-  // Audio and web search types
-  OpenAIAudioConfig,
-  OpenAIWebSearchOptions,
-  OpenAIWebSearchUserLocation,
-  OpenAICompletionsWebSearchUserLocation,
-  // Built-in tool types
-  OpenAIBuiltInTool,
-  OpenAIWebSearchTool,
-  OpenAIFileSearchTool,
-  OpenAICodeInterpreterTool,
-  OpenAICodeInterpreterContainer,
-  OpenAIComputerTool,
-  OpenAIComputerEnvironment,
-  OpenAIImageGenerationTool,
-  OpenAIMcpTool,
-  OpenAIMcpServerConfig,
-  OpenAIResponsesToolUnion,
-  // Conversation and prompt types
-  OpenAIConversation,
-  OpenAIPromptTemplate,
-} from '../providers/openai/index.ts';

package/src/openrouter/index.ts

@@ -1,11 +0,0 @@
-// Re-export from providers/openrouter
-export { openrouter } from '../providers/openrouter/index.ts';
-export type {
-  OpenRouterCompletionsParams,
-  OpenRouterResponsesParams,
-  OpenRouterConfig,
-  OpenRouterAPIMode,
-  OpenRouterModelOptions,
-  OpenRouterModelReference,
-  OpenRouterProviderPreferences,
-} from '../providers/openrouter/index.ts';

package/src/providers/anthropic/index.ts

@@ -1,17 +0,0 @@
-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

@@ -1,196 +0,0 @@
-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;
-    },
-  };
-}