@providerprotocol/ai 0.0.10 → 0.0.12

package/src/providers/anthropic/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,
-  UserMessage,
-  ToolResultMessage,
-  isUserMessage,
-  isAssistantMessage,
-  isToolResultMessage,
-} from '../../types/messages.ts';
-import type {
-  AnthropicLLMParams,
-  AnthropicRequest,
-  AnthropicMessage,
-  AnthropicContent,
-  AnthropicTool,
-  AnthropicResponse,
-  AnthropicStreamEvent,
-  AnthropicContentBlockDeltaEvent,
-} from './types.ts';
-
-/**
- * Transform UPP request to Anthropic format
- *
- * Params are spread directly to allow pass-through of any Anthropic API fields,
- * even those not explicitly defined in our type. This enables developers to
- * use new API features without waiting for library updates.
- */
-export function transformRequest<TParams extends AnthropicLLMParams>(
-  request: LLMRequest<TParams>,
-  modelId: string
-): AnthropicRequest {
-  const params = (request.params ?? {}) as AnthropicLLMParams;
-
-  // Spread params to pass through all fields, then set required fields
-  const anthropicRequest: AnthropicRequest = {
-    ...params,
-    model: modelId,
-    messages: request.messages.map(transformMessage),
-  };
-
-  // System prompt (top-level in Anthropic)
-  if (request.system) {
-    anthropicRequest.system = request.system;
-  }
-
-  // Tools come from request, not params
-  if (request.tools && request.tools.length > 0) {
-    anthropicRequest.tools = request.tools.map(transformTool);
-    anthropicRequest.tool_choice = { type: 'auto' };
-  }
-
-  // Structured output via tool-based approach
-  // Anthropic doesn't have native structured output, so we use a tool to enforce the schema
-  if (request.structure) {
-    const structuredTool: AnthropicTool = {
-      name: 'json_response',
-      description: 'Return the response in the specified JSON format. You MUST use this tool to provide your response.',
-      input_schema: {
-        type: 'object',
-        properties: request.structure.properties,
-        required: request.structure.required,
-      },
-    };
-
-    // Add the structured output tool (may coexist with user tools)
-    anthropicRequest.tools = [...(anthropicRequest.tools ?? []), structuredTool];
-    // Force the model to use the json_response tool
-    anthropicRequest.tool_choice = { type: 'tool', name: 'json_response' };
-  }
-
-  return anthropicRequest;
-}
-
-/**
- * Filter to only valid content blocks with a type property
- */
-function filterValidContent<T extends { type?: string }>(content: T[]): T[] {
-  return content.filter((c) => c && typeof c.type === 'string');
-}
-
-/**
- * Transform a UPP Message to Anthropic format
- */
-function transformMessage(message: Message): AnthropicMessage {
-  if (isUserMessage(message)) {
-    const validContent = filterValidContent(message.content);
-    return {
-      role: 'user',
-      content: validContent.map(transformContentBlock),
-    };
-  }
-
-  if (isAssistantMessage(message)) {
-    const validContent = filterValidContent(message.content);
-    const content: AnthropicContent[] = validContent.map(transformContentBlock);
-
-    // Add tool calls as tool_use content blocks
-    if (message.toolCalls) {
-      for (const call of message.toolCalls) {
-        content.push({
-          type: 'tool_use',
-          id: call.toolCallId,
-          name: call.toolName,
-          input: call.arguments,
-        });
-      }
-    }
-
-    return {
-      role: 'assistant',
-      content,
-    };
-  }
-
-  if (isToolResultMessage(message)) {
-    // Tool results are sent as user messages with tool_result content
-    return {
-      role: 'user',
-      content: message.results.map((result) => ({
-        type: 'tool_result' as const,
-        tool_use_id: result.toolCallId,
-        content:
-          typeof result.result === 'string'
-            ? result.result
-            : JSON.stringify(result.result),
-        is_error: result.isError,
-      })),
-    };
-  }
-
-  throw new Error(`Unknown message type: ${message.type}`);
-}
-
-/**
- * Transform a content block to Anthropic format
- */
-function transformContentBlock(block: ContentBlock): AnthropicContent {
-  switch (block.type) {
-    case 'text':
-      return { type: 'text', text: block.text };
-
-    case 'image': {
-      const imageBlock = block as ImageBlock;
-      if (imageBlock.source.type === 'base64') {
-        return {
-          type: 'image',
-          source: {
-            type: 'base64',
-            media_type: imageBlock.mimeType,
-            data: imageBlock.source.data,
-          },
-        };
-      }
-      if (imageBlock.source.type === 'url') {
-        return {
-          type: 'image',
-          source: {
-            type: 'url',
-            url: imageBlock.source.url,
-          },
-        };
-      }
-      if (imageBlock.source.type === 'bytes') {
-        // Convert bytes to base64
-        const base64 = btoa(
-          Array.from(imageBlock.source.data)
-            .map((b) => String.fromCharCode(b))
-            .join('')
-        );
-        return {
-          type: 'image',
-          source: {
-            type: 'base64',
-            media_type: imageBlock.mimeType,
-            data: base64,
-          },
-        };
-      }
-      throw new Error(`Unknown image source type`);
-    }
-
-    default:
-      throw new Error(`Unsupported content type: ${block.type}`);
-  }
-}
-
-/**
- * Transform a UPP Tool to Anthropic format
- */
-function transformTool(tool: Tool): AnthropicTool {
-  return {
-    name: tool.name,
-    description: tool.description,
-    input_schema: {
-      type: 'object',
-      properties: tool.parameters.properties,
-      required: tool.parameters.required,
-    },
-  };
-}
-
-/**
- * Transform Anthropic response to UPP LLMResponse
- */
-export function transformResponse(data: AnthropicResponse): LLMResponse {
-  // Extract text content
-  const textContent: TextBlock[] = [];
-  const toolCalls: ToolCall[] = [];
-  let structuredData: unknown;
-
-  for (const block of data.content) {
-    if (block.type === 'text') {
-      textContent.push({ type: 'text', text: block.text });
-    } else if (block.type === 'tool_use') {
-      // Check if this is the json_response tool (structured output)
-      if (block.name === 'json_response') {
-        // Extract structured data from tool arguments
-        structuredData = block.input;
-      }
-      toolCalls.push({
-        toolCallId: block.id,
-        toolName: block.name,
-        arguments: block.input,
-      });
-    }
-    // Skip thinking blocks for now
-  }
-
-  const message = new AssistantMessage(
-    textContent,
-    toolCalls.length > 0 ? toolCalls : undefined,
-    {
-      id: data.id,
-      metadata: {
-        anthropic: {
-          stop_reason: data.stop_reason,
-          stop_sequence: data.stop_sequence,
-          model: data.model,
-        },
-      },
-    }
-  );
-
-  const usage: TokenUsage = {
-    inputTokens: data.usage.input_tokens,
-    outputTokens: data.usage.output_tokens,
-    totalTokens: data.usage.input_tokens + data.usage.output_tokens,
-  };
-
-  return {
-    message,
-    usage,
-    stopReason: data.stop_reason ?? 'end_turn',
-    data: structuredData,
-  };
-}
-
-/**
- * State for accumulating streaming response
- */
-export interface StreamState {
-  messageId: string;
-  model: string;
-  content: Array<{ type: string; text?: string; id?: string; name?: string; input?: string }>;
-  stopReason: string | null;
-  inputTokens: number;
-  outputTokens: number;
-}
-
-/**
- * Create initial stream state
- */
-export function createStreamState(): StreamState {
-  return {
-    messageId: '',
-    model: '',
-    content: [],
-    stopReason: null,
-    inputTokens: 0,
-    outputTokens: 0,
-  };
-}
-
-/**
- * Transform Anthropic stream event to UPP StreamEvent
- * Returns null for events that don't produce UPP events
- */
-export function transformStreamEvent(
-  event: AnthropicStreamEvent,
-  state: StreamState
-): StreamEvent | null {
-  switch (event.type) {
-    case 'message_start':
-      state.messageId = event.message.id;
-      state.model = event.message.model;
-      state.inputTokens = event.message.usage.input_tokens;
-      return { type: 'message_start', index: 0, delta: {} };
-
-    case 'content_block_start':
-      // Initialize content block
-      if (event.content_block.type === 'text') {
-        state.content[event.index] = { type: 'text', text: '' };
-      } else if (event.content_block.type === 'tool_use') {
-        state.content[event.index] = {
-          type: 'tool_use',
-          id: event.content_block.id,
-          name: event.content_block.name,
-          input: '',
-        };
-      }
-      return { type: 'content_block_start', index: event.index, delta: {} };
-
-    case 'content_block_delta': {
-      const delta = event.delta;
-      if (delta.type === 'text_delta') {
-        if (state.content[event.index]) {
-          state.content[event.index]!.text =
-            (state.content[event.index]!.text ?? '') + delta.text;
-        }
-        return {
-          type: 'text_delta',
-          index: event.index,
-          delta: { text: delta.text },
-        };
-      }
-      if (delta.type === 'input_json_delta') {
-        if (state.content[event.index]) {
-          state.content[event.index]!.input =
-            (state.content[event.index]!.input ?? '') + delta.partial_json;
-        }
-        return {
-          type: 'tool_call_delta',
-          index: event.index,
-          delta: {
-            argumentsJson: delta.partial_json,
-            toolCallId: state.content[event.index]?.id,
-            toolName: state.content[event.index]?.name,
-          },
-        };
-      }
-      if (delta.type === 'thinking_delta') {
-        return {
-          type: 'reasoning_delta',
-          index: event.index,
-          delta: { text: delta.thinking },
-        };
-      }
-      return null;
-    }
-
-    case 'content_block_stop':
-      return { type: 'content_block_stop', index: event.index, delta: {} };
-
-    case 'message_delta':
-      state.stopReason = event.delta.stop_reason;
-      state.outputTokens = event.usage.output_tokens;
-      return null;
-
-    case 'message_stop':
-      return { type: 'message_stop', index: 0, delta: {} };
-
-    case 'ping':
-    case 'error':
-      return null;
-
-    default:
-      return null;
-  }
-}
-
-/**
- * Build LLMResponse from accumulated stream state
- */
-export function buildResponseFromState(state: StreamState): LLMResponse {
-  const textContent: TextBlock[] = [];
-  const toolCalls: ToolCall[] = [];
-  let structuredData: unknown;
-
-  for (const block of state.content) {
-    if (block.type === 'text' && block.text) {
-      textContent.push({ type: 'text', text: block.text });
-    } else if (block.type === 'tool_use' && block.id && block.name) {
-      let args: Record<string, unknown> = {};
-      if (block.input) {
-        try {
-          args = JSON.parse(block.input);
-        } catch {
-          // Invalid JSON - use empty object
-        }
-      }
-      // Check if this is the json_response tool (structured output)
-      if (block.name === 'json_response') {
-        structuredData = args;
-      }
-      toolCalls.push({
-        toolCallId: block.id,
-        toolName: block.name,
-        arguments: args,
-      });
-    }
-  }
-
-  const message = new AssistantMessage(
-    textContent,
-    toolCalls.length > 0 ? toolCalls : undefined,
-    {
-      id: state.messageId,
-      metadata: {
-        anthropic: {
-          stop_reason: state.stopReason,
-          model: state.model,
-        },
-      },
-    }
-  );
-
-  const usage: TokenUsage = {
-    inputTokens: state.inputTokens,
-    outputTokens: state.outputTokens,
-    totalTokens: state.inputTokens + state.outputTokens,
-  };
-
-  return {
-    message,
-    usage,
-    stopReason: state.stopReason ?? 'end_turn',
-    data: structuredData,
-  };
-}

package/src/providers/anthropic/types.ts

@@ -1,213 +0,0 @@
-/**
- * Anthropic-specific LLM parameters
- * These are passed through to the Anthropic Messages API
- */
-export interface AnthropicLLMParams {
-  /** Maximum number of tokens to generate (required by Anthropic API) */
-  max_tokens?: number;
-
-  /** Temperature for randomness (0.0 - 1.0) */
-  temperature?: number;
-
-  /** Top-p (nucleus) sampling */
-  top_p?: number;
-
-  /** Top-k sampling */
-  top_k?: number;
-
-  /** Custom stop sequences */
-  stop_sequences?: string[];
-
-  /** Metadata for the request */
-  metadata?: {
-    user_id?: string;
-  };
-
-  /** Extended thinking configuration */
-  thinking?: {
-    type: 'enabled';
-    budget_tokens: number;
-  };
-
-  /**
-   * Service tier for priority/standard capacity
-   * - "auto": Automatically select based on availability (default)
-   * - "standard_only": Only use standard capacity
-   */
-  service_tier?: 'auto' | 'standard_only';
-}
-
-/**
- * Anthropic API request body
- */
-export interface AnthropicRequest {
-  model: string;
-  max_tokens?: number;
-  messages: AnthropicMessage[];
-  system?: string;
-  temperature?: number;
-  top_p?: number;
-  top_k?: number;
-  stop_sequences?: string[];
-  stream?: boolean;
-  tools?: AnthropicTool[];
-  tool_choice?: { type: 'auto' | 'any' | 'tool'; name?: string };
-  metadata?: { user_id?: string };
-  thinking?: { type: 'enabled'; budget_tokens: number };
-  service_tier?: 'auto' | 'standard_only';
-}
-
-/**
- * Anthropic message format
- */
-export interface AnthropicMessage {
-  role: 'user' | 'assistant';
-  content: AnthropicContent[] | string;
-}
-
-/**
- * Anthropic content types
- */
-export type AnthropicContent =
-  | AnthropicTextContent
-  | AnthropicImageContent
-  | AnthropicToolUseContent
-  | AnthropicToolResultContent;
-
-export interface AnthropicTextContent {
-  type: 'text';
-  text: string;
-}
-
-export interface AnthropicImageContent {
-  type: 'image';
-  source: {
-    type: 'base64' | 'url';
-    media_type?: string;
-    data?: string;
-    url?: string;
-  };
-}
-
-export interface AnthropicToolUseContent {
-  type: 'tool_use';
-  id: string;
-  name: string;
-  input: Record<string, unknown>;
-}
-
-export interface AnthropicToolResultContent {
-  type: 'tool_result';
-  tool_use_id: string;
-  content: string | AnthropicContent[];
-  is_error?: boolean;
-}
-
-/**
- * Anthropic tool format
- */
-export interface AnthropicTool {
-  name: string;
-  description: string;
-  input_schema: {
-    type: 'object';
-    properties: Record<string, unknown>;
-    required?: string[];
-  };
-}
-
-/**
- * Anthropic response format
- */
-export interface AnthropicResponse {
-  id: string;
-  type: 'message';
-  role: 'assistant';
-  content: AnthropicResponseContent[];
-  model: string;
-  stop_reason: 'end_turn' | 'max_tokens' | 'stop_sequence' | 'tool_use' | 'pause_turn' | 'refusal' | null;
-  stop_sequence: string | null;
-  usage: {
-    input_tokens: number;
-    output_tokens: number;
-    cache_creation_input_tokens?: number;
-    cache_read_input_tokens?: number;
-  };
-}
-
-export type AnthropicResponseContent =
-  | AnthropicTextContent
-  | AnthropicToolUseContent
-  | AnthropicThinkingContent;
-
-export interface AnthropicThinkingContent {
-  type: 'thinking';
-  thinking: string;
-  signature?: string;
-}
-
-/**
- * Anthropic streaming event types
- */
-export type AnthropicStreamEvent =
-  | AnthropicMessageStartEvent
-  | AnthropicContentBlockStartEvent
-  | AnthropicContentBlockDeltaEvent
-  | AnthropicContentBlockStopEvent
-  | AnthropicMessageDeltaEvent
-  | AnthropicMessageStopEvent
-  | AnthropicPingEvent
-  | AnthropicErrorEvent;
-
-export interface AnthropicMessageStartEvent {
-  type: 'message_start';
-  message: AnthropicResponse;
-}
-
-export interface AnthropicContentBlockStartEvent {
-  type: 'content_block_start';
-  index: number;
-  content_block: AnthropicResponseContent;
-}
-
-export interface AnthropicContentBlockDeltaEvent {
-  type: 'content_block_delta';
-  index: number;
-  delta:
-    | { type: 'text_delta'; text: string }
-    | { type: 'thinking_delta'; thinking: string }
-    | { type: 'signature_delta'; signature: string }
-    | { type: 'input_json_delta'; partial_json: string };
-}
-
-export interface AnthropicContentBlockStopEvent {
-  type: 'content_block_stop';
-  index: number;
-}
-
-export interface AnthropicMessageDeltaEvent {
-  type: 'message_delta';
-  delta: {
-    stop_reason: string | null;
-    stop_sequence: string | null;
-  };
-  usage: {
-    output_tokens: number;
-  };
-}
-
-export interface AnthropicMessageStopEvent {
-  type: 'message_stop';
-}
-
-export interface AnthropicPingEvent {
-  type: 'ping';
-}
-
-export interface AnthropicErrorEvent {
-  type: 'error';
-  error: {
-    type: string;
-    message: string;
-  };
-}

package/src/providers/google/index.ts

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