dsh-lcx-codex 0.3.3 → 0.4.0-rc.13

package/lib/compact-v2.js

@@ -1,307 +1,158 @@
-import { normalizeCompactionResponse } from './compact.js'
-import { fetchSseWithRetry } from './transport.js'
+import { consumeSse, fetchSseWithRetry } from './transport.js'
+import { responsesTools } from './dsh-responses.js'
 
-const REMOTE_COMPACTION_V2_FEATURE = 'remote_compaction_v2'
-const DEFAULT_MAX_SSE_BYTES = 8 * 1024 * 1024
+export const REMOTE_COMPACTION_V2_FEATURE = 'remote_compaction_v2'
 
-function isObject(value) {
-  return value !== null && typeof value === 'object' && !Array.isArray(value)
+function isObject(value) { return value !== null && typeof value === 'object' && !Array.isArray(value) }
+function fail(message, code = 'LCX_COMPACT_INVALID_RESPONSE') { const e = new Error(message); e.code = code; return e }
+function safeMachineField(value) {
+  if (typeof value !== 'string' || value.length === 0 || value.length > 96) return undefined
+  return /^[A-Za-z0-9_.:\[\]-]+$/u.test(value) ? value : undefined
 }
 
-function protocolError(message, code = 'LCX_COMPACT_INVALID_SSE') {
-  const error = new Error(message)
-  error.code = code
-  return error
-}
-
-function outputItemIdentity(event) {
-  const outputIndex = Number.isInteger(event?.output_index) && event.output_index >= 0
-    ? `index:${event.output_index}`
-    : undefined
-  const itemIds = [event?.item?.id, event?.item_id]
-    .filter((value) => typeof value === 'string' && value.length > 0)
-    .map((value) => `id:${value}`)
-  const uniqueItemIds = [...new Set(itemIds)]
-  if (uniqueItemIds.length > 1) {
-    throw protocolError('Native compaction SSE event contains conflicting item identities')
-  }
-  return { outputIndex, itemId: uniqueItemIds[0] }
-}
-
-function mergeOutputItem(event, items, recordsByIndex, recordsById) {
-  if (!isObject(event?.item)) return
-  const { outputIndex, itemId } = outputItemIdentity(event)
-  const mappedRecords = new Set()
-  if (outputIndex && recordsByIndex.has(outputIndex)) mappedRecords.add(recordsByIndex.get(outputIndex))
-  if (itemId && recordsById.has(itemId)) mappedRecords.add(recordsById.get(itemId))
-  if (mappedRecords.size > 1) {
-    throw protocolError('Native compaction SSE event maps output_index and item id to different items')
-  }
-
-  let record = mappedRecords.values().next().value
-  if (!record && event.type === 'response.output_item.done') {
-    const pending = items.filter((candidate) => !candidate.done &&
-      (!candidate.item.type || !event.item.type || candidate.item.type === event.item.type))
-    if (pending.length === 1) record = pending[0]
-    else if (pending.length > 1) {
-      throw protocolError('Native compaction SSE output item has ambiguous aliases')
-    }
-  }
-  if (!record) {
-    record = { item: {}, outputIndex: undefined, itemId: undefined, done: false }
-    items.push(record)
-  }
-
-  if (outputIndex && record.outputIndex && outputIndex !== record.outputIndex) {
-    throw protocolError('Native compaction SSE output_index changed for one item')
-  }
-  if (itemId && record.itemId && itemId !== record.itemId) {
-    throw protocolError('Native compaction SSE item id changed for one item')
-  }
-  if (outputIndex && recordsByIndex.has(outputIndex) && recordsByIndex.get(outputIndex) !== record) {
-    throw protocolError('Native compaction SSE output_index is reused by different items')
-  }
-  if (itemId && recordsById.has(itemId) && recordsById.get(itemId) !== record) {
-    throw protocolError('Native compaction SSE item id is reused by different items')
-  }
-
-  const previousEncryptedContent = typeof record.item.encrypted_content === 'string' && record.item.encrypted_content.length > 0
-    ? record.item.encrypted_content
-    : undefined
-  Object.assign(record.item, structuredClone(event.item))
-  if ((!record.item.encrypted_content || typeof record.item.encrypted_content !== 'string') && previousEncryptedContent) {
-    record.item.encrypted_content = previousEncryptedContent
-  }
-  if (outputIndex) {
-    record.outputIndex = outputIndex
-    recordsByIndex.set(outputIndex, record)
-  }
-  if (itemId) {
-    record.itemId = itemId
-    recordsById.set(itemId, record)
-  }
-  if (event.type === 'response.output_item.done') record.done = true
+export function mergeFeatureHeader(headers = {}) {
+  const result = { ...headers }
+  const key = Object.keys(result).find((name) => name.toLowerCase() === 'x-codex-beta-features')
+  const values = String(key ? result[key] ?? '' : '').split(',').map((x) => x.trim()).filter(Boolean)
+  if (!values.includes(REMOTE_COMPACTION_V2_FEATURE)) values.push(REMOTE_COMPACTION_V2_FEATURE)
+  result[key ?? 'x-codex-beta-features'] = values.join(',')
+  return result
 }
 
-function validCompletedOutput(output) {
-  if (!Array.isArray(output)) return false
-  try {
-    normalizeCompactionResponse({ object: 'response.compaction', output })
-    return true
-  } catch {
-    return false
+export function responsesGenerationEnvelope({ reasoningEffort, temperature, maxTokens } = {}) {
+  const result = {}
+  if (reasoningEffort !== undefined && reasoningEffort !== 'off') {
+    result.reasoning = { effort: String(reasoningEffort), summary: 'auto' }
+    result.include = ['reasoning.encrypted_content']
   }
-}
-
-function usageFrom(response) {
-  const usage = response?.usage
-  if (!isObject(usage)) return undefined
-  const totalInputTokens = Number(usage.input_tokens ?? 0)
-  const outputTokens = Number(usage.output_tokens ?? 0)
-  const cacheReadValue = Number(usage.input_tokens_details?.cached_tokens ?? usage.input_token_details?.cached_tokens ?? usage.prompt_tokens_details?.cached_tokens ?? 0)
-  const cacheWriteValue = Number(usage.input_tokens_details?.cache_write_tokens ?? usage.input_token_details?.cache_write_tokens ?? usage.prompt_tokens_details?.cache_write_tokens ?? 0)
-  const cacheReadTokens = Number.isFinite(cacheReadValue) && cacheReadValue > 0 ? cacheReadValue : 0
-  const cacheWriteTokens = Number.isFinite(cacheWriteValue) && cacheWriteValue > 0 ? cacheWriteValue : 0
-  const inputTokens = Number.isFinite(totalInputTokens)
-    ? Math.max(0, totalInputTokens - cacheReadTokens - cacheWriteTokens)
-    : 0
-  const normalizedOutputTokens = Number.isFinite(outputTokens) && outputTokens > 0 ? outputTokens : 0
-  if (![inputTokens, cacheReadTokens, cacheWriteTokens, normalizedOutputTokens].some((value) => value > 0)) return undefined
-  return {
-    inputTokens,
-    outputTokens: normalizedOutputTokens,
-    ...(cacheReadTokens > 0 ? { cacheReadTokens } : {}),
-    ...(cacheWriteTokens > 0 ? { cacheWriteTokens } : {}),
-    ...(Number.isFinite(usage.output_token_details?.reasoning_tokens) && usage.output_token_details.reasoning_tokens > 0
-      ? { reasoningTokens: Number(usage.output_token_details.reasoning_tokens) }
-      : {}),
+  if (temperature !== undefined) {
+    if (!Number.isFinite(temperature)) throw fail('Responses temperature must be finite', 'LCX_COMPACT_INVALID_INPUT')
+    result.temperature = Number(temperature)
   }
-}
-
-function validToolDeclaration(tool) {
-  if (!isObject(tool)) return false
-  if (tool.type === undefined) return typeof tool.name === 'string' && tool.name.length > 0
-  if (typeof tool.type !== 'string' || tool.type.length === 0) return false
-  if (tool.type === 'function' || tool.type === 'custom') {
-    const name = tool.name ?? tool.function?.name
-    return typeof name === 'string' && name.length > 0
+  if (maxTokens !== undefined) {
+    if (!Number.isSafeInteger(maxTokens) || maxTokens <= 0) throw fail('Responses maxTokens must be a positive safe integer', 'LCX_COMPACT_INVALID_INPUT')
+    result.max_output_tokens = Math.max(16, maxTokens)
   }
-  return true
-}
-
-export function responsesTools(tools) {
-  if (tools === undefined) return undefined
-  if (!Array.isArray(tools) || !tools.every(validToolDeclaration)) {
-    throw protocolError('Native compaction tools contain an invalid declaration', 'LCX_COMPACT_INVALID_TOOLS')
-  }
-  return tools.map((tool) => {
-    if (tool.type !== undefined) return structuredClone(tool)
-    return {
-      type: 'function',
-      ...structuredClone(tool),
-      description: typeof tool.description === 'string' ? tool.description : '',
-      parameters: tool.parameters && typeof tool.parameters === 'object' ? structuredClone(tool.parameters) : { type: 'object', properties: {} },
-      strict: false,
-    }
-  })
-}
-
-export function mergeFeatureHeader(headers) {
-  const result = { ...(headers ?? {}) }
-  const key = Object.keys(result).find((name) => name.toLowerCase() === 'x-codex-beta-features')
-  const existing = key ? String(result[key] ?? '').trim() : ''
-  const features = existing.split(',').map((value) => value.trim()).filter(Boolean)
-  if (!features.includes(REMOTE_COMPACTION_V2_FEATURE)) features.push(REMOTE_COMPACTION_V2_FEATURE)
-  result[key ?? 'x-codex-beta-features'] = features.join(',')
   return result
 }
 
-export function buildNativeCompactionBody({ model, input, instructions, promptCacheKey, promptCacheRetention, tools }) {
-  if (!Array.isArray(input)) throw protocolError('Native compaction input must be an array', 'LCX_COMPACT_INVALID_INPUT')
-  if (input.some((item) => isObject(item) && item.type === 'compaction_trigger')) {
-    throw protocolError('Native compaction input already contains compaction_trigger', 'LCX_COMPACT_DUPLICATE_TRIGGER')
-  }
+export function buildNativeCompactionBody({ model, input, instructions, tools, promptCacheKey, promptCacheRetention, reasoningEffort, temperature, maxTokens }) {
+  if (!Array.isArray(input)) throw fail('native compaction input must be an array', 'LCX_COMPACT_INVALID_INPUT')
+  if (input.some((item) => item?.type === 'compaction_trigger')) throw fail('native compaction input already contains compaction_trigger', 'LCX_COMPACT_DUPLICATE_TRIGGER')
   const nativeTools = responsesTools(tools)
   return {
     model,
     input: [...structuredClone(input), { type: 'compaction_trigger' }],
     stream: true,
     store: false,
+    tool_choice: 'auto',
+    parallel_tool_calls: true,
+    ...(instructions !== undefined ? { instructions } : {}),
     ...(nativeTools !== undefined ? { tools: nativeTools } : {}),
-    ...(instructions !== undefined ? { instructions: structuredClone(instructions) } : {}),
-    ...(promptCacheKey !== undefined && promptCacheKey !== null ? { prompt_cache_key: String(promptCacheKey) } : {}),
-    ...(promptCacheRetention !== undefined && promptCacheRetention !== null ? { prompt_cache_retention: String(promptCacheRetention) } : {}),
+    ...(promptCacheKey ? { prompt_cache_key: String(promptCacheKey) } : {}),
+    ...(promptCacheRetention ? { prompt_cache_retention: String(promptCacheRetention) } : {}),
+    ...responsesGenerationEnvelope({ reasoningEffort, temperature, maxTokens }),
   }
 }
 
-function parseSseEvent(dataLines) {
-  if (dataLines.length === 0) return undefined
-  const data = dataLines.join('\n')
-  if (data === '[DONE]') return undefined
-  try {
-    const parsed = JSON.parse(data)
-    if (!isObject(parsed)) throw new Error('SSE event is not an object')
-    return parsed
-  } catch (error) {
-    throw protocolError(`Native compaction returned malformed SSE JSON: ${String(error)}`)
-  }
+function usageFrom(raw) {
+  if (!isObject(raw)) return undefined
+  const inputTotal = Number(raw.input_tokens ?? 0)
+  const output = Number(raw.output_tokens ?? 0)
+  const details = raw.input_tokens_details ?? raw.input_token_details ?? raw.prompt_tokens_details ?? {}
+  const cacheRead = Number(details.cached_tokens ?? 0)
+  const cacheWrite = Number(details.cache_write_tokens ?? 0)
+  const result = {
+    inputTokens: Math.max(0, Number.isFinite(inputTotal) ? inputTotal - (Number.isFinite(cacheRead) ? cacheRead : 0) - (Number.isFinite(cacheWrite) ? cacheWrite : 0) : 0),
+    outputTokens: Number.isFinite(output) && output > 0 ? output : 0,
+  }
+  if (Number.isFinite(cacheRead) && cacheRead > 0) result.cacheReadTokens = cacheRead
+  if (Number.isFinite(cacheWrite) && cacheWrite > 0) result.cacheWriteTokens = cacheWrite
+  const reasoning = Number(raw.output_tokens_details?.reasoning_tokens ?? raw.output_token_details?.reasoning_tokens ?? 0)
+  if (Number.isFinite(reasoning) && reasoning > 0) result.reasoningTokens = reasoning
+  return Object.values(result).some((v) => Number(v) > 0) ? result : undefined
 }
 
-export async function parseNativeCompactionSse(response, options = {}) {
-  if (!response?.body) throw protocolError('Native compaction response did not include an SSE body', 'LCX_INVALID_SSE')
-  const maxBytes = options.maxResponseBytes ?? DEFAULT_MAX_SSE_BYTES
-  const reader = response.body.getReader()
-  const decoder = new TextDecoder()
-  const eventItems = []
-  const recordsByIndex = new Map()
-  const recordsById = new Map()
-  let completedResponse
-  let completedOutput
-  let pending = ''
-  let dataLines = []
-  let bytes = 0
-  let sawTerminal = false
-
-  const dispatch = () => {
-    const event = parseSseEvent(dataLines)
-    dataLines = []
-    if (!event) return
-    if (event.type === 'error' || event.type === 'response.failed' || event.type === 'response.incomplete') {
-      const message = event.error?.message ?? event.response?.error?.message ?? `Native compaction ended with ${String(event.type)}`
-      throw protocolError(message, 'LCX_COMPACT_UPSTREAM_ERROR')
-    }
-    if (event.type === 'response.output_item.added' || event.type === 'response.output_item.done') {
-      mergeOutputItem(event, eventItems, recordsByIndex, recordsById)
-    }
-    if (event.type === 'response.completed') {
-      sawTerminal = true
-      completedResponse = isObject(event.response) ? event.response : {}
-      completedOutput = Array.isArray(completedResponse.output) ? structuredClone(completedResponse.output) : undefined
+function validateOutput(output) {
+  if (!Array.isArray(output) || output.length === 0) throw fail('native compaction output is empty')
+  const compactions = output.filter((item) => isObject(item) && item.type === 'compaction')
+  if (compactions.length !== 1) throw fail(`native compaction must return exactly one compaction item, got ${compactions.length}`)
+  const compact = compactions[0]
+  if (typeof compact.encrypted_content !== 'string' || compact.encrypted_content.length === 0) throw fail('native compaction item has no encrypted_content')
+  const calls = new Set()
+  const results = new Set()
+  for (const item of output) {
+    if (!isObject(item) || typeof item.type !== 'string') throw fail('native compaction output contains a malformed item')
+    if (item.type === 'function_call') {
+      if (typeof item.call_id !== 'string' || !item.call_id || calls.has(item.call_id)) throw fail('native compaction output contains an invalid function_call')
+      calls.add(item.call_id)
+    } else if (item.type === 'function_call_output') {
+      if (typeof item.call_id !== 'string' || !item.call_id || results.has(item.call_id)) throw fail('native compaction output contains an invalid function_call_output')
+      results.add(item.call_id)
     }
   }
+  for (const id of calls) if (!results.has(id)) throw fail(`native compaction output has orphan function_call ${id}`)
+  for (const id of results) if (!calls.has(id)) throw fail(`native compaction output has orphan function_call_output ${id}`)
+  return { output: structuredClone(output), compaction: structuredClone(compact) }
+}
 
-  try {
-    while (true) {
-      if (options.signal?.aborted) throw options.signal.reason ?? new Error('request aborted')
-      const result = await reader.read()
-      if (result.done) break
-      bytes += result.value.byteLength
-      if (bytes > maxBytes) throw protocolError(`Native compaction SSE response exceeds ${maxBytes} bytes`, 'LCX_RESPONSE_TOO_LARGE')
-      pending += decoder.decode(result.value, { stream: true })
-      let newline
-      while ((newline = pending.indexOf('\n')) >= 0) {
-        const line = pending.slice(0, newline).replace(/\r$/u, '')
-        pending = pending.slice(newline + 1)
-        if (line === '') dispatch()
-        else if (!line.startsWith(':')) {
-          if (line.startsWith('data:')) dataLines.push(line.slice(5).replace(/^ /u, ''))
-        }
-      }
-    }
-    pending += decoder.decode()
-    if (pending.length > 0) {
-      const line = pending.replace(/\r$/u, '')
-      if (line.startsWith('data:')) dataLines.push(line.slice(5).replace(/^ /u, ''))
+export async function parseNativeCompactionSse(response, options = {}) {
+  const byIndex = new Map()
+  const byId = new Map()
+  let terminal
+  const mergeItem = (event) => {
+    if (!isObject(event?.item)) return
+    const index = Number.isInteger(event.output_index) ? event.output_index : undefined
+    const id = typeof event.item.id === 'string' ? event.item.id : typeof event.item_id === 'string' ? event.item_id : undefined
+    let record = (index !== undefined ? byIndex.get(index) : undefined) ?? (id ? byId.get(id) : undefined)
+    if (!record) record = {}
+    const encrypted = record.encrypted_content
+    Object.assign(record, structuredClone(event.item))
+    if (typeof record.encrypted_content !== 'string' && typeof encrypted === 'string') record.encrypted_content = encrypted
+    if (index !== undefined) byIndex.set(index, record)
+    if (id) byId.set(id, record)
+  }
+  await consumeSse(response, (event) => {
+    if (!isObject(event)) return
+    if (event.type === 'error' || event.type === 'response.failed' || event.type === 'response.incomplete') {
+      const upstream = event.type === 'response.failed' ? event.response?.error : event.error
+      const providerCode = safeMachineField(upstream?.code)
+      const providerType = safeMachineField(upstream?.type)
+      const providerParam = safeMachineField(upstream?.param)
+      const diagnostics = [
+        providerCode ? `providerCode=${providerCode}` : '',
+        providerType ? `providerType=${providerType}` : '',
+        providerParam ? `providerParam=${providerParam}` : '',
+      ].filter(Boolean).join(' ')
+      const e = fail(`native compaction ended with ${event.type}${diagnostics ? ` ${diagnostics}` : ''}`, 'LCX_COMPACT_UPSTREAM_ERROR')
+      if (Number.isInteger(upstream?.status ?? event.error?.status)) e.status = upstream?.status ?? event.error?.status
+      if (providerCode) e.providerCode = providerCode
+      if (providerType) e.providerType = providerType
+      if (providerParam) e.providerParam = providerParam
+      throw e
     }
-    dispatch()
-  } finally {
-    await reader.cancel().catch(() => undefined)
-  }
-
-  if (!sawTerminal || !completedResponse) {
-    throw protocolError('Native compaction SSE ended without response.completed', 'LCX_COMPACT_INCOMPLETE_SSE')
-  }
-
-  if (completedResponse.object !== undefined && !['response.compaction', 'response'].includes(completedResponse.object)) {
-    throw protocolError(`Native compaction returned unexpected response object: ${String(completedResponse.object)}`, 'LCX_COMPACT_INVALID_RESPONSE')
-  }
-  const mergedEventOutput = eventItems.map((record) => record.item)
-  const output = validCompletedOutput(completedOutput) ? completedOutput : mergedEventOutput
-  const normalized = normalizeCompactionResponse({
-    object: completedResponse.object ?? 'response.compaction',
-    id: typeof completedResponse.id === 'string' ? completedResponse.id : undefined,
-    output,
-  })
+    if (event.type === 'response.output_item.added' || event.type === 'response.output_item.done') mergeItem(event)
+    if (event.type === 'response.completed') terminal = event.response
+  }, options)
+  if (!isObject(terminal)) throw fail('native compaction stream ended without response.completed', 'LCX_COMPACT_INCOMPLETE_SSE')
+  if (terminal.status !== 'completed') throw fail('native compaction response.completed did not carry completed status', 'LCX_COMPACT_INCOMPLETE_SSE')
+  const eventItems = [...new Set([...byIndex.values(), ...byId.values()])]
+  const output = Array.isArray(terminal.output) && terminal.output.length > 0 ? terminal.output : eventItems
+  const normalized = validateOutput(output)
   return {
+    object: terminal.object ?? 'response.compaction',
+    ...(typeof terminal.id === 'string' ? { id: terminal.id } : {}),
     ...normalized,
-    usage: usageFrom(completedResponse),
+    usage: usageFrom(terminal.usage),
   }
 }
 
-export async function requestNativeCompaction({
-  baseURL,
-  model,
-  input,
-  instructions,
-  promptCacheKey,
-  promptCacheRetention,
-  idempotencyKey,
-  tools,
-  headers,
-  signal,
-  timeoutMs,
-  maxAttempts,
-  maxResponseBytes,
-}) {
-  const body = buildNativeCompactionBody({ model, input, instructions, promptCacheKey, promptCacheRetention, tools })
-  const requestHeaders = { ...(headers ?? {}) }
-  if (idempotencyKey !== undefined && idempotencyKey !== null && !Object.keys(requestHeaders).some((name) => name.toLowerCase() === 'idempotency-key')) {
-    requestHeaders['idempotency-key'] = String(idempotencyKey)
-  }
-  const featureHeaders = mergeFeatureHeader(requestHeaders)
-  return fetchSseWithRetry(
-    `${String(baseURL).replace(/\/+$/u, '')}/responses`,
-    body,
-    featureHeaders,
-    signal,
-    timeoutMs,
-    {
-      maxAttempts,
-      maxResponseBytes,
-      consume: (response, consumeOptions = {}) => parseNativeCompactionSse(response, {
-        signal: consumeOptions.requestSignal ?? signal,
-        maxResponseBytes,
-      }),
-    },
-  )
+export async function requestNativeCompaction({ baseURL, model, input, instructions, tools, promptCacheKey, promptCacheRetention, reasoningEffort, temperature, maxTokens, idempotencyKey, headers, signal, timeoutMs, maxAttempts, maxResponseBytes }) {
+  const body = buildNativeCompactionBody({ model, input, instructions, tools, promptCacheKey, promptCacheRetention, reasoningEffort, temperature, maxTokens })
+  const requestHeaders = mergeFeatureHeader({ ...headers, ...(idempotencyKey ? { 'idempotency-key': String(idempotencyKey) } : {}) })
+  return fetchSseWithRetry(`${String(baseURL).replace(/\/+$/u, '')}/responses`, body, requestHeaders, signal, timeoutMs, {
+    maxAttempts,
+    maxResponseBytes,
+    consume: (response, consumeOptions) => parseNativeCompactionSse(response, { signal: consumeOptions.requestSignal ?? signal, maxResponseBytes }),
+  })
 }