@young1lin/dsh-gpt-sub 0.1.0 → 0.1.2

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
+}

package/src/types.ts

@@ -14,4 +14,10 @@ export interface Config {
   bootstrapRetries: number
   /** Where the panel's runtime overrides (proxy, credential file) are persisted. */
   stateFile: string
+  /** Total timeout for a native Codex compaction request. */
+  nativeCompactionTimeoutMs: number
+  /** Recent user-message budget retained alongside the encrypted summary. */
+  nativeRetainTokens: number
+  /** Maximum streamed bytes accepted from one native compaction response. */
+  nativeResponseMaxBytes: number
 }