@providerprotocol/ai 0.0.10 → 0.0.12

package/src/providers/google/types.ts

@@ -1,214 +0,0 @@
-/**
- * Google Gemini-specific LLM parameters
- */
-export interface GoogleLLMParams {
-  /** Maximum number of tokens to generate */
-  maxOutputTokens?: number;
-
-  /** Temperature for randomness (0.0 - 2.0) */
-  temperature?: number;
-
-  /** Top-p (nucleus) sampling */
-  topP?: number;
-
-  /** Top-k sampling */
-  topK?: number;
-
-  /** Stop sequences */
-  stopSequences?: string[];
-
-  /** Number of candidates to generate */
-  candidateCount?: number;
-
-  /** Response MIME type */
-  responseMimeType?: 'text/plain' | 'application/json';
-
-  /** Response schema for structured output */
-  responseSchema?: Record<string, unknown>;
-
-  /**
-   * Presence penalty for new topics
-   * Positive values encourage discussing new topics
-   */
-  presencePenalty?: number;
-
-  /**
-   * Frequency penalty for repeated tokens
-   * Positive values discourage repetition
-   */
-  frequencyPenalty?: number;
-
-  /**
-   * Seed for deterministic sampling
-   * Same seed with same parameters should produce same results
-   */
-  seed?: number;
-
-  /**
-   * Whether to return log probabilities in response
-   */
-  responseLogprobs?: boolean;
-
-  /**
-   * Number of log probabilities to return (requires responseLogprobs: true)
-   */
-  logprobs?: number;
-
-  /**
-   * Whether to include audio timestamps in response
-   */
-  audioTimestamp?: boolean;
-
-  /**
-   * Thinking/reasoning configuration for Gemini 3+ models
-   */
-  thinkingConfig?: GoogleThinkingConfig;
-}
-
-/**
- * Thinking configuration for Gemini 3+ models
- */
-export interface GoogleThinkingConfig {
-  /** Whether thinking is enabled */
-  thinkingBudget?: number;
-}
-
-/**
- * Google API request body
- */
-export interface GoogleRequest {
-  contents: GoogleContent[];
-  systemInstruction?: {
-    parts: GooglePart[];
-  };
-  generationConfig?: {
-    maxOutputTokens?: number;
-    temperature?: number;
-    topP?: number;
-    topK?: number;
-    stopSequences?: string[];
-    candidateCount?: number;
-    responseMimeType?: string;
-    responseSchema?: Record<string, unknown>;
-    presencePenalty?: number;
-    frequencyPenalty?: number;
-    seed?: number;
-    responseLogprobs?: boolean;
-    logprobs?: number;
-    audioTimestamp?: boolean;
-    thinkingConfig?: GoogleThinkingConfig;
-  };
-  tools?: GoogleTool[];
-  safetySettings?: GoogleSafetySetting[];
-}
-
-/**
- * Google content (message) format
- */
-export interface GoogleContent {
-  role: 'user' | 'model';
-  parts: GooglePart[];
-}
-
-/**
- * Google content part types
- */
-export type GooglePart =
-  | GoogleTextPart
-  | GoogleImagePart
-  | GoogleFunctionCallPart
-  | GoogleFunctionResponsePart;
-
-export interface GoogleTextPart {
-  text: string;
-}
-
-export interface GoogleImagePart {
-  inlineData: {
-    mimeType: string;
-    data: string;
-  };
-}
-
-export interface GoogleFunctionCallPart {
-  functionCall: {
-    name: string;
-    args: Record<string, unknown>;
-  };
-  /** Gemini 3+ thought signature for multi-turn tool calls */
-  thoughtSignature?: string;
-}
-
-export interface GoogleFunctionResponsePart {
-  functionResponse: {
-    name: string;
-    response: Record<string, unknown>;
-  };
-}
-
-/**
- * Google tool format
- */
-export interface GoogleTool {
-  functionDeclarations: GoogleFunctionDeclaration[];
-}
-
-export interface GoogleFunctionDeclaration {
-  name: string;
-  description: string;
-  parameters: {
-    type: 'object';
-    properties: Record<string, unknown>;
-    required?: string[];
-  };
-}
-
-/**
- * Google safety setting
- */
-export interface GoogleSafetySetting {
-  category: string;
-  threshold: string;
-}
-
-/**
- * Google response format
- */
-export interface GoogleResponse {
-  candidates: GoogleCandidate[];
-  usageMetadata?: {
-    promptTokenCount: number;
-    candidatesTokenCount: number;
-    totalTokenCount: number;
-  };
-}
-
-export interface GoogleCandidate {
-  content: {
-    role: 'model';
-    parts: GoogleResponsePart[];
-  };
-  finishReason: 'STOP' | 'MAX_TOKENS' | 'SAFETY' | 'RECITATION' | 'OTHER' | 'TOOL_USE' | null;
-  index: number;
-  safetyRatings?: GoogleSafetyRating[];
-}
-
-export type GoogleResponsePart = GoogleTextPart | GoogleFunctionCallPart;
-
-export interface GoogleSafetyRating {
-  category: string;
-  probability: string;
-}
-
-/**
- * Google streaming response chunk
- * Same structure as regular response but may be partial
- */
-export interface GoogleStreamChunk {
-  candidates?: GoogleCandidate[];
-  usageMetadata?: {
-    promptTokenCount: number;
-    candidatesTokenCount: number;
-    totalTokenCount: number;
-  };
-}

package/src/providers/ollama/index.ts

@@ -1,43 +0,0 @@
-import { createProvider } from '../../core/provider.ts';
-import { createLLMHandler } from './llm.ts';
-
-/**
- * Ollama provider
- * Supports LLM modality with local Ollama models
- *
- * Ollama is a local LLM server that supports many open-source models including:
- * - Llama 3.x
- * - Mistral
- * - Mixtral
- * - Gemma
- * - Qwen
- * - DeepSeek
- * - Phi
- * - And many more
- *
- * @example
- * ```ts
- * import { llm } from 'provider-protocol';
- * import { ollama } from 'provider-protocol/ollama';
- *
- * const model = llm(ollama('llama3.2'));
- * const result = await model.generate('Hello, how are you?');
- * ```
- *
- * @example Custom server URL
- * ```ts
- * const model = llm(ollama('llama3.2'), {
- *   baseUrl: 'http://my-ollama-server:11434',
- * });
- * ```
- */
-export const ollama = createProvider({
-  name: 'ollama',
-  version: '1.0.0',
-  modalities: {
-    llm: createLLMHandler(),
-  },
-});
-
-// Re-export types
-export type { OllamaLLMParams } from './types.ts';

package/src/providers/ollama/llm.ts

@@ -1,272 +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 { normalizeHttpError } from '../../http/errors.ts';
-import type { OllamaLLMParams, OllamaResponse, OllamaStreamChunk } from './types.ts';
-import {
-  transformRequest,
-  transformResponse,
-  transformStreamChunk,
-  createStreamState,
-  buildResponseFromState,
-} from './transform.ts';
-
-const OLLAMA_DEFAULT_URL = 'http://localhost:11434';
-
-/**
- * Ollama API capabilities
- * Note: Tool calling is disabled - Ollama recommends using their
- * OpenAI-compatible API (/v1/chat/completions) for tool calling.
- * Use the OpenAI provider with baseUrl pointed to Ollama for tools.
- */
-const OLLAMA_CAPABILITIES: LLMCapabilities = {
-  streaming: true,
-  tools: false,
-  structuredOutput: true,
-  imageInput: true,
-  videoInput: false,
-  audioInput: false,
-};
-
-/**
- * Parse Ollama's newline-delimited JSON stream
- */
-async function* parseOllamaStream(
-  body: ReadableStream<Uint8Array>
-): AsyncGenerator<OllamaStreamChunk, void, unknown> {
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = '';
-
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-
-      buffer += decoder.decode(value, { stream: true });
-
-      // Process complete lines (Ollama uses newline-delimited JSON)
-      const lines = buffer.split('\n');
-      buffer = lines.pop() ?? ''; // Keep incomplete line in buffer
-
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed) continue;
-
-        try {
-          const chunk = JSON.parse(trimmed) as OllamaStreamChunk;
-          yield chunk;
-        } catch {
-          // Skip invalid JSON lines
-        }
-      }
-    }
-
-    // Process any remaining buffer
-    if (buffer.trim()) {
-      try {
-        const chunk = JSON.parse(buffer.trim()) as OllamaStreamChunk;
-        yield chunk;
-      } catch {
-        // Skip invalid JSON
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-}
-
-/**
- * Create Ollama LLM handler
- */
-export function createLLMHandler(): LLMHandler<OllamaLLMParams> {
-  // Provider reference injected by createProvider() after construction
-  let providerRef: LLMProvider<OllamaLLMParams> | null = null;
-
-  return {
-    _setProvider(provider: LLMProvider<OllamaLLMParams>) {
-      providerRef = provider;
-    },
-
-    bind(modelId: string): BoundLLMModel<OllamaLLMParams> {
-      // 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',
-          'ollama',
-          'llm'
-        );
-      }
-
-      const model: BoundLLMModel<OllamaLLMParams> = {
-        modelId,
-        capabilities: OLLAMA_CAPABILITIES,
-
-        get provider(): LLMProvider<OllamaLLMParams> {
-          return providerRef!;
-        },
-
-        async complete(request: LLMRequest<OllamaLLMParams>): Promise<LLMResponse> {
-          // Ollama doesn't require an API key by default, but may use one for auth
-          let apiKey: string | undefined;
-          try {
-            apiKey = await resolveApiKey(
-              request.config,
-              'OLLAMA_API_KEY',
-              'ollama',
-              'llm'
-            );
-          } catch {
-            // API key is optional for Ollama
-          }
-
-          const baseUrl = request.config.baseUrl ?? OLLAMA_DEFAULT_URL;
-          const url = `${baseUrl}/api/chat`;
-          const body = transformRequest(request, modelId);
-          body.stream = false;
-
-          const headers: Record<string, string> = {
-            'Content-Type': 'application/json',
-          };
-
-          if (apiKey) {
-            headers['Authorization'] = `Bearer ${apiKey}`;
-          }
-
-          const response = await doFetch(
-            url,
-            {
-              method: 'POST',
-              headers,
-              body: JSON.stringify(body),
-              signal: request.signal,
-            },
-            request.config,
-            'ollama',
-            'llm'
-          );
-
-          const data = (await response.json()) as OllamaResponse;
-          return transformResponse(data);
-        },
-
-        stream(request: LLMRequest<OllamaLLMParams>): 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 {
-              // Ollama doesn't require an API key by default
-              let apiKey: string | undefined;
-              try {
-                apiKey = await resolveApiKey(
-                  request.config,
-                  'OLLAMA_API_KEY',
-                  'ollama',
-                  'llm'
-                );
-              } catch {
-                // API key is optional for Ollama
-              }
-
-              const baseUrl = request.config.baseUrl ?? OLLAMA_DEFAULT_URL;
-              const url = `${baseUrl}/api/chat`;
-              const body = transformRequest(request, modelId);
-              body.stream = true;
-
-              const headers: Record<string, string> = {
-                'Content-Type': 'application/json',
-              };
-
-              if (apiKey) {
-                headers['Authorization'] = `Bearer ${apiKey}`;
-              }
-
-              const response = await doStreamFetch(
-                url,
-                {
-                  method: 'POST',
-                  headers,
-                  body: JSON.stringify(body),
-                  signal: request.signal,
-                },
-                request.config,
-                'ollama',
-                'llm'
-              );
-
-              if (!response.ok) {
-                const error = await normalizeHttpError(response, 'ollama', 'llm');
-                responseReject(error);
-                throw error;
-              }
-
-              if (!response.body) {
-                const error = new UPPError(
-                  'No response body for streaming request',
-                  'PROVIDER_ERROR',
-                  'ollama',
-                  'llm'
-                );
-                responseReject(error);
-                throw error;
-              }
-
-              // Parse Ollama's newline-delimited JSON stream
-              for await (const chunk of parseOllamaStream(response.body)) {
-                // Check for error in chunk
-                if ('error' in chunk && typeof (chunk as Record<string, unknown>).error === 'string') {
-                  const error = new UPPError(
-                    (chunk as Record<string, unknown>).error as string,
-                    'PROVIDER_ERROR',
-                    'ollama',
-                    'llm'
-                  );
-                  responseReject(error);
-                  throw error;
-                }
-
-                const events = transformStreamChunk(chunk, state);
-                for (const event of events) {
-                  yield event;
-                }
-              }
-
-              // Build final response
-              responseResolve(buildResponseFromState(state));
-            } catch (error) {
-              responseReject(error as Error);
-              throw error;
-            }
-          }
-
-          return {
-            [Symbol.asyncIterator]() {
-              return generateEvents();
-            },
-            response: responsePromise,
-          };
-        },
-      };
-
-      return model;
-    },
-  };
-}