@young1lin/dsh-gpt-sub 0.1.1 → 0.1.3

package/src/compaction.ts

@@ -0,0 +1,188 @@
+/** Routes Codex Subscription compaction to native Responses checkpoints. */
+import { randomUUID } from 'node:crypto'
+import { isDeepStrictEqual } from 'node:util'
+import type { Context } from '@deepseek-ai/cordis'
+import type { Agent } from '@deepseek-ai/dsh-agent'
+import type { CommandId } from '@deepseek-ai/dsh-commands/brand'
+import {
+  CompactionId, compactCheckpointSource, ManualCompactionError,
+  toolPairingBalancedAfter, toolPairingBalancedBefore,
+  type CompactionResult, type CompactionTrigger,
+} from '@deepseek-ai/dsh-compaction'
+import { BasicCompactionEngine, type BasicCompactionConfig } from '@deepseek-ai/dsh-compaction-basic'
+import { BlockAssembler, createUserMessage, type Message } from '@deepseek-ai/dsh-llm'
+import type { Session, SessionSeq } from '@deepseek-ai/dsh-session'
+import type {} from '@deepseek-ai/dsh-token-meter'
+import { hasPiAiNativeStream } from './native-bridge.ts'
+import { nativeCompactionProjection, type NativeCompactionState } from './compaction-state.ts'
+import { nativeItemTokens, nativeResult, type CodexCheckpointSource } from './native-history.ts'
+
+/** Compaction backend selected by the sub bundle. Other routes retain basic compaction. */
+export default class CodexCompactionEngine extends BasicCompactionEngine {
+  static override inject = ['llm', 'tokenMeter', 'sessions', 'sessionProjections', 'gptSubNative']
+
+  constructor(ctx: Context, config: BasicCompactionConfig = {}) {
+    super(ctx, config)
+    ctx.effect(() => ctx.sessionProjections.register(nativeCompactionProjection))
+  }
+
+  override async compactIfNeeded(agent: Agent, trigger: CompactionTrigger, signal: AbortSignal): Promise<CompactionResult | null> {
+    // Without the llm-pi-ai/stream extension the native protocol cannot run;
+    // Codex Subscription then keeps DSH basic compaction like every other route.
+    if (!this.isCodex(agent) || !hasPiAiNativeStream()) return super.compactIfNeeded(agent, trigger, signal)
+    signal.throwIfAborted()
+    const header = agent.session.requestHeader()
+    if (header === undefined) return null
+    if (trigger === 'pressure') {
+      const info = await this.ctx.llm.resolveModelInfo(header.config.provider, header.config.model, signal)
+      if (info.context === undefined) throw new Error('Codex native compaction requires the model contextWindow')
+      const override = this.config.modelPolicies.find(value => value.provider === header.config.provider && value.model === header.config.model)
+      const ratio = override?.thresholdRatio ?? this.config.thresholdRatio
+      const headroom = override?.headroomTokens ?? this.config.headroomTokens
+      const reserve = header.config.maxTokens ?? info.defaultMaxTokens ?? 0
+      const threshold = Math.min(Math.floor(info.context.contextWindow * ratio), info.context.contextWindow - reserve - headroom)
+      if (threshold <= 0) throw new Error('Codex compaction headroom and output reservation exhaust contextWindow')
+      if (this.nativePressure(agent.session) < threshold) return null
+    }
+    const range = this.wholeRange(agent.session)
+    if (range === null) return null
+    return this.compactRegion(range.start, range.end, agent, signal)
+  }
+
+  override compactNow(agent: Agent, signal: AbortSignal, sourceCommandId?: CommandId): Promise<CompactionResult | null> {
+    if (!this.isCodex(agent) || !hasPiAiNativeStream()) return super.compactNow(agent, signal, sourceCommandId)
+    signal.throwIfAborted()
+    try {
+      return agent.runMaintenance(async agentSignal => {
+        const operationSignal = AbortSignal.any([agentSignal, signal])
+        const range = this.wholeRange(agent.session)
+        if (range === null) return null
+        try {
+          const result = await this.nativeRegion(range.start, range.end, agent, operationSignal, null, sourceCommandId)
+          await this.ctx.sessions.flush(agent.session)
+          return result
+        } catch (error) {
+          if (agentSignal.aborted) throw new ManualCompactionError('cancelled', 'Codex native compaction was cancelled', { cause: error })
+          operationSignal.throwIfAborted()
+          throw error
+        }
+      })
+    } catch (error) {
+      throw new ManualCompactionError('busy', 'manual Codex compaction requires an idle agent', { cause: error })
+    }
+  }
+
+  override compactRegion(start: SessionSeq, end: SessionSeq, agent: Agent, signal?: AbortSignal): Promise<CompactionResult> {
+    if (!this.isCodex(agent) || !hasPiAiNativeStream()) return super.compactRegion(start, end, agent, signal)
+    const owner = this.state(agent.session).openTurn
+    if (owner === null) return Promise.reject(new Error('automatic Codex compaction requires an open turn'))
+    return this.nativeRegion(start, end, agent, signal ?? new AbortController().signal, owner)
+  }
+
+  private isCodex(agent: Agent): boolean {
+    return (agent.session.requestHeader()?.config.provider ?? agent.options.provider) === 'openai-codex'
+  }
+
+  private state(session: Session): NativeCompactionState {
+    const state = this.ctx.sessionProjections.stateOf(session, 'gptSubCompaction')
+    if (state === undefined) throw new Error('Codex compaction projection is not registered')
+    return state
+  }
+
+  private nativePressure(session: Session): number {
+    const measurement = this.ctx.tokenMeter.measure(session)
+    const state = this.state(session)
+    const correction = measurement.baseline.kind === 'usage'
+      ? state.nativeExtraTokens - state.lastAssistantExtraTokens
+      : state.nativeExtraTokens
+    return Math.max(0, measurement.totalTokens + correction)
+  }
+
+  private wholeRange(session: Session): { start: SessionSeq; end: SessionSeq } | null {
+    const nodes = session.surface.nodes
+    const first = this.state(session).systemHead === true ? 1 : 0
+    const start = nodes[first]
+    const end = nodes.at(-1)
+    if (start === undefined || end === undefined || nodes.length - first < 2) return null
+    if (!toolPairingBalancedBefore(session, start) || !toolPairingBalancedAfter(session, end)) return null
+    return { start, end }
+  }
+
+  private async nativeRegion(
+    start: SessionSeq, end: SessionSeq, agent: Agent, signal: AbortSignal,
+    owner: number | null, sourceCommandId?: CommandId,
+  ): Promise<CompactionResult> {
+    signal.throwIfAborted()
+    const session = agent.session
+    const state = this.state(session)
+    if (state.activeCompaction !== null || state.openTurn !== owner) {
+      throw new ManualCompactionError('busy', 'another turn or compaction owns this Session')
+    }
+    const range = this.wholeRange(session)
+    if (range === null || range.start !== start || range.end !== end) {
+      throw new Error('native Codex compaction requires the complete balanced history after the system head')
+    }
+    const nodes = [...session.surface.nodes]
+    const first = nodes.indexOf(start)
+    const last = nodes.indexOf(end)
+    const shadowedSeqs = nodes.slice(first, last + 1)
+    const messages: Message[] = [...session.deriveMessages()]
+    const measurement = this.ctx.tokenMeter.measure(session)
+    const shadowedTokenCount = measurement.nodes.slice(first, last + 1).reduce((sum, node) => sum + node.heuristicTokens, 0)
+    const previousTokens = measurement.nodes.slice(first, last + 1).reduce((sum, node) => sum + node.tokens, 0)
+      + state.nativeExtraTokens
+    const header = session.requestHeader()
+    const provider = header?.config.provider ?? agent.options.provider
+    const model = header?.config.model ?? agent.options.model
+    if (provider !== 'openai-codex' || model === undefined) throw new Error('native Codex compaction requires a routed subscription model')
+    const compactionId = CompactionId(randomUUID())
+    const lifecycle = { compactionId, turn: owner, ...sourceCommandId === undefined ? {} : { sourceCommandId } }
+    const startEvent = session.append('compaction/start', lifecycle)
+    let closing = false
+    try {
+      const assembler = new BlockAssembler()
+      for await (const chunk of this.ctx.llm.stream({
+        provider, model, messages, purpose: 'compaction', sessionId: session.id, signal,
+        toolHistory: session.toolHistory(),
+        ...header?.tools === undefined ? {} : { tools: [...header.tools] },
+        ...header?.config.reasoningEffort === undefined ? {} : { reasoningEffort: header.config.reasoningEffort },
+      })) assembler.push(chunk)
+      signal.throwIfAborted()
+      if (assembler.finish.kind === 'error' || assembler.finish.kind === 'aborted') {
+        throw new Error(assembler.finish.failure.message)
+      }
+      const result = nativeResult(assembler.blocks())
+      const contextTokens = result.summaryTokens + result.retained.reduce((sum, item) => sum + nativeItemTokens(item), 0)
+      if (contextTokens >= previousTokens) throw new Error('Codex native compaction did not reduce context tokens')
+      const currentNodes = session.surface.nodes
+      if (!isDeepStrictEqual(currentNodes.slice(first, last + 1), shadowedSeqs)
+        || !isDeepStrictEqual(session.deriveMessages().slice(0, messages.length), messages)) {
+        throw new ManualCompactionError('changed', 'Session history changed during Codex native compaction')
+      }
+      const source: CodexCheckpointSource = {
+        ...compactCheckpointSource(compactionId, sourceCommandId),
+        nativeCodex: { version: 1, provider, model, items: [...result.retained, result.item], contextTokens },
+      }
+      const summary = [{ type: 'text' as const, text: `[Codex native checkpoint ${compactionId}]` }]
+      const summaryEvent = session.append('compaction/summary', {
+        compactionId, ...sourceCommandId === undefined ? {} : { sourceCommandId },
+        summary, rawOutput: assembler.blocks(), llmStreamCall: true,
+        shadowedRange: { start, end }, shadowedSeqs, shadowedTokenCount, provider, model,
+        ...assembler.usage === undefined ? {} : { usage: assembler.usage },
+      })
+      session.append('user/message', createUserMessage({ content: summary, source }), {
+        surfaceOp: { op: 'replace', startSeq: start, endSeq: end },
+        sourceEventSeqs: [startEvent.seq, summaryEvent.seq, ...shadowedSeqs],
+      })
+      closing = true
+      const endEvent = session.append('compaction/end', lifecycle)
+      this.ctx.logger.info('Codex native compaction (%s): %s, summary %d tokens, retained %d messages', model, compactionId, result.summaryTokens, result.retained.length)
+      return { compactionId, ...sourceCommandId === undefined ? {} : { sourceCommandId },
+        startSeq: startEvent.seq, summarySeq: summaryEvent.seq, endSeq: endEvent.seq,
+        summary, shadowedRange: { start, end }, shadowedSeqs, shadowedTokenCount }
+    } catch (error) {
+      if (!closing) session.append('compaction/end', { ...lifecycle, error: error instanceof Error ? error.message : String(error) })
+      throw error
+    }
+  }
+}

package/src/index.ts

@@ -1,15 +1,9 @@
 /**
  * Direct ChatGPT/Codex subscription access for DeepSeek Harness.
  *
- * This plugin owns no transport. pi-ai already ships an `openai-codex`
- * provider that knows the Codex wire format -- it sets `store`, derives
- * `chatgpt-account-id` from the access token's own JWT claim, and speaks the
- * codex-responses protocol -- but it authenticates only through OAuth, and
- * `dsh-llm-pi-ai` runs no login flow and holds no OAuth store. Naming a
- * credential on the route grafts an api-key method beside the provider's own,
- * which is the seam this plugin fills: it keeps a live Codex access token in
- * the harness credential store, refreshing it from `~/.codex/auth.json` before
- * it expires.
+ * The plugin refreshes the Codex CLI subscription token, routes Codex egress,
+ * and executes native context compaction. pi-ai serves normal conversation
+ * requests and replays the encrypted checkpoints stored in Session history.
  *
  * The result needs no loopback port, no shared local key, and no external
  * proxy binary. The `codex` CLI still owns the login.
@@ -41,6 +35,7 @@ import { consumeResetCredit, listResetCredits } from './reset-credits.ts'
 import { installProxyRouting, type ProxyRouting } from './proxy-routing.ts'
 import { QuotaSource } from './quota-route.ts'
 import { TokenStore } from './token-store.ts'
+import { CodexNativeBridge } from './native-bridge.ts'
 import type { Config as ConfigShape } from './types.ts'
 import { fetchUsage, reportedWindows } from './usage.ts'
 
@@ -126,6 +121,9 @@ export const Config: z<Partial<ConfigShape>, ConfigShape> = z.object({
   // exists, its proxyUrl wins over the config's -- a page edit survives
   // restarts without touching cordis config layers.
   stateFile: z.string().default('~/.dsh/gpt-sub.json'),
+  nativeCompactionTimeoutMs: z.number().step(1).min(1).default(300_000),
+  nativeRetainTokens: z.number().step(1).min(0).default(64_000),
+  nativeResponseMaxBytes: z.number().step(1).min(1).default(16 * 1024 * 1024),
 }) as z<Partial<ConfigShape>, ConfigShape>
 
 /** Expand a leading `~` against the current user's home directory. */
@@ -236,6 +234,8 @@ export async function apply(ctx: Context, config: ConfigShape): Promise<() => Pr
     throw error
   }
   ctx.logger.info('gpt-sub: published Codex access token to %s', config.tokenRef)
+  const nativeBridge = new CodexNativeBridge(ctx, config)
+  ctx.effect(() => () => nativeBridge.stop())
 
   // Reachability probe. An unproxied egress answers 403 with a Cloudflare
   // block page, and that failure is otherwise invisible until the first model
@@ -677,6 +677,7 @@ export async function apply(ctx: Context, config: ConfigShape): Promise<() => Pr
 
   return async () => {
     clearInterval(timer)
+    await nativeBridge.stop()
     // Restores the previous global dispatcher before closing the agent, so a
     // fiber restart never leaves the host dispatching into a closing proxy.
     await switching.catch(() => undefined)

package/src/native-bridge.ts

@@ -0,0 +1,288 @@
+/** Codex native compaction and checkpoint replay through resolved pi-ai requests. */
+import { Service, type Context } from '@deepseek-ai/cordis'
+import { LlmError, type Message, type StreamChunk, type TokenUsage } from '@deepseek-ai/dsh-llm'
+import * as PiAi from '@deepseek-ai/dsh-llm-pi-ai'
+import { normalizeContext } from '@earendil-works/pi-ai/utils/transcript'
+import { convertResponsesMessages, convertResponsesTools } from '@earendil-works/pi-ai/api/openai-responses-shared'
+import { createParser } from 'eventsource-parser'
+import { z } from 'zod'
+import type { ModelThinkingLevel } from '@earendil-works/pi-ai'
+import {
+  expandCheckpoints, nativeItemsSchema, readCheckpoint, retainUserItems,
+  type NativeCompactionResultBlock,
+} from './native-history.ts'
+
+/** Native compaction request bounds configured by the plugin. */
+export interface NativeBridgeConfig {
+  nativeCompactionTimeoutMs: number
+  nativeRetainTokens: number
+  nativeResponseMaxBytes: number
+}
+
+/** Options the pi-ai SDK accepts for one native request stream. */
+export interface PiAiNativeStreamOptions {
+  apiKey?: string
+  reasoning?: ModelThinkingLevel
+  maxRetries?: number
+  signal?: AbortSignal
+  headers?: Record<string, string | null | undefined>
+  transport?: string
+  fetch?: typeof fetch
+  onPayload?: (payload: unknown, model: unknown) => unknown | Promise<unknown>
+}
+
+/**
+ * Native request the llm-pi-ai/stream extension hands to listeners.
+ * Mirrors the extension's own shape; declared locally so this plugin also
+ * typechecks against adapters that do not ship the extension yet.
+ */
+export interface PiAiNativeRequest {
+  options: {
+    provider: string
+    model: string
+    purpose?: string
+    messages: Message[]
+    sessionId?: string | number
+    reasoningEffort?: string
+  }
+  model: Parameters<typeof convertResponsesMessages>[0]
+  context: Parameters<typeof normalizeContext>[0]
+  streamOptions: PiAiNativeStreamOptions
+  stream: (options: PiAiNativeStreamOptions) => AsyncIterable<StreamChunk>
+}
+
+/**
+ * Event name published by the llm-pi-ai/stream extension. Falls back to the
+ * wire name so the plugin loads — inert — on hosts whose adapter does not
+ * emit it yet; nothing fires and ordinary SDK dispatch is unchanged.
+ */
+const PI_AI_NATIVE_STREAM_EVENT = (PiAi as { PI_AI_NATIVE_STREAM_EVENT?: string }).PI_AI_NATIVE_STREAM_EVENT ?? 'llm-pi-ai/stream'
+
+/** Whether the host's llm-pi-ai adapter emits native requests through the stream extension. */
+export function hasPiAiNativeStream(): boolean {
+  return (PiAi as { PI_AI_NATIVE_STREAM_EVENT?: string }).PI_AI_NATIVE_STREAM_EVENT !== undefined
+}
+
+/** Listener for one native request; call next() to defer to the SDK dispatch. */
+export type PiAiNativeStreamListener = (request: PiAiNativeRequest, next: () => AsyncIterable<StreamChunk>) => AsyncIterable<StreamChunk>
+
+/**
+ * Register a native stream listener. The event key is provided by the
+ * extension's typings when present; typed loosely here so registration also
+ * compiles — and stays dormant — where the extension is absent.
+ */
+export function onPiAiNativeStream(ctx: Context, listener: PiAiNativeStreamListener): () => boolean {
+  return (ctx.on as unknown as (name: string, listener: PiAiNativeStreamListener) => () => boolean)(PI_AI_NATIVE_STREAM_EVENT, listener)
+}
+
+/** Drive one native request through the registered listeners, as the extension does. */
+export function waterfallPiAiNativeStream(ctx: Context, request: PiAiNativeRequest, next: () => AsyncIterable<StreamChunk>): AsyncIterable<StreamChunk> {
+  return (ctx.waterfall as unknown as (name: string, request: PiAiNativeRequest, next: () => AsyncIterable<StreamChunk>) => AsyncIterable<StreamChunk>)(PI_AI_NATIVE_STREAM_EVENT, request, next)
+}
+
+declare module '@deepseek-ai/cordis' {
+  interface Context { gptSubNative: CodexNativeBridge }
+}
+
+const jsonObject = z.record(z.string(), z.unknown())
+const claimsSchema = z.object({
+  'https://api.openai.com/auth': z.object({ chatgpt_account_id: z.string().min(1) }),
+})
+const usageSchema = z.object({
+  input_tokens: z.number().int().nonnegative(),
+  output_tokens: z.number().int().nonnegative(),
+  input_tokens_details: z.object({ cached_tokens: z.number().int().nonnegative().optional() }).optional(),
+})
+
+/**
+ * Expand persisted checkpoints immediately before the SDK sends its payload.
+ * @param request - prepared pi-ai request.
+ * @param payload - provider-native request body.
+ * @returns body with native checkpoint items restored.
+ */
+export function replayPayload(request: PiAiNativeRequest, payload: unknown): unknown {
+  const body = jsonObject.parse(payload)
+  const input = nativeItemsSchema.parse(body['input'])
+  return { ...body, input: expandCheckpoints(input, request.options.messages, request.options.provider, request.options.model) }
+}
+
+/**
+ * Resolve the Responses endpoint from the captured model descriptor.
+ * @param baseUrl - configured native model endpoint.
+ * @returns Codex Responses URL.
+ */
+export function codexResponsesUrl(baseUrl: string): string {
+  const base = baseUrl.replace(/\/+$/, '')
+  if (base.endsWith('/codex/responses')) return base
+  if (base.endsWith('/codex')) return `${base}/responses`
+  return `${base}/codex/responses`
+}
+
+/** Plugin-owned native request execution, cancelled before its proxy is closed. */
+export class CodexNativeBridge extends Service {
+  private readonly stopping = new AbortController()
+  private readonly active = new Set<Promise<void>>()
+
+  constructor(ctx: Context, private readonly config: NativeBridgeConfig, private readonly fetchImpl: typeof fetch = fetch) {
+    super(ctx, 'gptSubNative')
+    onPiAiNativeStream(ctx, (request, next) => {
+      if (request.options.provider !== 'openai-codex') return next()
+      if (request.model.api !== 'openai-codex-responses') {
+        throw new LlmError('Codex native compaction requires the openai-codex-responses protocol', 'INVALID_CONFIG')
+      }
+      if (request.options.purpose === 'compaction') return this.compact(request)
+      const checkpoints = request.options.messages.some(message => 'source' in message && readCheckpoint(message.source) !== undefined)
+      if (!checkpoints) return next()
+      return request.stream({
+        ...request.streamOptions,
+        onPayload: payload => replayPayload(request, payload),
+      })
+    })
+    ctx.on('llm/stream', (options, next) => {
+      for (const message of options.messages) {
+        if (!('source' in message)) continue
+        const checkpoint = readCheckpoint(message.source)
+        if (checkpoint !== undefined && (checkpoint.provider !== options.provider || checkpoint.model !== options.model)) {
+          throw new LlmError(
+            `This Session contains a Codex checkpoint for ${checkpoint.model}; use the same model or start a new Session`,
+            'UNSUPPORTED_CONTENT',
+          )
+        }
+      }
+      return next()
+    })
+  }
+
+  /**
+   * Abort and await all native compaction requests before transport teardown.
+   * @returns completion of every active request.
+   */
+  async stop(): Promise<void> {
+    this.stopping.abort(new Error('Codex subscription plugin unloaded'))
+    await Promise.all(this.active)
+  }
+
+  private async *compact(request: PiAiNativeRequest): AsyncGenerator<StreamChunk> {
+    let settle: () => void = () => undefined
+    const done = new Promise<void>(resolve => { settle = resolve })
+    this.active.add(done)
+    const signal = AbortSignal.any([
+      this.stopping.signal,
+      AbortSignal.timeout(this.config.nativeCompactionTimeoutMs),
+      ...request.streamOptions.signal === undefined ? [] : [request.streamOptions.signal],
+    ])
+    let reader: ReadableStreamDefaultReader<Uint8Array> | undefined
+    try {
+      signal.throwIfAborted()
+      const token = request.streamOptions.apiKey
+      if (token === undefined) throw new LlmError('Codex native compaction requires a resolved subscription token', 'MISSING_CREDENTIAL')
+      const payloadPart = token.split('.')[1]
+      if (payloadPart === undefined) throw new LlmError('Codex subscription token is not a JWT', 'MISSING_CREDENTIAL')
+      const account = claimsSchema.parse(JSON.parse(Buffer.from(payloadPart, 'base64url').toString('utf8')))
+      const serialized = convertResponsesMessages(request.model, normalizeContext(request.context), new Set(['openai', 'openai-codex', 'azure-openai-responses']), {
+        includeSystemPrompt: false,
+      })
+      const input = expandCheckpoints(
+        nativeItemsSchema.parse(JSON.parse(JSON.stringify(serialized))),
+        request.options.messages, request.options.provider, request.options.model,
+      )
+      const body: Record<string, unknown> = {
+        model: request.model.id,
+        store: false,
+        stream: true,
+        instructions: request.context.systemPrompt ?? '',
+        input: [...input, { type: 'compaction_trigger' }],
+        parallel_tool_calls: true,
+        include: ['reasoning.encrypted_content'],
+        ...request.options.sessionId === undefined ? {} : { prompt_cache_key: String(request.options.sessionId) },
+      }
+      if (request.context.tools !== undefined) body['tools'] = convertResponsesTools(request.context.tools, { strict: null })
+      const reasoning = request.streamOptions.reasoning
+      if (reasoning !== undefined) {
+        const effort = request.model.thinkingLevelMap?.[reasoning] ?? reasoning
+        body['reasoning'] = { effort, summary: 'auto' }
+      }
+      const headers = new Headers()
+      for (const [name, value] of Object.entries({ ...request.model.headers, ...request.streamOptions.headers })) {
+        if (value !== null && value !== undefined) headers.set(name, value)
+      }
+      headers.set('authorization', `Bearer ${token}`)
+      headers.set('chatgpt-account-id', account['https://api.openai.com/auth'].chatgpt_account_id)
+      headers.set('originator', 'codex_cli_rs')
+      headers.set('OpenAI-Beta', 'responses=experimental')
+      headers.set('content-type', 'application/json')
+      headers.set('accept', 'text/event-stream')
+      if (request.options.sessionId !== undefined) headers.set('session-id', String(request.options.sessionId))
+      const response = await this.fetchImpl(codexResponsesUrl(request.model.baseUrl), {
+        method: 'POST', headers, body: JSON.stringify(body), signal,
+      })
+      if (!response.ok) throw new LlmError(`Codex native compaction HTTP ${response.status}: ${await response.text()}`, 'CODEX_COMPACTION_HTTP_ERROR')
+      if (response.body === null) throw new LlmError('Codex native compaction returned no response stream', 'STREAM_CLOSED')
+      reader = response.body.getReader()
+      const events: string[] = []
+      let parseError: Error | undefined
+      const parser = createParser({ onEvent: event => events.push(event.data), onError: error => { parseError = error } })
+      const decoder = new TextDecoder()
+      let receivedBytes = 0
+      let compaction: NativeCompactionResultBlock['item'] | undefined
+      let compactionCount = 0
+      let completed: Record<string, unknown> | undefined
+      while (completed === undefined) {
+        const chunk = await reader.read()
+        if (chunk.done) {
+          parser.feed(decoder.decode())
+          if (events.length === 0) throw new LlmError('Codex compaction stream closed before response.completed', 'STREAM_CLOSED')
+        } else {
+          receivedBytes += chunk.value.byteLength
+          if (receivedBytes > this.config.nativeResponseMaxBytes) throw new LlmError('Codex compaction response exceeded nativeResponseMaxBytes', 'CODEX_COMPACTION_RESPONSE_LIMIT')
+          parser.feed(decoder.decode(chunk.value, { stream: true }))
+        }
+        if (parseError !== undefined) throw parseError
+        for (const data of events.splice(0)) {
+          if (data === '[DONE]') continue
+          const event = jsonObject.parse(JSON.parse(data))
+          if (event['type'] === 'response.output_item.done') {
+            const item = nativeItemsSchema.element.parse(event['item'])
+            if (item['type'] === 'compaction') {
+              compaction = item
+              compactionCount += 1
+            }
+          } else if (event['type'] === 'response.completed') completed = jsonObject.parse(event['response'])
+          else if (event['type'] === 'error' || event['type'] === 'response.failed' || event['type'] === 'response.incomplete') {
+            throw new LlmError(`Codex native compaction failed: ${data}`, 'CODEX_COMPACTION_ERROR')
+          }
+        }
+        signal.throwIfAborted()
+        if (chunk.done && completed === undefined) throw new LlmError('Codex compaction stream closed before response.completed', 'STREAM_CLOSED')
+      }
+      if (compactionCount !== 1 || compaction === undefined || typeof compaction['encrypted_content'] !== 'string' || compaction['encrypted_content'].length === 0) {
+        throw new LlmError(`Codex native compaction expected one encrypted compaction item, received ${compactionCount}`, 'INVALID_REPLAY_STATE')
+      }
+      const responseId = z.string().min(1).parse(completed['id'])
+      const usage = usageSchema.parse(completed['usage'])
+      const cached = usage.input_tokens_details?.cached_tokens ?? 0
+      const tokenUsage: TokenUsage = {
+        inputTokens: Math.max(0, usage.input_tokens - cached),
+        outputTokens: usage.output_tokens,
+        cacheReadTokens: cached,
+        totalTokens: usage.input_tokens + usage.output_tokens,
+      }
+      yield {
+        type: 'block-end', index: 0,
+        block: {
+          type: 'codex-compaction-result', item: compaction, responseId,
+          summaryTokens: usage.output_tokens,
+          retained: retainUserItems(input, this.config.nativeRetainTokens),
+        },
+      }
+      yield { type: 'usage', usage: tokenUsage }
+      yield { type: 'finish', reason: { kind: 'stop' } }
+    } finally {
+      try { await reader?.cancel() } finally {
+        reader?.releaseLock()
+        this.active.delete(done)
+        settle()
+      }
+    }
+  }
+}

package/src/native-history.ts

@@ -0,0 +1,140 @@
+/** Persisted Codex compaction windows and their Responses input projection. */
+import type { ContentBlock, MessageSource, RequestMessage } from '@deepseek-ai/dsh-llm'
+import type { CompactionCheckpointSource } from '@deepseek-ai/dsh-compaction/checkpoint'
+import { z } from 'zod'
+
+/** Lossless JSON validation for provider-native Responses items. */
+export const nativeItemsSchema = z.array(z.record(z.string(), z.json()))
+/** One lossless provider-native Responses input item. */
+export type NativeItem = z.infer<typeof nativeItemsSchema>[number]
+const checkpointSchema = z.object({
+  version: z.literal(1),
+  provider: z.literal('openai-codex'),
+  model: z.string().min(1),
+  items: nativeItemsSchema.min(1),
+  contextTokens: z.number().int().nonnegative(),
+})
+
+/** Native window carried by a persisted replacement message. */
+export type CodexCheckpoint = z.infer<typeof checkpointSchema>
+
+/** Backend-independent checkpoint identity with plugin-owned native state. */
+export type CodexCheckpointSource = CompactionCheckpointSource & { readonly nativeCodex: CodexCheckpoint }
+
+/** Completed native compaction output and the retained user messages. */
+export interface NativeCompactionResultBlock {
+  type: 'codex-compaction-result'
+  item: NativeItem
+  retained: NativeItem[]
+  responseId: string
+  summaryTokens: number
+}
+
+declare module '@deepseek-ai/dsh-llm' {
+  interface ContentBlockMap {
+    'codex-compaction-result': NativeCompactionResultBlock
+  }
+}
+
+/**
+ * Validate plugin state restored with one checkpoint source.
+ * @param source - source of the durable message.
+ * @returns native state, or undefined for other producers.
+ */
+export function readCheckpoint(source: MessageSource): CodexCheckpoint | undefined {
+  if (!('nativeCodex' in source)) return undefined
+  if (source.kind !== 'compact-checkpoint') throw new Error('Codex native state requires a compaction checkpoint')
+  const state = checkpointSchema.parse(source.nativeCodex)
+  if (state.items.filter(item => item['type'] === 'compaction').length !== 1) {
+    throw new Error('Codex checkpoint must contain exactly one compaction item')
+  }
+  const item = state.items.find(value => value['type'] === 'compaction')
+  if (typeof item?.['encrypted_content'] !== 'string' || item['encrypted_content'].length === 0) {
+    throw new Error('Codex checkpoint is missing encrypted_content')
+  }
+  return state
+}
+
+/**
+ * Replace logged checkpoint markers with their exact native items.
+ * @param input - serialized Responses input.
+ * @param messages - durable history that produced the input.
+ * @param provider - captured provider route.
+ * @param model - captured model id.
+ * @returns input with each checkpoint expanded once, preserving order.
+ */
+export function expandCheckpoints(
+  input: readonly NativeItem[], messages: readonly RequestMessage[], provider: string, model: string,
+): NativeItem[] {
+  const checkpoints = new Map<string, CodexCheckpoint>()
+  for (const message of messages) {
+    if (!('source' in message)) continue
+    const state = readCheckpoint(message.source)
+    if (state === undefined) continue
+    if (state.provider !== provider || state.model !== model) {
+      throw new Error(`Codex checkpoint belongs to ${state.provider}/${state.model}; start a new Session to use ${provider}/${model}`)
+    }
+    const marker = message.content.filter(block => block.type === 'text').map(block => block.text).join('')
+    if (marker.length === 0 || checkpoints.has(marker)) throw new Error('invalid Codex checkpoint marker')
+    checkpoints.set(marker, state)
+  }
+  if (checkpoints.size === 0) return [...input]
+  const remaining = new Set(checkpoints.keys())
+  const output: NativeItem[] = []
+  for (const item of input) {
+    const content = item['content']
+    const text = item['role'] === 'user' && Array.isArray(content)
+      ? content.map(value => typeof value === 'object' && value !== null && !Array.isArray(value)
+        && value['type'] === 'input_text' && typeof value['text'] === 'string' ? value['text'] : '').join('')
+      : ''
+    const checkpoint = checkpoints.get(text)
+    if (checkpoint === undefined) output.push(item)
+    else {
+      if (!remaining.delete(text)) throw new Error('Codex checkpoint marker was serialized more than once')
+      output.push(...checkpoint.items)
+    }
+  }
+  if (remaining.size > 0) throw new Error('Codex checkpoint marker was lost during request conversion')
+  return output
+}
+
+/**
+ * Retain recent user items within a structural token budget.
+ * @param input - expanded native history sent for compaction.
+ * @param budget - maximum estimated tokens retained verbatim.
+ * @returns recent user items in conversation order.
+ */
+export function retainUserItems(input: readonly NativeItem[], budget: number): NativeItem[] {
+  const retained: NativeItem[] = []
+  let remaining = budget
+  for (const item of [...input].reverse()) {
+    if (item['role'] !== 'user' || (item['type'] !== undefined && item['type'] !== 'message')) continue
+    const price = nativeItemTokens(item)
+    if (price > remaining) break
+    retained.push(item)
+    remaining -= price
+  }
+  return retained.reverse()
+}
+
+/**
+ * Estimate a plaintext native item's serialized token cost.
+ * @param item - retained user item, excluding encrypted compaction state.
+ * @returns conservative structural token estimate.
+ */
+export function nativeItemTokens(item: NativeItem): number {
+  return Math.ceil(JSON.stringify(item).length / 4) + 4
+}
+
+/**
+ * Read the completed compaction block assembled from the auxiliary stream.
+ * @param blocks - complete auxiliary output.
+ * @returns the unique native compaction result.
+ */
+export function nativeResult(blocks: readonly ContentBlock[]): NativeCompactionResultBlock {
+  const results = blocks.filter(block => block.type === 'codex-compaction-result')
+  if (results.length !== 1) throw new Error('native Codex compaction did not return exactly one result')
+  const result = results[0]
+  if (result === undefined) throw new Error('native Codex compaction result is missing')
+  return result
+}