@providerprotocol/ai 0.0.1

package/src/providers/anthropic/transform.ts

@@ -0,0 +1,452 @@
+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
+ */
+export function transformRequest<TParams extends AnthropicLLMParams>(
+  request: LLMRequest<TParams>,
+  modelId: string
+): AnthropicRequest {
+  const params = (request.params ?? { max_tokens: 4096 }) as AnthropicLLMParams;
+
+  const anthropicRequest: AnthropicRequest = {
+    model: modelId,
+    max_tokens: params.max_tokens ?? 4096,
+    messages: request.messages.map(transformMessage),
+  };
+
+  // System prompt (top-level in Anthropic)
+  if (request.system) {
+    anthropicRequest.system = request.system;
+  }
+
+  // Model parameters
+  if (params.temperature !== undefined) {
+    anthropicRequest.temperature = params.temperature;
+  }
+  if (params.top_p !== undefined) {
+    anthropicRequest.top_p = params.top_p;
+  }
+  if (params.top_k !== undefined) {
+    anthropicRequest.top_k = params.top_k;
+  }
+  if (params.stop_sequences) {
+    anthropicRequest.stop_sequences = params.stop_sequences;
+  }
+  if (params.metadata) {
+    anthropicRequest.metadata = params.metadata;
+  }
+  if (params.thinking) {
+    anthropicRequest.thinking = params.thinking;
+  }
+  if (params.service_tier !== undefined) {
+    anthropicRequest.service_tier = params.service_tier;
+  }
+
+  // Tools
+  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

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

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