free-coding-models 0.3.11 → 0.3.13

package/src/request-transformer.js

@@ -1,180 +0,0 @@
-/**
- * request-transformer.js
- *
- * Utilities for transforming outgoing API request bodies before they are
- * forwarded to a model provider:
- *   - applyThinkingBudget  — control Anthropic-style "thinking" budget
- *   - compressContext      — reduce prompt size at increasing compression levels
- */
-
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Count the total characters contributed by a single message.
- * Handles both plain-string content and array-of-blocks content.
- *
- * @param {object} msg
- * @returns {number}
- */
-function messageCharCount(msg) {
-  if (typeof msg.content === 'string') return msg.content.length
-  if (Array.isArray(msg.content)) {
-    return msg.content.reduce((sum, block) => {
-      if (typeof block === 'string') return sum + block.length
-      if (block.type === 'text') return sum + (block.text?.length || 0)
-      if (block.type === 'thinking') return sum + (block.thinking?.length || 0)
-      return sum
-    }, 0)
-  }
-  return 0
-}
-
-// ---------------------------------------------------------------------------
-// applyThinkingBudget
-// ---------------------------------------------------------------------------
-
-/**
- * Attach (or omit) an Anthropic-style "thinking" budget to the request body.
- *
- * Modes:
- *   'passthrough' — return a shallow copy of body with no changes
- *   'custom'      — add thinking: { budget_tokens: config.budget_tokens }
- *   'auto'        — add thinking only when the total prompt is > 2 000 chars;
- *                   budget is proportional: min(totalChars * 2, 32 000)
- *
- * The original body is NEVER mutated.
- *
- * @param {object} body        - The request body (OpenAI-compatible shape)
- * @param {{ mode: string, budget_tokens?: number }} config
- * @returns {object}           - A new body object
- */
-export function applyThinkingBudget(body, config) {
-  const { mode } = config
-
-  if (mode === 'passthrough') {
-    return { ...body }
-  }
-
-  if (mode === 'custom') {
-    return { ...body, thinking: { budget_tokens: config.budget_tokens } }
-  }
-
-  if (mode === 'auto') {
-    const messages = Array.isArray(body.messages) ? body.messages : []
-    const totalChars = messages.reduce((sum, msg) => {
-      if (typeof msg.content === 'string') return sum + msg.content.length
-      if (Array.isArray(msg.content)) {
-        return sum + msg.content.reduce((s, block) => {
-          if (typeof block === 'string') return s + block.length
-          return s + (block.text?.length || 0) + (block.thinking?.length || 0)
-        }, 0)
-      }
-      return sum
-    }, 0)
-
-    if (totalChars > 2000) {
-      const budget_tokens = Math.min(Math.floor(totalChars * 2), 32000)
-      return { ...body, thinking: { budget_tokens } }
-    }
-
-    return { ...body }
-  }
-
-  // Unknown mode — return shallow copy unchanged
-  return { ...body }
-}
-
-// ---------------------------------------------------------------------------
-// compressContext
-// ---------------------------------------------------------------------------
-
-/**
- * Reduce the size of the messages array at increasing compression levels.
- *
- * Levels:
- *   0 — no change (shallow copy of array)
- *   1 — truncate tool-result messages whose content exceeds toolResultMaxChars
- *   2 — L1 + truncate thinking blocks in assistant messages
- *   3 — L2 + drop oldest non-system messages when total chars exceed maxTotalChars
- *
- * The original messages array and its objects are NEVER mutated.
- *
- * @param {object[]} messages
- * @param {{
- *   level?: number,
- *   toolResultMaxChars?: number,
- *   thinkingMaxChars?: number,
- *   maxTotalChars?: number
- * }} opts
- * @returns {object[]}
- */
-export function compressContext(messages, opts = {}) {
-  const {
-    level = 0,
-    toolResultMaxChars = 4000,
-    thinkingMaxChars = 1000,
-    maxTotalChars = 100000,
-  } = opts
-
-  if (level === 0) {
-    return [...messages]
-  }
-
-  // L1: trim oversized tool results
-  let result = messages.map(msg => {
-    if (msg.role === 'tool' && typeof msg.content === 'string') {
-      if (msg.content.length > toolResultMaxChars) {
-        return {
-          ...msg,
-          content: msg.content.slice(0, toolResultMaxChars) + '\n[truncated]',
-        }
-      }
-    }
-    return msg
-  })
-
-  if (level === 1) {
-    return result
-  }
-
-  // L2: trim thinking blocks in assistant messages
-  result = result.map(msg => {
-    if (msg.role === 'assistant' && Array.isArray(msg.content)) {
-      const newContent = msg.content.map(block => {
-        if (
-          block.type === 'thinking' &&
-          typeof block.thinking === 'string' &&
-          block.thinking.length > thinkingMaxChars
-        ) {
-          return { ...block, thinking: block.thinking.slice(0, thinkingMaxChars) }
-        }
-        return block
-      })
-      // Only create a new message object when something actually changed
-      const changed = newContent.some((b, i) => b !== msg.content[i])
-      return changed ? { ...msg, content: newContent } : msg
-    }
-    return msg
-  })
-
-  if (level === 2) {
-    return result
-  }
-
-  // L3: drop oldest non-system messages until total chars is within budget
-  // Always preserve: every 'system' message, and the last message in the array.
-  const totalChars = () => result.reduce((sum, msg) => sum + messageCharCount(msg), 0)
-
-  while (totalChars() > maxTotalChars && result.length > 1) {
-    // Find the first droppable message: not 'system', not the last one
-    const dropIdx = result.findIndex(
-      (msg, idx) => msg.role !== 'system' && idx !== result.length - 1
-    )
-    if (dropIdx === -1) break // nothing left to drop
-    result = [...result.slice(0, dropIdx), ...result.slice(dropIdx + 1)]
-  }
-
-  return result
-}

package/src/responses-translator.js

@@ -1,423 +0,0 @@
-/**
- * @file src/responses-translator.js
- * @description Bidirectional translation between the OpenAI Responses API wire format
- * and the older OpenAI Chat Completions wire used by the upstream free providers.
- *
- * @details
- *   📖 Codex CLI can speak either `responses` or `chat` depending on provider config.
- *   📖 Our upstream accounts still expose `/chat/completions`, so this module converts:
- *   - Responses requests → Chat Completions requests
- *   - Chat Completions JSON/SSE responses → Responses JSON/SSE responses
- *
- *   📖 The implementation focuses on the items Codex actually uses:
- *   - `instructions` / `input` message history
- *   - function tools + function-call outputs
- *   - assistant text deltas
- *   - function call argument deltas
- *   - final `response.completed` payload with usage
- *
- * @functions
- *   → `translateResponsesToOpenAI` — convert a Responses request body to chat completions
- *   → `translateOpenAIToResponses` — convert a chat completions JSON response to Responses JSON
- *   → `createResponsesSSETransformer` — convert chat-completions SSE chunks to Responses SSE
- *
- * @exports translateResponsesToOpenAI, translateOpenAIToResponses, createResponsesSSETransformer
- * @see src/proxy-server.js
- */
-
-import { randomUUID } from 'node:crypto'
-import { Transform } from 'node:stream'
-
-const MAX_SSE_BUFFER = 1 * 1024 * 1024
-
-function serializeJsonish(value) {
-  if (typeof value === 'string') return value
-  try {
-    return JSON.stringify(value ?? '')
-  } catch {
-    return String(value ?? '')
-  }
-}
-
-function normalizeResponseContent(content) {
-  if (typeof content === 'string') return [{ type: 'input_text', text: content }]
-  if (!Array.isArray(content)) return []
-  return content
-}
-
-function contentPartToText(part) {
-  if (!part || typeof part !== 'object') return ''
-  if (typeof part.text === 'string') return part.text
-  if (part.type === 'reasoning' && typeof part.summary === 'string') return part.summary
-  return ''
-}
-
-function pushTextMessage(messages, role, textParts) {
-  const text = textParts.join('\n').trim()
-  if (!text && role !== 'assistant') return
-  messages.push({ role, content: text || '' })
-}
-
-function makeFunctionToolCall(entry = {}) {
-  const callId = entry.call_id || entry.id || `call_${randomUUID().replace(/-/g, '')}`
-  return {
-    id: callId,
-    type: 'function',
-    function: {
-      name: entry.name || entry.function?.name || '',
-      arguments: typeof entry.arguments === 'string'
-        ? entry.arguments
-        : serializeJsonish(entry.arguments || entry.function?.arguments || {}),
-    },
-  }
-}
-
-export function translateResponsesToOpenAI(body) {
-  if (!body || typeof body !== 'object') return { model: '', messages: [], stream: false }
-
-  const messages = []
-
-  if (typeof body.instructions === 'string' && body.instructions.trim()) {
-    messages.push({ role: 'system', content: body.instructions.trim() })
-  }
-
-  const inputItems = Array.isArray(body.input)
-    ? body.input
-    : body.input != null
-      ? [body.input]
-      : []
-
-  for (const item of inputItems) {
-    if (typeof item === 'string') {
-      messages.push({ role: 'user', content: item })
-      continue
-    }
-    if (!item || typeof item !== 'object') continue
-
-    if (item.type === 'function_call') {
-      messages.push({ role: 'assistant', content: null, tool_calls: [makeFunctionToolCall(item)] })
-      continue
-    }
-
-    if (item.type === 'function_call_output') {
-      messages.push({
-        role: 'tool',
-        tool_call_id: item.call_id || item.id || '',
-        content: serializeJsonish(item.output),
-      })
-      continue
-    }
-
-    if (item.type === 'input_text' && typeof item.text === 'string') {
-      messages.push({ role: 'user', content: item.text })
-      continue
-    }
-
-    if (item.type !== 'message') continue
-
-    const role = item.role === 'assistant'
-      ? 'assistant'
-      : (item.role === 'developer' || item.role === 'system')
-          ? 'system'
-          : 'user'
-
-    const textParts = []
-    const toolCalls = []
-    for (const part of normalizeResponseContent(item.content)) {
-      if (part.type === 'function_call') {
-        toolCalls.push(makeFunctionToolCall(part))
-        continue
-      }
-      if (part.type === 'function_call_output') {
-        messages.push({
-          role: 'tool',
-          tool_call_id: part.call_id || part.id || '',
-          content: serializeJsonish(part.output),
-        })
-        continue
-      }
-      const text = contentPartToText(part)
-      if (text) textParts.push(text)
-    }
-
-    if (toolCalls.length > 0) {
-      messages.push({
-        role: 'assistant',
-        content: textParts.length > 0 ? textParts.join('\n') : null,
-        tool_calls: toolCalls,
-      })
-      continue
-    }
-
-    pushTextMessage(messages, role, textParts)
-  }
-
-  const result = {
-    model: body.model,
-    messages,
-    stream: body.stream === true,
-  }
-
-  if (body.max_output_tokens != null) result.max_tokens = body.max_output_tokens
-  if (body.temperature != null) result.temperature = body.temperature
-  if (body.top_p != null) result.top_p = body.top_p
-
-  if (Array.isArray(body.tools) && body.tools.length > 0) {
-    result.tools = body.tools
-      .filter(tool => tool && typeof tool === 'object' && (tool.type === 'function' || typeof tool.name === 'string'))
-      .map(tool => ({
-        type: 'function',
-        function: {
-          name: tool.name || tool.function?.name || '',
-          description: tool.description || tool.function?.description || '',
-          parameters: tool.parameters || tool.input_schema || tool.function?.parameters || {},
-        },
-      }))
-  }
-
-  return result
-}
-
-function buildResponsesOutput(message = {}) {
-  const output = []
-  const text = typeof message.content === 'string' ? message.content : ''
-  if (text || !Array.isArray(message.tool_calls) || message.tool_calls.length === 0) {
-    output.push({
-      id: `msg_${randomUUID().replace(/-/g, '')}`,
-      type: 'message',
-      status: 'completed',
-      role: 'assistant',
-      content: [{ type: 'output_text', text: text || '', annotations: [] }],
-    })
-  }
-
-  if (Array.isArray(message.tool_calls)) {
-    for (const toolCall of message.tool_calls) {
-      const callId = toolCall?.id || `call_${randomUUID().replace(/-/g, '')}`
-      output.push({
-        id: callId,
-        type: 'function_call',
-        status: 'completed',
-        call_id: callId,
-        name: toolCall?.function?.name || '',
-        arguments: toolCall?.function?.arguments || '{}',
-      })
-    }
-  }
-
-  return output
-}
-
-export function translateOpenAIToResponses(openaiResponse, requestModel) {
-  const choice = openaiResponse?.choices?.[0] || {}
-  const message = choice?.message || {}
-  const inputTokens = openaiResponse?.usage?.prompt_tokens || 0
-  const outputTokens = openaiResponse?.usage?.completion_tokens || 0
-
-  return {
-    id: openaiResponse?.id || `resp_${randomUUID().replace(/-/g, '')}`,
-    object: 'response',
-    created_at: Math.floor(Date.now() / 1000),
-    status: 'completed',
-    model: requestModel || openaiResponse?.model || '',
-    output: buildResponsesOutput(message),
-    usage: {
-      input_tokens: inputTokens,
-      output_tokens: outputTokens,
-      total_tokens: inputTokens + outputTokens,
-    },
-  }
-}
-
-function createResponseSseEvent(type, payload) {
-  return `event: ${type}\ndata: ${JSON.stringify({ type, ...payload })}\n\n`
-}
-
-export function createResponsesSSETransformer(requestModel) {
-  let buffer = ''
-  let responseId = `resp_${randomUUID().replace(/-/g, '')}`
-  let messageItemId = `msg_${randomUUID().replace(/-/g, '')}`
-  let createdAt = Math.floor(Date.now() / 1000)
-  let createdSent = false
-  let messageAdded = false
-  let messageText = ''
-  let promptTokens = 0
-  let completionTokens = 0
-  const functionCalls = new Map()
-
-  const ensureStarted = (stream) => {
-    if (createdSent) return
-    createdSent = true
-    stream.push(createResponseSseEvent('response.created', {
-      response: {
-        id: responseId,
-        object: 'response',
-        created_at: createdAt,
-        status: 'in_progress',
-        model: requestModel || '',
-        output: [],
-      },
-    }))
-  }
-
-  const ensureMessageItem = (stream) => {
-    if (messageAdded) return
-    messageAdded = true
-    stream.push(createResponseSseEvent('response.output_item.added', {
-      output_index: 0,
-      item: {
-        id: messageItemId,
-        type: 'message',
-        status: 'in_progress',
-        role: 'assistant',
-        content: [{ type: 'output_text', text: '', annotations: [] }],
-      },
-    }))
-  }
-
-  const transform = new Transform({
-    transform(chunk, _encoding, callback) {
-      buffer += chunk.toString()
-      if (buffer.length > MAX_SSE_BUFFER) {
-        buffer = ''
-        return callback(new Error('Responses SSE buffer overflow'))
-      }
-
-      const lines = buffer.split('\n')
-      buffer = lines.pop() || ''
-
-      for (const line of lines) {
-        if (!line.startsWith('data: ')) continue
-        const payload = line.slice(6).trim()
-
-        if (payload === '[DONE]') {
-          ensureStarted(this)
-          ensureMessageItem(this)
-
-          const output = [{
-            id: messageItemId,
-            type: 'message',
-            status: 'completed',
-            role: 'assistant',
-            content: [{ type: 'output_text', text: messageText, annotations: [] }],
-          }]
-          this.push(createResponseSseEvent('response.output_item.done', {
-            output_index: 0,
-            item: output[0],
-          }))
-
-          const sortedCalls = [...functionCalls.entries()].sort((a, b) => a[0] - b[0])
-          for (const [index, call] of sortedCalls) {
-            const item = {
-              id: call.id,
-              type: 'function_call',
-              status: 'completed',
-              call_id: call.id,
-              name: call.name,
-              arguments: call.arguments,
-            }
-            output.push(item)
-            this.push(createResponseSseEvent('response.output_item.done', {
-              output_index: index + 1,
-              item,
-            }))
-          }
-
-          this.push(createResponseSseEvent('response.completed', {
-            response: {
-              id: responseId,
-              object: 'response',
-              created_at: createdAt,
-              status: 'completed',
-              model: requestModel || '',
-              output,
-              usage: {
-                input_tokens: promptTokens,
-                output_tokens: completionTokens,
-                total_tokens: promptTokens + completionTokens,
-              },
-            },
-          }))
-          continue
-        }
-
-        let parsed
-        try {
-          parsed = JSON.parse(payload)
-        } catch {
-          continue
-        }
-
-        if (typeof parsed.id === 'string' && parsed.id.length > 0) responseId = parsed.id
-        if (typeof parsed.model === 'string' && parsed.model.length > 0 && !requestModel) {
-          requestModel = parsed.model
-        }
-        if (parsed.usage) {
-          promptTokens = parsed.usage.prompt_tokens || promptTokens
-          completionTokens = parsed.usage.completion_tokens || completionTokens
-        }
-
-        ensureStarted(this)
-        const choice = parsed.choices?.[0]
-        if (!choice) continue
-        const delta = choice.delta || {}
-
-        if (typeof delta.content === 'string' && delta.content.length > 0) {
-          ensureMessageItem(this)
-          messageText += delta.content
-          this.push(createResponseSseEvent('response.output_text.delta', {
-            output_index: 0,
-            item_id: messageItemId,
-            content_index: 0,
-            delta: delta.content,
-          }))
-        }
-
-        if (Array.isArray(delta.tool_calls)) {
-          for (const toolCallDelta of delta.tool_calls) {
-            const callIndex = Number.isInteger(toolCallDelta.index) ? toolCallDelta.index : functionCalls.size
-            const existing = functionCalls.get(callIndex) || {
-              id: toolCallDelta.id || `call_${randomUUID().replace(/-/g, '')}`,
-              name: '',
-              arguments: '',
-              added: false,
-            }
-            if (typeof toolCallDelta.id === 'string' && toolCallDelta.id.length > 0) {
-              existing.id = toolCallDelta.id
-            }
-            if (typeof toolCallDelta.function?.name === 'string' && toolCallDelta.function.name.length > 0) {
-              existing.name = toolCallDelta.function.name
-            }
-            if (!existing.added) {
-              existing.added = true
-              this.push(createResponseSseEvent('response.output_item.added', {
-                output_index: callIndex + 1,
-                item: {
-                  id: existing.id,
-                  type: 'function_call',
-                  status: 'in_progress',
-                  call_id: existing.id,
-                  name: existing.name,
-                  arguments: existing.arguments,
-                },
-              }))
-            }
-            if (typeof toolCallDelta.function?.arguments === 'string' && toolCallDelta.function.arguments.length > 0) {
-              existing.arguments += toolCallDelta.function.arguments
-              this.push(createResponseSseEvent('response.function_call_arguments.delta', {
-                output_index: callIndex + 1,
-                item_id: existing.id,
-                delta: toolCallDelta.function.arguments,
-              }))
-            }
-            functionCalls.set(callIndex, existing)
-          }
-        }
-      }
-
-      callback()
-    },
-  })
-
-  return { transform }
-}