@providerprotocol/ai 0.0.10 → 0.0.12

package/src/providers/ollama/transform.ts

@@ -1,434 +0,0 @@
-import type { LLMRequest, LLMResponse } from '../../types/llm.ts';
-import type { Message } from '../../types/messages.ts';
-import type { StreamEvent } from '../../types/stream.ts';
-import type { Tool, ToolCall } from '../../types/tool.ts';
-import type { TokenUsage } from '../../types/turn.ts';
-import type { ContentBlock, TextBlock, ImageBlock } from '../../types/content.ts';
-import {
-  AssistantMessage,
-  isUserMessage,
-  isAssistantMessage,
-  isToolResultMessage,
-} from '../../types/messages.ts';
-import type {
-  OllamaLLMParams,
-  OllamaRequest,
-  OllamaMessage,
-  OllamaTool,
-  OllamaResponse,
-  OllamaStreamChunk,
-  OllamaToolCall,
-  OllamaOptions,
-} from './types.ts';
-
-/**
- * Transform UPP request to Ollama format
- *
- * Params are spread to allow pass-through of any Ollama API fields,
- * even those not explicitly defined in our type. This enables developers to
- * use new API features without waiting for library updates.
- *
- * Note: Ollama uses nested 'options' for model parameters. Params that belong
- * in options (like temperature, top_p, etc.) are spread into options, while
- * top-level params (like keep_alive, think) are spread at the request level.
- */
-export function transformRequest<TParams extends OllamaLLMParams>(
-  request: LLMRequest<TParams>,
-  modelId: string
-): OllamaRequest {
-  const params = (request.params ?? {}) as OllamaLLMParams;
-
-  // Extract top-level params vs options params
-  const {
-    keep_alive,
-    think,
-    logprobs,
-    top_logprobs,
-    ...optionsParams
-  } = params;
-
-  // Spread params to pass through all fields, then set required fields
-  const ollamaRequest: OllamaRequest = {
-    model: modelId,
-    messages: transformMessages(request.messages, request.system),
-  };
-
-  // Add top-level params if provided
-  if (keep_alive !== undefined) ollamaRequest.keep_alive = keep_alive;
-  if (think !== undefined) ollamaRequest.think = think;
-  if (logprobs !== undefined) ollamaRequest.logprobs = logprobs;
-  if (top_logprobs !== undefined) ollamaRequest.top_logprobs = top_logprobs;
-
-  // Spread remaining params into options to pass through all model parameters
-  if (Object.keys(optionsParams).length > 0) {
-    ollamaRequest.options = optionsParams as OllamaOptions;
-  }
-
-  // Tools come from request, not params
-  if (request.tools && request.tools.length > 0) {
-    ollamaRequest.tools = request.tools.map(transformTool);
-  }
-
-  // Structured output via format field
-  if (request.structure) {
-    ollamaRequest.format = request.structure as unknown as Record<string, unknown>;
-  }
-
-  return ollamaRequest;
-}
-
-/**
- * Transform UPP Messages to Ollama messages
- */
-function transformMessages(messages: Message[], system?: string): OllamaMessage[] {
-  const ollamaMessages: OllamaMessage[] = [];
-
-  // System prompt as first message
-  if (system) {
-    ollamaMessages.push({
-      role: 'system',
-      content: system,
-    });
-  }
-
-  for (const msg of messages) {
-    if (isUserMessage(msg)) {
-      const textContent: string[] = [];
-      const images: string[] = [];
-
-      for (const block of msg.content) {
-        if (block.type === 'text') {
-          textContent.push(block.text);
-        } else if (block.type === 'image') {
-          const imageBlock = block as ImageBlock;
-          if (imageBlock.source.type === 'base64') {
-            images.push(imageBlock.source.data);
-          } else if (imageBlock.source.type === 'bytes') {
-            // Convert bytes to base64
-            const base64 = btoa(
-              Array.from(imageBlock.source.data)
-                .map((b) => String.fromCharCode(b))
-                .join('')
-            );
-            images.push(base64);
-          } else if (imageBlock.source.type === 'url') {
-            // Ollama doesn't support URL images directly
-            // Would need to fetch and convert, for now just add as text
-            textContent.push(`[Image: ${imageBlock.source.url}]`);
-          }
-        }
-      }
-
-      const message: OllamaMessage = {
-        role: 'user',
-        content: textContent.join('\n'),
-      };
-
-      if (images.length > 0) {
-        message.images = images;
-      }
-
-      ollamaMessages.push(message);
-    } else if (isAssistantMessage(msg)) {
-      const textContent = msg.content
-        .filter((block): block is TextBlock => block.type === 'text')
-        .map((block) => block.text)
-        .join('\n');
-
-      const message: OllamaMessage = {
-        role: 'assistant',
-        content: textContent,
-      };
-
-      // Add tool calls if present
-      if (msg.toolCalls && msg.toolCalls.length > 0) {
-        message.tool_calls = msg.toolCalls.map((call) => ({
-          function: {
-            name: call.toolName,
-            arguments: call.arguments,
-          },
-        }));
-      }
-
-      ollamaMessages.push(message);
-    } else if (isToolResultMessage(msg)) {
-      // Tool results are sent as 'tool' role messages
-      for (const result of msg.results) {
-        ollamaMessages.push({
-          role: 'tool',
-          tool_name: result.toolCallId, // In our UPP, toolCallId maps to tool name for Ollama
-          content:
-            typeof result.result === 'string'
-              ? result.result
-              : JSON.stringify(result.result),
-        });
-      }
-    }
-  }
-
-  return ollamaMessages;
-}
-
-/**
- * Transform a UPP Tool to Ollama format
- */
-function transformTool(tool: Tool): OllamaTool {
-  return {
-    type: 'function',
-    function: {
-      name: tool.name,
-      description: tool.description,
-      parameters: {
-        type: 'object',
-        properties: tool.parameters.properties,
-        required: tool.parameters.required,
-      },
-    },
-  };
-}
-
-/**
- * Transform Ollama response to UPP LLMResponse
- */
-export function transformResponse(data: OllamaResponse): LLMResponse {
-  const textContent: TextBlock[] = [];
-  const toolCalls: ToolCall[] = [];
-  let structuredData: unknown;
-
-  // Add main content
-  if (data.message.content) {
-    textContent.push({ type: 'text', text: data.message.content });
-
-    // Try to parse as JSON for structured output
-    try {
-      structuredData = JSON.parse(data.message.content);
-    } catch {
-      // Not valid JSON - that's fine, might not be structured output
-    }
-  }
-
-  // Extract tool calls
-  if (data.message.tool_calls) {
-    for (const call of data.message.tool_calls) {
-      toolCalls.push({
-        toolCallId: call.function.name, // Ollama doesn't have separate IDs, use name
-        toolName: call.function.name,
-        arguments: call.function.arguments,
-      });
-    }
-  }
-
-  const message = new AssistantMessage(
-    textContent,
-    toolCalls.length > 0 ? toolCalls : undefined,
-    {
-      metadata: {
-        ollama: {
-          model: data.model,
-          created_at: data.created_at,
-          done_reason: data.done_reason,
-          thinking: data.message.thinking,
-          total_duration: data.total_duration,
-          load_duration: data.load_duration,
-          prompt_eval_duration: data.prompt_eval_duration,
-          eval_duration: data.eval_duration,
-          logprobs: data.logprobs,
-        },
-      },
-    }
-  );
-
-  // Calculate token usage
-  const usage: TokenUsage = {
-    inputTokens: data.prompt_eval_count ?? 0,
-    outputTokens: data.eval_count ?? 0,
-    totalTokens: (data.prompt_eval_count ?? 0) + (data.eval_count ?? 0),
-  };
-
-  // Map done_reason to standard stop reason
-  let stopReason = 'end_turn';
-  if (data.done_reason === 'length') {
-    stopReason = 'max_tokens';
-  } else if (data.done_reason === 'stop') {
-    stopReason = 'end_turn';
-  } else if (toolCalls.length > 0) {
-    stopReason = 'tool_use';
-  }
-
-  return {
-    message,
-    usage,
-    stopReason,
-    data: structuredData,
-  };
-}
-
-/**
- * State for accumulating streaming response
- */
-export interface StreamState {
-  model: string;
-  content: string;
-  thinking: string;
-  toolCalls: Array<{ name: string; args: Record<string, unknown> }>;
-  doneReason: string | null;
-  promptEvalCount: number;
-  evalCount: number;
-  totalDuration: number;
-  isFirstChunk: boolean;
-  createdAt: string;
-}
-
-/**
- * Create initial stream state
- */
-export function createStreamState(): StreamState {
-  return {
-    model: '',
-    content: '',
-    thinking: '',
-    toolCalls: [],
-    doneReason: null,
-    promptEvalCount: 0,
-    evalCount: 0,
-    totalDuration: 0,
-    isFirstChunk: true,
-    createdAt: '',
-  };
-}
-
-/**
- * Transform Ollama stream chunk to UPP StreamEvents
- */
-export function transformStreamChunk(
-  chunk: OllamaStreamChunk,
-  state: StreamState
-): StreamEvent[] {
-  const events: StreamEvent[] = [];
-
-  // First chunk - emit message start
-  if (state.isFirstChunk) {
-    state.model = chunk.model;
-    state.createdAt = chunk.created_at;
-    events.push({ type: 'message_start', index: 0, delta: {} });
-    state.isFirstChunk = false;
-  }
-
-  // Process message content
-  if (chunk.message) {
-    // Text content delta
-    if (chunk.message.content) {
-      state.content += chunk.message.content;
-      events.push({
-        type: 'text_delta',
-        index: 0,
-        delta: { text: chunk.message.content },
-      });
-    }
-
-    // Thinking content delta
-    if (chunk.message.thinking) {
-      state.thinking += chunk.message.thinking;
-      events.push({
-        type: 'reasoning_delta',
-        index: 0,
-        delta: { text: chunk.message.thinking },
-      });
-    }
-
-    // Tool calls (typically come in final chunk)
-    if (chunk.message.tool_calls) {
-      for (const call of chunk.message.tool_calls) {
-        state.toolCalls.push({
-          name: call.function.name,
-          args: call.function.arguments,
-        });
-        events.push({
-          type: 'tool_call_delta',
-          index: state.toolCalls.length - 1,
-          delta: {
-            toolCallId: call.function.name,
-            toolName: call.function.name,
-            argumentsJson: JSON.stringify(call.function.arguments),
-          },
-        });
-      }
-    }
-  }
-
-  // Final chunk with metrics
-  if (chunk.done) {
-    state.doneReason = chunk.done_reason ?? null;
-    state.promptEvalCount = chunk.prompt_eval_count ?? 0;
-    state.evalCount = chunk.eval_count ?? 0;
-    state.totalDuration = chunk.total_duration ?? 0;
-    events.push({ type: 'message_stop', index: 0, delta: {} });
-  }
-
-  return events;
-}
-
-/**
- * Build LLMResponse from accumulated stream state
- */
-export function buildResponseFromState(state: StreamState): LLMResponse {
-  const textContent: TextBlock[] = [];
-  const toolCalls: ToolCall[] = [];
-  let structuredData: unknown;
-
-  if (state.content) {
-    textContent.push({ type: 'text', text: state.content });
-
-    // Try to parse as JSON for structured output
-    try {
-      structuredData = JSON.parse(state.content);
-    } catch {
-      // Not valid JSON - that's fine
-    }
-  }
-
-  for (const tc of state.toolCalls) {
-    toolCalls.push({
-      toolCallId: tc.name,
-      toolName: tc.name,
-      arguments: tc.args,
-    });
-  }
-
-  const message = new AssistantMessage(
-    textContent,
-    toolCalls.length > 0 ? toolCalls : undefined,
-    {
-      metadata: {
-        ollama: {
-          model: state.model,
-          created_at: state.createdAt,
-          done_reason: state.doneReason,
-          thinking: state.thinking || undefined,
-          total_duration: state.totalDuration,
-        },
-      },
-    }
-  );
-
-  const usage: TokenUsage = {
-    inputTokens: state.promptEvalCount,
-    outputTokens: state.evalCount,
-    totalTokens: state.promptEvalCount + state.evalCount,
-  };
-
-  // Map done_reason to standard stop reason
-  let stopReason = 'end_turn';
-  if (state.doneReason === 'length') {
-    stopReason = 'max_tokens';
-  } else if (toolCalls.length > 0) {
-    stopReason = 'tool_use';
-  }
-
-  return {
-    message,
-    usage,
-    stopReason,
-    data: structuredData,
-  };
-}

package/src/providers/ollama/types.ts

@@ -1,260 +0,0 @@
-/**
- * Ollama-specific LLM parameters
- * These map to Ollama's runtime options
- */
-export interface OllamaLLMParams {
-  /** Maximum number of tokens to predict (default: -1 = infinite) */
-  num_predict?: number;
-
-  /** Temperature for randomness (default: 0.8) */
-  temperature?: number;
-
-  /** Top-p (nucleus) sampling (default: 0.9) */
-  top_p?: number;
-
-  /** Top-k sampling (default: 40) */
-  top_k?: number;
-
-  /** Minimum probability for a token to be considered (default: 0.0) */
-  min_p?: number;
-
-  /** Typical p sampling (default: 1.0 = disabled) */
-  typical_p?: number;
-
-  /** Repeat penalty (default: 1.1) */
-  repeat_penalty?: number;
-
-  /** Number of tokens to look back for repeat penalty (default: 64) */
-  repeat_last_n?: number;
-
-  /** Presence penalty (default: 0.0) */
-  presence_penalty?: number;
-
-  /** Frequency penalty (default: 0.0) */
-  frequency_penalty?: number;
-
-  /** Mirostat sampling mode (0 = disabled, 1 = Mirostat, 2 = Mirostat 2.0) */
-  mirostat?: 0 | 1 | 2;
-
-  /** Mirostat learning rate (default: 0.1) */
-  mirostat_eta?: number;
-
-  /** Mirostat target entropy (default: 5.0) */
-  mirostat_tau?: number;
-
-  /** Penalize newlines (default: true) */
-  penalize_newline?: boolean;
-
-  /** Stop sequences */
-  stop?: string[];
-
-  /** Seed for deterministic sampling (default: random) */
-  seed?: number;
-
-  /** Number of tokens to keep from initial prompt (default: 4) */
-  num_keep?: number;
-
-  /** Context window size (default: model-dependent) */
-  num_ctx?: number;
-
-  /** Number of batches (default: 512) */
-  num_batch?: number;
-
-  /** Number of threads (default: auto) */
-  num_thread?: number;
-
-  /** Number of layers to offload to GPU (default: auto) */
-  num_gpu?: number;
-
-  /** Main GPU to use (default: 0) */
-  main_gpu?: number;
-
-  /** Enable low VRAM mode */
-  low_vram?: boolean;
-
-  /** Enable f16 KV cache */
-  f16_kv?: boolean;
-
-  /** Use mmap for model loading */
-  use_mmap?: boolean;
-
-  /** Use mlock for memory locking */
-  use_mlock?: boolean;
-
-  /** Vocabulary only mode */
-  vocab_only?: boolean;
-
-  /** NUMA support */
-  numa?: boolean;
-
-  /** TFS-Z sampling (default: 1.0 = disabled) */
-  tfs_z?: number;
-
-  /** Enable thinking mode (for models that support it) */
-  think?: boolean | 'high' | 'medium' | 'low';
-
-  /** Keep model loaded in memory (string duration like "5m" or number of seconds) */
-  keep_alive?: string | number;
-
-  /** Return log probabilities */
-  logprobs?: boolean;
-
-  /** Number of top log probabilities to return */
-  top_logprobs?: number;
-}
-
-/**
- * Ollama chat message format
- */
-export interface OllamaMessage {
-  role: 'system' | 'user' | 'assistant' | 'tool';
-  content: string;
-  /** Base64 encoded images for vision models */
-  images?: string[];
-  /** Tool calls made by the assistant */
-  tool_calls?: OllamaToolCall[];
-  /** Tool name when role is 'tool' */
-  tool_name?: string;
-}
-
-/**
- * Ollama tool call format
- */
-export interface OllamaToolCall {
-  function: {
-    name: string;
-    arguments: Record<string, unknown>;
-  };
-}
-
-/**
- * Ollama tool definition format
- */
-export interface OllamaTool {
-  type: 'function';
-  function: {
-    name: string;
-    description: string;
-    parameters: {
-      type: 'object';
-      properties: Record<string, unknown>;
-      required?: string[];
-    };
-  };
-}
-
-/**
- * Ollama API request body for chat endpoint
- */
-export interface OllamaRequest {
-  model: string;
-  messages: OllamaMessage[];
-  stream?: boolean;
-  format?: 'json' | Record<string, unknown>;
-  options?: OllamaOptions;
-  tools?: OllamaTool[];
-  keep_alive?: string | number;
-  think?: boolean | 'high' | 'medium' | 'low';
-  logprobs?: boolean;
-  top_logprobs?: number;
-}
-
-/**
- * Ollama runtime options (passed in options field)
- */
-export interface OllamaOptions {
-  num_predict?: number;
-  temperature?: number;
-  top_p?: number;
-  top_k?: number;
-  min_p?: number;
-  typical_p?: number;
-  repeat_penalty?: number;
-  repeat_last_n?: number;
-  presence_penalty?: number;
-  frequency_penalty?: number;
-  mirostat?: 0 | 1 | 2;
-  mirostat_eta?: number;
-  mirostat_tau?: number;
-  penalize_newline?: boolean;
-  stop?: string[];
-  seed?: number;
-  num_keep?: number;
-  num_ctx?: number;
-  num_batch?: number;
-  num_thread?: number;
-  num_gpu?: number;
-  main_gpu?: number;
-  low_vram?: boolean;
-  f16_kv?: boolean;
-  use_mmap?: boolean;
-  use_mlock?: boolean;
-  vocab_only?: boolean;
-  numa?: boolean;
-  tfs_z?: number;
-}
-
-/**
- * Ollama API response format
- */
-export interface OllamaResponse {
-  model: string;
-  created_at: string;
-  message: OllamaResponseMessage;
-  done: boolean;
-  done_reason?: 'stop' | 'length' | 'load' | 'unload';
-  total_duration?: number;
-  load_duration?: number;
-  prompt_eval_count?: number;
-  prompt_eval_duration?: number;
-  eval_count?: number;
-  eval_duration?: number;
-  logprobs?: OllamaLogprob[];
-}
-
-/**
- * Ollama response message format
- */
-export interface OllamaResponseMessage {
-  role: 'assistant';
-  content: string;
-  /** Thinking content (if think mode enabled) */
-  thinking?: string;
-  /** Tool calls requested by the model */
-  tool_calls?: OllamaToolCall[];
-  /** Images (for multimodal responses) */
-  images?: string[];
-}
-
-/**
- * Ollama log probability format
- */
-export interface OllamaLogprob {
-  token: string;
-  logprob: number;
-  bytes?: number[];
-  top_logprobs?: Array<{
-    token: string;
-    logprob: number;
-    bytes?: number[];
-  }>;
-}
-
-/**
- * Ollama streaming response chunk
- * Same structure as regular response but partial
- */
-export interface OllamaStreamChunk {
-  model: string;
-  created_at: string;
-  message: OllamaResponseMessage;
-  done: boolean;
-  done_reason?: 'stop' | 'length' | 'load' | 'unload';
-  total_duration?: number;
-  load_duration?: number;
-  prompt_eval_count?: number;
-  prompt_eval_duration?: number;
-  eval_count?: number;
-  eval_duration?: number;
-  logprobs?: OllamaLogprob[];
-}