@providerprotocol/ai 0.0.2 → 0.0.4

package/src/providers/openrouter/transform.responses.ts

@@ -0,0 +1,755 @@
+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 {
+  OpenRouterLLMParams,
+  OpenRouterResponsesRequest,
+  OpenRouterResponsesInputItem,
+  OpenRouterResponsesContentPart,
+  OpenRouterResponsesTool,
+  OpenRouterResponsesResponse,
+  OpenRouterResponsesStreamEvent,
+  OpenRouterResponsesOutputItem,
+  OpenRouterResponsesMessageOutput,
+  OpenRouterResponsesFunctionCallOutput,
+} from './types.ts';
+
+/**
+ * Transform UPP request to OpenRouter Responses API format
+ */
+export function transformRequest<TParams extends OpenRouterLLMParams>(
+  request: LLMRequest<TParams>,
+  modelId: string
+): OpenRouterResponsesRequest {
+  const params: OpenRouterLLMParams = request.params ?? {};
+
+  const openrouterRequest: OpenRouterResponsesRequest = {
+    model: modelId,
+    input: transformInputItems(request.messages, request.system),
+  };
+
+  // Model parameters
+  if (params.temperature !== undefined) {
+    openrouterRequest.temperature = params.temperature;
+  }
+  if (params.top_p !== undefined) {
+    openrouterRequest.top_p = params.top_p;
+  }
+  if (params.max_output_tokens !== undefined) {
+    openrouterRequest.max_output_tokens = params.max_output_tokens;
+  } else if (params.max_tokens !== undefined) {
+    openrouterRequest.max_output_tokens = params.max_tokens;
+  }
+  if (params.reasoning !== undefined) {
+    openrouterRequest.reasoning = { ...params.reasoning };
+  }
+
+  // Tools
+  if (request.tools && request.tools.length > 0) {
+    openrouterRequest.tools = request.tools.map(transformTool);
+    if (params.parallel_tool_calls !== undefined) {
+      openrouterRequest.parallel_tool_calls = params.parallel_tool_calls;
+    }
+  }
+
+  // Structured output via text.format
+  if (request.structure) {
+    const schema: Record<string, unknown> = {
+      type: 'object',
+      properties: request.structure.properties,
+      required: request.structure.required,
+      ...(request.structure.additionalProperties !== undefined
+        ? { additionalProperties: request.structure.additionalProperties }
+        : { additionalProperties: false }),
+    };
+    if (request.structure.description) {
+      schema.description = request.structure.description;
+    }
+
+    openrouterRequest.text = {
+      format: {
+        type: 'json_schema',
+        name: 'json_response',
+        description: request.structure.description,
+        schema,
+        strict: true,
+      },
+    };
+  }
+
+  return openrouterRequest;
+}
+
+/**
+ * Transform messages to Responses API input items
+ */
+function transformInputItems(
+  messages: Message[],
+  system?: string
+): OpenRouterResponsesInputItem[] | string {
+  const result: OpenRouterResponsesInputItem[] = [];
+
+  if (system) {
+    result.push({
+      type: 'message',
+      role: 'system',
+      content: system,
+    });
+  }
+
+  for (const message of messages) {
+    const items = transformMessage(message);
+    result.push(...items);
+  }
+
+  // If there's only one user message with simple text, return as string
+  if (result.length === 1 && result[0]?.type === 'message') {
+    const item = result[0] as { role?: string; content?: string | unknown[] };
+    if (item.role === 'user' && typeof item.content === 'string') {
+      return item.content;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * 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 OpenRouter Responses API input items
+ */
+function transformMessage(message: Message): OpenRouterResponsesInputItem[] {
+  if (isUserMessage(message)) {
+    const validContent = filterValidContent(message.content);
+    // Check if we can use simple string content
+    if (validContent.length === 1 && validContent[0]?.type === 'text') {
+      return [
+        {
+          type: 'message',
+          role: 'user',
+          content: (validContent[0] as TextBlock).text,
+        },
+      ];
+    }
+    return [
+      {
+        type: 'message',
+        role: 'user',
+        content: validContent.map(transformContentPart),
+      },
+    ];
+  }
+
+  if (isAssistantMessage(message)) {
+    const validContent = filterValidContent(message.content);
+    const items: OpenRouterResponsesInputItem[] = [];
+
+    // Add message content - only text parts for assistant messages
+    const contentParts: OpenRouterResponsesContentPart[] = validContent
+      .filter((c): c is TextBlock => c.type === 'text')
+      .map((c): OpenRouterResponsesContentPart => ({
+        type: 'output_text',
+        text: c.text,
+        annotations: [],
+      }));
+
+    // Get message id from metadata or generate one
+    const messageId = message.id ?? `msg_${Date.now()}`;
+
+    // Add assistant message if we have text content
+    if (contentParts.length > 0) {
+      items.push({
+        type: 'message',
+        role: 'assistant',
+        id: messageId,
+        status: 'completed',
+        content: contentParts,
+      });
+    }
+
+    // Add function_call items for each tool call (must precede function_call_output)
+    const openrouterMeta = message.metadata?.openrouter as
+      | { functionCallItems?: Array<{ id: string; call_id: string; name: string; arguments: string }> }
+      | undefined;
+    const functionCallItems = openrouterMeta?.functionCallItems;
+
+    if (functionCallItems && functionCallItems.length > 0) {
+      for (const fc of functionCallItems) {
+        items.push({
+          type: 'function_call',
+          id: fc.id,
+          call_id: fc.call_id,
+          name: fc.name,
+          arguments: fc.arguments,
+        });
+      }
+    } else if (message.toolCalls && message.toolCalls.length > 0) {
+      for (const call of message.toolCalls) {
+        items.push({
+          type: 'function_call',
+          id: `fc_${call.toolCallId}`,
+          call_id: call.toolCallId,
+          name: call.toolName,
+          arguments: JSON.stringify(call.arguments),
+        });
+      }
+    }
+
+    return items;
+  }
+
+  if (isToolResultMessage(message)) {
+    // Tool results are function_call_output items
+    return message.results.map((result, index) => ({
+      type: 'function_call_output' as const,
+      id: `fco_${result.toolCallId}_${index}`,
+      call_id: result.toolCallId,
+      output:
+        typeof result.result === 'string'
+          ? result.result
+          : JSON.stringify(result.result),
+    }));
+  }
+
+  return [];
+}
+
+/**
+ * Transform a content block to Responses API format
+ */
+function transformContentPart(block: ContentBlock): OpenRouterResponsesContentPart {
+  switch (block.type) {
+    case 'text':
+      return { type: 'input_text', text: block.text };
+
+    case 'image': {
+      const imageBlock = block as ImageBlock;
+      if (imageBlock.source.type === 'base64') {
+        return {
+          type: 'input_image',
+          image_url: `data:${imageBlock.mimeType};base64,${imageBlock.source.data}`,
+          detail: 'auto',
+        };
+      }
+
+      if (imageBlock.source.type === 'url') {
+        return {
+          type: 'input_image',
+          image_url: imageBlock.source.url,
+          detail: 'auto',
+        };
+      }
+
+      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: 'input_image',
+          image_url: `data:${imageBlock.mimeType};base64,${base64}`,
+          detail: 'auto',
+        };
+      }
+
+      throw new Error('Unknown image source type');
+    }
+
+    default:
+      throw new Error(`Unsupported content type: ${block.type}`);
+  }
+}
+
+/**
+ * Transform a UPP Tool to Responses API format
+ */
+function transformTool(tool: Tool): OpenRouterResponsesTool {
+  return {
+    type: 'function',
+    name: tool.name,
+    description: tool.description,
+    parameters: {
+      type: 'object',
+      properties: tool.parameters.properties,
+      required: tool.parameters.required,
+      ...(tool.parameters.additionalProperties !== undefined
+        ? { additionalProperties: tool.parameters.additionalProperties }
+        : {}),
+    },
+  };
+}
+
+/**
+ * Transform OpenRouter Responses API response to UPP LLMResponse
+ */
+export function transformResponse(data: OpenRouterResponsesResponse): LLMResponse {
+  // Extract text content and tool calls from output items
+  const textContent: TextBlock[] = [];
+  const toolCalls: ToolCall[] = [];
+  const functionCallItems: Array<{
+    id: string;
+    call_id: string;
+    name: string;
+    arguments: string;
+  }> = [];
+  let hadRefusal = false;
+  let structuredData: unknown;
+
+  for (const item of data.output) {
+    if (item.type === 'message') {
+      const messageItem = item as OpenRouterResponsesMessageOutput;
+      for (const content of messageItem.content) {
+        if (content.type === 'output_text') {
+          textContent.push({ type: 'text', text: content.text });
+          // Try to parse as JSON for structured output (native JSON mode)
+          // Only set data if text is valid JSON
+          if (structuredData === undefined) {
+            try {
+              structuredData = JSON.parse(content.text);
+            } catch {
+              // Not valid JSON - that's fine, might not be structured output
+            }
+          }
+        } else if (content.type === 'refusal') {
+          textContent.push({ type: 'text', text: content.refusal });
+          hadRefusal = true;
+        }
+      }
+    } else if (item.type === 'function_call') {
+      const functionCall = item as OpenRouterResponsesFunctionCallOutput;
+      let args: Record<string, unknown> = {};
+      try {
+        args = JSON.parse(functionCall.arguments);
+      } catch {
+        // Invalid JSON - use empty object
+      }
+      toolCalls.push({
+        toolCallId: functionCall.call_id,
+        toolName: functionCall.name,
+        arguments: args,
+      });
+      functionCallItems.push({
+        id: functionCall.id,
+        call_id: functionCall.call_id,
+        name: functionCall.name,
+        arguments: functionCall.arguments,
+      });
+    }
+  }
+
+  const message = new AssistantMessage(
+    textContent,
+    toolCalls.length > 0 ? toolCalls : undefined,
+    {
+      id: data.id,
+      metadata: {
+        openrouter: {
+          model: data.model,
+          status: data.status,
+          // Store response_id for multi-turn tool calling
+          response_id: data.id,
+          functionCallItems:
+            functionCallItems.length > 0 ? functionCallItems : undefined,
+        },
+      },
+    }
+  );
+
+  const usage: TokenUsage = {
+    inputTokens: data.usage.input_tokens,
+    outputTokens: data.usage.output_tokens,
+    totalTokens: data.usage.total_tokens,
+  };
+
+  // Map status to stop reason
+  let stopReason = 'end_turn';
+  if (data.status === 'completed') {
+    stopReason = toolCalls.length > 0 ? 'tool_use' : 'end_turn';
+  } else if (data.status === 'incomplete') {
+    stopReason = data.incomplete_details?.reason === 'max_output_tokens'
+      ? 'max_tokens'
+      : 'end_turn';
+  } else if (data.status === 'failed') {
+    stopReason = 'error';
+  }
+  if (hadRefusal && stopReason !== 'error') {
+    stopReason = 'content_filter';
+  }
+
+  return {
+    message,
+    usage,
+    stopReason,
+    data: structuredData,
+  };
+}
+
+/**
+ * State for accumulating streaming response
+ */
+export interface ResponsesStreamState {
+  id: string;
+  model: string;
+  textByIndex: Map<number, string>;
+  toolCalls: Map<
+    number,
+    { itemId?: string; callId?: string; name?: string; arguments: string }
+  >;
+  status: string;
+  inputTokens: number;
+  outputTokens: number;
+  hadRefusal: boolean;
+}
+
+/**
+ * Create initial stream state
+ */
+export function createStreamState(): ResponsesStreamState {
+  return {
+    id: '',
+    model: '',
+    textByIndex: new Map(),
+    toolCalls: new Map(),
+    status: 'in_progress',
+    inputTokens: 0,
+    outputTokens: 0,
+    hadRefusal: false,
+  };
+}
+
+/**
+ * Transform OpenRouter Responses API stream event to UPP StreamEvent
+ * Returns array since one event may produce multiple UPP events
+ */
+export function transformStreamEvent(
+  event: OpenRouterResponsesStreamEvent,
+  state: ResponsesStreamState
+): StreamEvent[] {
+  const events: StreamEvent[] = [];
+
+  switch (event.type) {
+    case 'response.created':
+      state.id = event.response.id;
+      state.model = event.response.model;
+      events.push({ type: 'message_start', index: 0, delta: {} });
+      break;
+
+    case 'response.in_progress':
+      state.status = 'in_progress';
+      break;
+
+    case 'response.completed':
+    case 'response.done':
+      // Handle both event type names (OpenRouter docs show response.done)
+      state.status = 'completed';
+      if (event.response?.usage) {
+        state.inputTokens = event.response.usage.input_tokens;
+        state.outputTokens = event.response.usage.output_tokens;
+      }
+      // CRITICAL: OpenRouter's streaming doesn't send function call arguments incrementally.
+      // They only appear in the final response.completed event's output array.
+      // We must extract them here to populate state.toolCalls with actual arguments.
+      if (event.response?.output) {
+        for (let i = 0; i < event.response.output.length; i++) {
+          const item = event.response.output[i];
+          if (item && item.type === 'function_call') {
+            const functionCall = item as OpenRouterResponsesFunctionCallOutput;
+            const existing = state.toolCalls.get(i) ?? { arguments: '' };
+            existing.itemId = functionCall.id ?? existing.itemId;
+            existing.callId = functionCall.call_id ?? existing.callId;
+            existing.name = functionCall.name ?? existing.name;
+            // This is the key fix: get arguments from the completed response
+            if (functionCall.arguments) {
+              existing.arguments = functionCall.arguments;
+            }
+            state.toolCalls.set(i, existing);
+          }
+        }
+      }
+      events.push({ type: 'message_stop', index: 0, delta: {} });
+      break;
+
+    case 'response.failed':
+      state.status = 'failed';
+      events.push({ type: 'message_stop', index: 0, delta: {} });
+      break;
+
+    case 'response.output_item.added':
+      if (event.item.type === 'function_call') {
+        const functionCall = event.item as OpenRouterResponsesFunctionCallOutput;
+        const existing = state.toolCalls.get(event.output_index) ?? {
+          arguments: '',
+        };
+        existing.itemId = functionCall.id;
+        existing.callId = functionCall.call_id;
+        existing.name = functionCall.name;
+        if (functionCall.arguments) {
+          existing.arguments = functionCall.arguments;
+        }
+        state.toolCalls.set(event.output_index, existing);
+      }
+      events.push({
+        type: 'content_block_start',
+        index: event.output_index,
+        delta: {},
+      });
+      break;
+
+    case 'response.output_item.done':
+      if (event.item.type === 'function_call') {
+        const functionCall = event.item as OpenRouterResponsesFunctionCallOutput;
+        const existing = state.toolCalls.get(event.output_index) ?? {
+          arguments: '',
+        };
+        existing.itemId = functionCall.id;
+        existing.callId = functionCall.call_id;
+        existing.name = functionCall.name;
+        if (functionCall.arguments) {
+          existing.arguments = functionCall.arguments;
+        }
+        state.toolCalls.set(event.output_index, existing);
+      } else if (event.item.type === 'message') {
+        // Extract text from completed message item (may not have incremental deltas)
+        const messageItem = event.item as OpenRouterResponsesMessageOutput;
+        for (const content of messageItem.content || []) {
+          if (content.type === 'output_text') {
+            const existingText = state.textByIndex.get(event.output_index) ?? '';
+            if (!existingText && content.text) {
+              // Only use done text if we didn't get incremental deltas
+              state.textByIndex.set(event.output_index, content.text);
+              events.push({
+                type: 'text_delta',
+                index: event.output_index,
+                delta: { text: content.text },
+              });
+            }
+          }
+        }
+      }
+      events.push({
+        type: 'content_block_stop',
+        index: event.output_index,
+        delta: {},
+      });
+      break;
+
+    case 'response.content_part.delta':
+    case 'response.output_text.delta': {
+      // Handle both event type names (OpenRouter docs vs OpenAI-style)
+      // Accumulate text
+      const textDelta = (event as { delta: string }).delta;
+      const currentText = state.textByIndex.get(event.output_index) ?? '';
+      state.textByIndex.set(event.output_index, currentText + textDelta);
+      events.push({
+        type: 'text_delta',
+        index: event.output_index,
+        delta: { text: textDelta },
+      });
+      break;
+    }
+
+    case 'response.output_text.done':
+    case 'response.content_part.done':
+      // Handle both event type names
+      if ('text' in event) {
+        state.textByIndex.set(event.output_index, (event as { text: string }).text);
+      }
+      break;
+
+    case 'response.refusal.delta': {
+      state.hadRefusal = true;
+      const currentRefusal = state.textByIndex.get(event.output_index) ?? '';
+      state.textByIndex.set(event.output_index, currentRefusal + event.delta);
+      events.push({
+        type: 'text_delta',
+        index: event.output_index,
+        delta: { text: event.delta },
+      });
+      break;
+    }
+
+    case 'response.refusal.done':
+      state.hadRefusal = true;
+      state.textByIndex.set(event.output_index, event.refusal);
+      break;
+
+    case 'response.function_call_arguments.delta': {
+      // Accumulate function call arguments
+      let toolCall = state.toolCalls.get(event.output_index);
+      if (!toolCall) {
+        toolCall = { arguments: '' };
+        state.toolCalls.set(event.output_index, toolCall);
+      }
+      if (event.item_id && !toolCall.itemId) {
+        toolCall.itemId = event.item_id;
+      }
+      if (event.call_id && !toolCall.callId) {
+        toolCall.callId = event.call_id;
+      }
+      toolCall.arguments += event.delta;
+      events.push({
+        type: 'tool_call_delta',
+        index: event.output_index,
+        delta: {
+          toolCallId: toolCall.callId ?? toolCall.itemId ?? '',
+          toolName: toolCall.name,
+          argumentsJson: event.delta,
+        },
+      });
+      break;
+    }
+
+    case 'response.function_call_arguments.done': {
+      // Finalize function call
+      let toolCall = state.toolCalls.get(event.output_index);
+      if (!toolCall) {
+        toolCall = { arguments: '' };
+        state.toolCalls.set(event.output_index, toolCall);
+      }
+      if (event.item_id) {
+        toolCall.itemId = event.item_id;
+      }
+      if (event.call_id) {
+        toolCall.callId = event.call_id;
+      }
+      toolCall.name = event.name;
+      toolCall.arguments = event.arguments;
+      break;
+    }
+
+    case 'response.reasoning.delta':
+      // Emit reasoning as a reasoning_delta event
+      events.push({
+        type: 'reasoning_delta',
+        index: 0,
+        delta: { text: event.delta },
+      });
+      break;
+
+    case 'error':
+      // Error events are handled at the handler level
+      break;
+
+    default:
+      // Ignore other events
+      break;
+  }
+
+  return events;
+}
+
+/**
+ * Build LLMResponse from accumulated stream state
+ */
+export function buildResponseFromState(state: ResponsesStreamState): LLMResponse {
+  const textContent: TextBlock[] = [];
+  let structuredData: unknown;
+
+  // Combine all text content
+  for (const [, text] of state.textByIndex) {
+    if (text) {
+      textContent.push({ type: 'text', text });
+      // Try to parse as JSON for structured output (native JSON mode)
+      if (structuredData === undefined) {
+        try {
+          structuredData = JSON.parse(text);
+        } catch {
+          // Not valid JSON - that's fine, might not be structured output
+        }
+      }
+    }
+  }
+
+  const toolCalls: ToolCall[] = [];
+  const functionCallItems: Array<{
+    id: string;
+    call_id: string;
+    name: string;
+    arguments: string;
+  }> = [];
+  for (const [, toolCall] of state.toolCalls) {
+    let args: Record<string, unknown> = {};
+    if (toolCall.arguments) {
+      try {
+        args = JSON.parse(toolCall.arguments);
+      } catch {
+        // Invalid JSON - use empty object
+      }
+    }
+    const itemId = toolCall.itemId ?? '';
+    const callId = toolCall.callId ?? toolCall.itemId ?? '';
+    const name = toolCall.name ?? '';
+    toolCalls.push({
+      toolCallId: callId,
+      toolName: name,
+      arguments: args,
+    });
+
+    if (itemId && callId && name) {
+      functionCallItems.push({
+        id: itemId,
+        call_id: callId,
+        name,
+        arguments: toolCall.arguments,
+      });
+    }
+  }
+
+  const message = new AssistantMessage(
+    textContent,
+    toolCalls.length > 0 ? toolCalls : undefined,
+    {
+      id: state.id,
+      metadata: {
+        openrouter: {
+          model: state.model,
+          status: state.status,
+          // Store response_id for multi-turn tool calling
+          response_id: state.id,
+          functionCallItems:
+            functionCallItems.length > 0 ? functionCallItems : undefined,
+        },
+      },
+    }
+  );
+
+  const usage: TokenUsage = {
+    inputTokens: state.inputTokens,
+    outputTokens: state.outputTokens,
+    totalTokens: state.inputTokens + state.outputTokens,
+  };
+
+  // Map status to stop reason
+  let stopReason = 'end_turn';
+  if (state.status === 'completed') {
+    stopReason = toolCalls.length > 0 ? 'tool_use' : 'end_turn';
+  } else if (state.status === 'failed') {
+    stopReason = 'error';
+  }
+  if (state.hadRefusal && stopReason !== 'error') {
+    stopReason = 'content_filter';
+  }
+
+  return {
+    message,
+    usage,
+    stopReason,
+    data: structuredData,
+  };
+}