dsh-lcx-codex 0.3.0

package/lib/client.js

@@ -0,0 +1,248 @@
+window.__ModuleLoader__.load({
+  id: 'dsh-lcx-codex',
+  factory: (require) => {
+    const module = { exports: {} }
+    const exports = module.exports
+    const React = require('react')
+    const { createSnapshotStore } = require('@deepseek-ai/dsh-client-runtime/client')
+
+    const NAMESPACE = 'lcx-codex'
+    const DEFAULTS = {
+      enabled: false,
+      webSearch: false,
+      alphaSearch: false,
+      remoteCompaction: false,
+      fallbackToBasicCompaction: true,
+      provider: 'lcx',
+      baseURL: 'https://api.lcxbot.com/v1',
+      apiKeyEnv: 'LCX_API_KEY',
+      model: 'gpt-5.6-sol',
+      compactTransport: 'native-v2',
+    }
+
+    const css = `
+      .lcx-card{border:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-layer-3);border-radius:12px;list-style:none}
+      .lcx-card-head{width:100%;display:flex;align-items:center;gap:12px;padding:14px 16px;border:0;background:transparent;color:inherit;text-align:left;font:inherit;cursor:pointer;border-radius:12px}
+      .lcx-card-head:hover{background:var(--dsw-alias-interactive-bg-hover)}
+      .lcx-card-title{display:flex;flex-direction:column;gap:4px;flex:1;min-width:0}
+      .lcx-card-title strong{font-size:15px}.lcx-card-title span,.lcx-help{font-size:12px;line-height:18px;color:var(--dsw-alias-label-tertiary)}
+      .lcx-card-body{border-top:1px solid var(--dsw-alias-border-l2);padding:14px 16px 10px}
+      .lcx-row{display:flex;align-items:flex-start;gap:9px;padding:9px 0}.lcx-row input[type=checkbox]{margin-top:3px;accent-color:var(--dsw-alias-brand-primary)}
+      .lcx-row label{font-size:13px;color:var(--dsw-alias-label-primary);line-height:19px}.lcx-row small{display:block;color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:17px}
+      .lcx-fields{display:grid;grid-template-columns:1fr 1fr;gap:10px;margin-top:8px}.lcx-field{display:flex;flex-direction:column;gap:5px}.lcx-field label{font-size:12px;color:var(--dsw-alias-label-secondary)}
+      .lcx-input{width:100%;box-sizing:border-box;border:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-layer-3);color:var(--dsw-alias-label-primary);border-radius:8px;padding:7px 9px;font:inherit;font-size:12px}.lcx-input:disabled{color:var(--dsw-alias-label-tertiary)}
+      .lcx-footer{display:flex;align-items:center;justify-content:flex-end;gap:8px;border-top:1px solid var(--dsw-alias-border-l2);padding:12px 0 4px}.lcx-footer button{border:1px solid var(--dsw-alias-border-l2);border-radius:8px;padding:6px 14px;background:transparent;color:var(--dsw-alias-label-primary);font:inherit;font-size:13px;cursor:pointer}.lcx-footer button.primary{background:var(--dsw-alias-state-business-primary);border-color:transparent;color:var(--dsw-alias-label-primary-inverted)}.lcx-footer button:disabled{opacity:.5;cursor:default}.lcx-error{flex:1;color:var(--dsw-alias-state-error-primary);font-size:12px}
+      @media(max-width:640px){.lcx-fields{grid-template-columns:1fr}}
+    `
+    if (typeof document !== 'undefined' && document.querySelector('style[data-plugin-css="dsh-lcx-codex"]') === null) {
+      const tag = document.createElement('style')
+      tag.dataset.plugin = 'dsh-lcx-codex'
+      tag.dataset.pluginCss = 'dsh-lcx-codex'
+      tag.textContent = css
+      document.head.appendChild(tag)
+    }
+
+    const copy = {
+      zh: {
+        title: 'Responses / Codex 能力',
+        description: '可选的 hosted Web Search 与 Responses 原生远程压缩。',
+        enabled: '启用 LCX/Codex 能力',
+        enabledHelp: '关闭时不改变当前模型、搜索提供方或压缩流程。',
+        webSearch: '启用 Responses Hosted 搜索（websearch_gpt）',
+        webSearchHelp: '开启后，模型可调用 websearch_gpt；插件通过 Responses /responses + web_search 执行结构化 hosted 搜索并返回来源。',
+        alphaSearch: '启用 Alpha command 搜索（websearch_alpha）',
+        alphaSearchHelp: '仅当当前 endpoint、provider、model 和 schema 的 capability probe 已通过时注册；PAT 模拟或未知能力不会暴露该工具。',
+        compaction: '启用 GPT 专属原生远程压缩',
+        compactionHelp: '只适用于兼容 Responses 的 GPT 路由；使用与 Sub2API 压缩测试一致的 native V2（/responses + compaction_trigger），保存完整 output 并在后续请求中回放。Legacy compact transport 已不支持，相关配置会被拒绝。',
+        fallback: 'native 压缩失败时回退 DSH 普通压缩',
+        fallbackHelp: '推荐开启：首次远程压缩失败且尚未生成 checkpoint 时，继续使用 DSH 原有压缩。已有 native checkpoint 的回放失败仍会明确报错。',
+        endpoint: '旧版回退 Responses 地址',
+        model: '默认 Hosted / Alpha 模型',
+        save: '保存',
+        saving: '保存中…',
+        discard: '放弃修改',
+        unsaved: '未保存',
+        readOnly: '当前部署的设置为只读。',
+        unavailable: '此插件的设置服务暂不可用。',
+        saveFailed: '保存失败，请重试。',
+        hint: '请求优先复用当前 DSH openai-responses 模型的地址与凭据；这里的地址仅用于旧版直连兼容。Hosted 与 Alpha 不会互相静默降级。',
+      },
+      en: {
+        title: 'Responses / Codex capabilities',
+        description: 'Optional hosted Web Search and native Responses compaction.',
+        enabled: 'Enable LCX/Codex capabilities',
+        enabledHelp: 'When off, the current model, search provider, and compaction flow are unchanged.',
+        webSearch: 'Enable Responses Hosted search (websearch_gpt)',
+        webSearchHelp: 'When on, the model can call websearch_gpt through Responses /responses + web_search with structured hosted-search controls and citations.',
+        alphaSearch: 'Enable Alpha command search (websearch_alpha)',
+        alphaSearchHelp: 'Registered only after a capability probe matches the current endpoint, provider, model, and schema. PAT emulation and unknown capabilities remain hidden.',
+        compaction: 'Enable GPT-only native remote compaction',
+        compactionHelp: 'Works only on a compatible Responses GPT route; uses the native V2 request used by Sub2API compact tests (/responses + compaction_trigger), stores the complete output, and replays it. Legacy compact transport is unsupported and rejected.',
+        fallback: 'Fall back to normal DSH compaction on native failure',
+        fallbackHelp: 'Recommended: if the first native request fails before a checkpoint is saved, use the existing DSH compaction. Replay failures for an existing native checkpoint still report an error.',
+        endpoint: 'Legacy fallback Responses endpoint',
+        model: 'Default Hosted / Alpha model',
+        save: 'Save',
+        saving: 'Saving…',
+        discard: 'Discard',
+        unsaved: 'Unsaved',
+        readOnly: 'This deployment stores settings read-only.',
+        unavailable: 'This plugin settings service is unavailable.',
+        saveFailed: 'Save failed; please try again.',
+        hint: 'Requests prefer the active DSH openai-responses model route and credential; this endpoint is only a legacy direct-route fallback. Hosted and Alpha never silently fall back to each other.',
+      },
+    }
+
+    function language() {
+      return String(globalThis.navigator?.language ?? '').toLowerCase().startsWith('zh') ? 'zh' : 'en'
+    }
+
+    function valueFrom(snapshot) {
+      return { ...DEFAULTS, ...(snapshot.value ?? {}) }
+    }
+
+    class SettingsController {
+      constructor(scope) {
+        this.scope = scope
+        this.draft = null
+        this.dirty = false
+        this.saving = false
+        this.failed = false
+        this.listeners = new Set()
+        this.store = createSnapshotStore(this.projection())
+        this.stop = scope.subscribe(() => {
+          if (!this.dirty) this.draft = null
+          this.publish()
+        })
+      }
+
+      snapshot() { return this.scope.getSnapshot() }
+      value() { return valueFrom(this.snapshot()) }
+      draftValue() { return { ...this.value(), ...(this.draft ?? {}) } }
+      field(name) { return this.draftValue()[name] }
+      overridden(name) { return Object.prototype.hasOwnProperty.call(this.snapshot().user ?? {}, name) }
+      projection() {
+        const snapshot = this.snapshot()
+        return {
+          available: snapshot.status === 'ready',
+          writable: snapshot.writable,
+          dirty: this.dirty,
+          saving: this.saving,
+          failed: this.failed,
+          enabled: { value: Boolean(this.field('enabled')), overridden: this.overridden('enabled') },
+          webSearch: { value: Boolean(this.field('webSearch')), overridden: this.overridden('webSearch') },
+          alphaSearch: { value: Boolean(this.field('alphaSearch')), overridden: this.overridden('alphaSearch') },
+          remoteCompaction: { value: Boolean(this.field('remoteCompaction')), overridden: this.overridden('remoteCompaction') },
+          fallbackToBasicCompaction: { value: this.field('fallbackToBasicCompaction') !== false, overridden: this.overridden('fallbackToBasicCompaction') },
+          baseURL: String(this.field('baseURL') ?? ''),
+          model: String(this.field('model') ?? ''),
+          hint: language() === 'zh' ? copy.zh.hint : copy.en.hint,
+        }
+      }
+      bind() { return this.store }
+      subscribe(listener) { this.listeners.add(listener); return () => this.listeners.delete(listener) }
+      publish() {
+        this.store.set(this.projection())
+        for (const listener of this.listeners) listener()
+      }
+      edit(field, value) {
+        this.draft = { ...(this.draft ?? this.value()), [field]: value }
+        this.dirty = true
+        this.failed = false
+        this.publish()
+      }
+      discard() {
+        this.draft = null
+        this.dirty = false
+        this.failed = false
+        this.publish()
+      }
+      async save() {
+        if (!this.dirty || this.saving || !this.snapshot().writable) return
+        const next = this.draftValue()
+        const previous = this.value()
+        const changes = Object.keys(next).filter((field) => next[field] !== previous[field])
+        this.saving = true
+        this.failed = false
+        this.publish()
+        try {
+          for (const field of changes) await this.scope.set(field, next[field])
+          this.draft = null
+          this.dirty = false
+        } catch {
+          this.failed = true
+        } finally {
+          this.saving = false
+          this.publish()
+        }
+      }
+      inject() { return { hooks: { lcxCard: this.bind() }, ...this.actions() } }
+      actions() {
+        return {
+          edit: (field, value) => this.edit(field, value),
+          save: () => { void this.save() },
+          discard: () => this.discard(),
+        }
+      }
+    }
+
+    function CheckRow({ id, label, help, checked, disabled, onChange }) {
+      return React.createElement('div', { className: 'lcx-row' },
+        React.createElement('input', { id, type: 'checkbox', checked, disabled, onChange: (event) => onChange(event.target.checked) }),
+        React.createElement('label', { htmlFor: id }, label, React.createElement('small', null, help)),
+      )
+    }
+
+    function LcxCard(props) {
+      const t = copy[language()]
+      const state = props.useLcxCard((snapshot) => snapshot)
+      const [open, setOpen] = React.useState(false)
+      if (!state.available) return null
+      const disabled = !state.writable || state.saving
+      return React.createElement('li', { className: 'lcx-card' },
+        React.createElement('button', { className: 'lcx-card-head', type: 'button', 'aria-expanded': open, onClick: () => setOpen(!open) },
+          React.createElement('span', { className: 'lcx-card-title' }, React.createElement('strong', null, t.title), React.createElement('span', null, t.description)),
+          state.dirty ? React.createElement('span', null, t.unsaved) : null,
+          React.createElement('span', null, open ? '⌃' : '⌄'),
+        ),
+        open ? React.createElement('div', { className: 'lcx-card-body' },
+          React.createElement(CheckRow, { id: 'lcx-enabled', label: t.enabled, help: t.enabledHelp, checked: state.enabled.value, disabled, onChange: (value) => props.edit('enabled', value) }),
+          React.createElement(CheckRow, { id: 'lcx-web-search', label: t.webSearch, help: t.webSearchHelp, checked: state.webSearch.value, disabled: disabled || !state.enabled.value, onChange: (value) => props.edit('webSearch', value) }),
+          React.createElement(CheckRow, { id: 'lcx-alpha-search', label: t.alphaSearch, help: t.alphaSearchHelp, checked: state.alphaSearch.value, disabled: disabled || !state.enabled.value, onChange: (value) => props.edit('alphaSearch', value) }),
+          React.createElement(CheckRow, { id: 'lcx-compaction', label: t.compaction, help: t.compactionHelp, checked: state.remoteCompaction.value, disabled: disabled || !state.enabled.value, onChange: (value) => props.edit('remoteCompaction', value) }),
+          React.createElement(CheckRow, { id: 'lcx-fallback', label: t.fallback, help: t.fallbackHelp, checked: state.fallbackToBasicCompaction.value, disabled: disabled || !state.enabled.value || !state.remoteCompaction.value, onChange: (value) => props.edit('fallbackToBasicCompaction', value) }),
+          React.createElement('div', { className: 'lcx-fields' },
+            React.createElement('div', { className: 'lcx-field' }, React.createElement('label', { htmlFor: 'lcx-endpoint' }, t.endpoint), React.createElement('input', { id: 'lcx-endpoint', className: 'lcx-input', value: state.baseURL, disabled, onChange: (event) => props.edit('baseURL', event.target.value) })),
+            React.createElement('div', { className: 'lcx-field' }, React.createElement('label', { htmlFor: 'lcx-model' }, t.model), React.createElement('input', { id: 'lcx-model', className: 'lcx-input', value: state.model, disabled, onChange: (event) => props.edit('model', event.target.value) })),
+          ),
+          React.createElement('p', { className: 'lcx-help' }, state.hint),
+          React.createElement('div', { className: 'lcx-footer' },
+            state.failed ? React.createElement('span', { className: 'lcx-error' }, t.saveFailed) : null,
+            React.createElement('button', { type: 'button', disabled: !state.dirty || disabled, onClick: props.discard }, t.discard),
+            React.createElement('button', { className: 'primary', type: 'button', disabled: !state.dirty || disabled, onClick: props.save }, state.saving ? t.saving : t.save),
+          ),
+        ) : null,
+      )
+    }
+
+    const inject = ['slots', 'locale', 'settingsScope']
+
+    function apply(ctx) {
+      const slots = ctx.slots ?? ctx.get('slots')
+      const scopeService = ctx.settingsScope ?? ctx.get('settingsScope')
+      if (slots === undefined || scopeService === undefined) return
+      const scope = scopeService.bind({ namespace: NAMESPACE })
+      const controller = new SettingsController(scope)
+      slots.inject('settings.plugin.item', () => slots.register({
+        name: 'settings.plugin.item',
+        key: NAMESPACE,
+        inject: () => controller.inject(),
+      }, LcxCard))
+      ctx.effect(() => () => controller.stop(), 'lcx-codex: settings card')
+    }
+
+    exports.apply = apply
+    exports.inject = inject
+    return module.exports
+  },
+})

package/lib/compact-v2.js

@@ -0,0 +1,305 @@
+import { normalizeCompactionResponse } from './compact.js'
+import { fetchSseWithRetry } from './transport.js'
+
+const REMOTE_COMPACTION_V2_FEATURE = 'remote_compaction_v2'
+const DEFAULT_MAX_SSE_BYTES = 8 * 1024 * 1024
+
+function isObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+}
+
+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
+}
+
+function validCompletedOutput(output) {
+  if (!Array.isArray(output)) return false
+  try {
+    normalizeCompactionResponse({ object: 'response.compaction', output })
+    return true
+  } catch {
+    return false
+  }
+}
+
+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) }
+      : {}),
+  }
+}
+
+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
+  }
+  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, 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')
+  }
+  const nativeTools = responsesTools(tools)
+  return {
+    model,
+    input: [...structuredClone(input), { type: 'compaction_trigger' }],
+    stream: true,
+    store: false,
+    ...(nativeTools !== undefined ? { tools: nativeTools } : {}),
+    ...(instructions !== undefined ? { instructions: structuredClone(instructions) } : {}),
+    ...(promptCacheKey !== undefined && promptCacheKey !== null ? { prompt_cache_key: String(promptCacheKey) } : {}),
+  }
+}
+
+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)}`)
+  }
+}
+
+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
+    }
+  }
+
+  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, ''))
+    }
+    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,
+  })
+  return {
+    ...normalized,
+    usage: usageFrom(completedResponse),
+  }
+}
+
+export async function requestNativeCompaction({
+  baseURL,
+  model,
+  input,
+  instructions,
+  promptCacheKey,
+  idempotencyKey,
+  tools,
+  headers,
+  signal,
+  timeoutMs,
+  maxAttempts,
+  maxResponseBytes,
+}) {
+  const body = buildNativeCompactionBody({ model, input, instructions, promptCacheKey, 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,
+      }),
+    },
+  )
+}