dsh-lcx-codex 0.4.1 → 0.4.2

package/lib/dsh-responses.js

@@ -98,6 +98,7 @@ export function readDshPiReplayState(value) {
     if (!['text', 'reasoning', 'tool-call'].includes(block.type)) throw invalidReplay(`block ${index} has an unknown type`)
     for (const signature of ['textSignature', 'thinkingSignature', 'thoughtSignature']) if (block[signature] !== undefined && typeof block[signature] !== 'string') throw invalidReplay(`block ${index} ${signature} must be a string`)
     if (block.redacted !== undefined && typeof block.redacted !== 'boolean') throw invalidReplay(`block ${index} redacted must be boolean`)
+    if (block.namespace !== undefined && typeof block.namespace !== 'string') throw invalidReplay(`block ${index} namespace must be a string`)
   }
   return { response, blocks: value.blocks }
 }
@@ -125,7 +126,7 @@ function replayedAssistant(message, source) {
     if (replayBlockType(block?.type) !== replay?.type) throw invalidReplay(`block ${index} does not match assistant content`)
     if (block.type === 'text') return { type: 'text', text: String(block.text ?? ''), ...(replay.textSignature === undefined ? {} : { textSignature: replay.textSignature }) }
     if (block.type === 'reasoning') return { type: 'thinking', thinking: String(block.text ?? ''), ...(replay.thinkingSignature === undefined ? {} : { thinkingSignature: replay.thinkingSignature }), ...(replay.redacted === undefined ? {} : { redacted: replay.redacted }) }
-    return { type: 'toolCall', id: String(block.id), name: String(block.name), arguments: parseArguments(block.arguments), ...(replay.thoughtSignature === undefined ? {} : { thoughtSignature: replay.thoughtSignature }) }
+    return { type: 'toolCall', id: String(block.id), name: String(block.name), arguments: parseArguments(block.arguments), ...(replay.thoughtSignature === undefined ? {} : { thoughtSignature: replay.thoughtSignature }), ...(replay.namespace === undefined ? {} : { namespace: replay.namespace }) }
   })
   return { role: 'assistant', content, api: state.response.api, provider: state.response.provider, model: state.response.model, ...(state.response.responseModel === undefined ? {} : { responseModel: state.response.responseModel }), ...(state.response.responseId === undefined ? {} : { responseId: state.response.responseId }), usage: emptyUsage(), stopReason: state.response.stopReason, timestamp: 0 }
 }
@@ -173,7 +174,7 @@ function builtinResponsesModel(provider, modelId) {
   catch { return undefined }
 }
 
-function piModel(options) {
+export function resolvePiResponsesModel(options) {
   const route = options.route ?? {}
   const explicit = options.model && typeof options.model === 'object' ? options.model : undefined
   const provider = String(explicit?.provider ?? route.provider ?? 'dsh-lcx-codex')
@@ -217,19 +218,25 @@ export async function serializeDshMessages(messages, ctx, options = {}) {
     requestImageMaxBytes: Number.isSafeInteger(options.requestImageMaxBytes) && options.requestImageMaxBytes > 0 ? options.requestImageMaxBytes : DEFAULT_REQUEST_IMAGE_MAX_BYTES,
   }
   const projected = offloadRequestImagesWithPolicy(messages ?? [], { representation: 'base64', maxBytes: normalized.maxRequestImageBytes, byteQuantum: 1, byteLength: ref => Math.min(ref.bytes, normalized.requestImageMaxBytes) })
-  const model = piModel(normalized)
+  const model = resolvePiResponsesModel(normalized)
   const context = { systemPrompt: normalized.systemPrompt, messages: await dshToPiMessages(projected, ctx, normalized, imageMap), tools: options.tools ?? [] }
   const supportsStrictMode = model.compat?.supportsStrictMode ?? false
   const supportsOpenAIGrammarTools = model.compat?.supportsOpenAIGrammarTools ?? false
+  const supportsAdditionalTools = model.compat?.supportsAdditionalTools ?? false
   const supportsToolSearch = model.compat?.supportsToolSearch ?? false
+  const deferredToolsMode = supportsAdditionalTools ? 'additional-tools' : supportsToolSearch ? 'tool-search' : undefined
   const grammarToolInputProperties = createGrammarToolInputProperties(context.tools, supportsOpenAIGrammarTools)
-  const placement = splitDeferredTools(context, supportsToolSearch)
+  const placement = splitDeferredTools(context, deferredToolsMode !== undefined)
   const toolOptions = { supportsStrictMode, supportsOpenAIGrammarTools }
   const input = convertResponsesMessages(model, context, new Set(['openai', 'openai-codex', 'opencode']), {
-    includeSystemPrompt: normalized.includeSystemPrompt, grammarToolInputProperties, deferredTools: placement.deferred, toolOptions,
+    includeSystemPrompt: normalized.includeSystemPrompt,
+    grammarToolInputProperties,
+    deferredTools: placement.deferred,
+    deferredToolsMode,
+    toolOptions,
   })
   const tools = options.tools === undefined ? undefined : convertResponsesTools(placement.immediate, toolOptions)
-  return { input, imageMap, tools }
+  return { input, imageMap, tools, model, grammarToolInputProperties, deferredToolsMode }
 }
 
 export function responsesTools(tools) {

package/lib/index.js

@@ -49,8 +49,9 @@ import {
   resolveModelImageSupport,
   serializeDshMessages,
 } from './dsh-responses.js'
-import { requestNativeCompaction } from './compact-v2.js'
-import { requestNativeReplay } from './responses-replay.js'
+import { mergeFeatureHeader, requestNativeCompaction } from './compact-v2.js'
+import { buildResponsesBody } from './responses-request.js'
+import { managedFailureChunk, streamResponsesRequest } from './responses-stream.js'
 import {
   checkpointStateForMessage,
   compactCheckpointId,
@@ -94,7 +95,6 @@ const SETTINGS_NS = settingsNamespace('lcx-codex')
 const ADVANCED_HOSTED_TOOL = 'websearch_gpt_advanced'
 const ALPHA_TOOL = 'websearch_alpha'
 const COMPACTION_DIRECTIVE = 'You are now acting as a compaction engine'
-const bypassReplayOptions = new WeakSet()
 const hostedSearchRouteContext = new AsyncLocalStorage()
 
 function dshHome() { return process.env.DSH_HOME ?? join(homedir(), '.dsh') }
@@ -107,6 +107,7 @@ export const Config = z.object({
   baseURL: z.string().default('https://api.lcxbot.com/v1'),
   apiKeyEnv: z.string().default('LCX_API_KEY'),
   model: z.string().default('gpt-5.6-sol'),
+  supportsExplicitPromptCacheMode: z.boolean().default(false),
   legacyCheckpointPath: z.string().default(''),
   checkpointPath: z.string().default(''),
   alphaCapabilityPath: z.string().default(''),
@@ -155,6 +156,7 @@ function normalizeConfig(input = {}) {
     baseURL: String(input.baseURL || 'https://api.lcxbot.com/v1').replace(/\/+$/u, ''),
     apiKeyEnv: input.apiKeyEnv || 'LCX_API_KEY',
     model: input.model || 'gpt-5.6-sol',
+    supportsExplicitPromptCacheMode: input.supportsExplicitPromptCacheMode === true,
     headers: input.headers && typeof input.headers === 'object' ? { ...input.headers } : {},
     legacyCheckpointPath: legacy,
     alphaCapabilityPath: input.alphaCapabilityPath || defaultAlphaCapabilityPath(),
@@ -370,15 +372,16 @@ function mergeMap(target, source) { for (const [key, value] of source ?? []) tar
 async function serializeNativeAware(messages, route, routeConfig, ctx, options = {}) {
   const session = sessionFor(ctx, route.sessionId)
   const imageSupport = await resolveModelImageSupport(ctx, route, options.signal)
-  const input = []; const imageMap = new Map(); let nativeTools
+  const input = []; const imageMap = new Map(); let nativeTools; let nativeModel; let grammarToolInputProperties
   let normal = []
   const serializeOptions = (imageMapOverride, extra = {}) => requestImageOptions(routeConfig, imageSupport, options.signal, imageMapOverride, { route, tools: options.tools, responsesCompat: routeConfig.responsesCompat, ...extra })
   const prelude = await serializeDshMessages([], ctx, serializeOptions(undefined, { systemPrompt: options.system, includeSystemPrompt: true }))
-  input.push(...prelude.input); nativeTools = prelude.tools
+  const ephemeralPreludeItemCount = prelude.input.length
+  input.push(...prelude.input); nativeTools = prelude.tools; nativeModel = prelude.model; grammarToolInputProperties = prelude.grammarToolInputProperties
   const flush = async () => {
     if (!normal.length) return
     const serialized = await serializeDshMessages(normal, ctx, serializeOptions())
-    nativeTools = serialized.tools ?? nativeTools
+    nativeTools = serialized.tools ?? nativeTools; nativeModel = serialized.model ?? nativeModel; grammarToolInputProperties = serialized.grammarToolInputProperties ?? grammarToolInputProperties
     input.push(...serialized.input); mergeMap(imageMap, serialized.imageMap); normal = []
   }
   for (const message of messages ?? []) {
@@ -439,7 +442,8 @@ async function serializeNativeAware(messages, route, routeConfig, ctx, options =
     normal.push(message)
   }
   await flush()
-  return { input, imageMap, imageSupport, tools: nativeTools }
+  if (!nativeModel) throw Object.assign(new Error('LCX could not resolve the Pi Responses model descriptor'), { code: 'LCX_RESPONSES_MODEL_UNAVAILABLE' })
+  return { input, ephemeralPreludeItemCount, imageMap, imageSupport, tools: nativeTools, model: nativeModel, grammarToolInputProperties }
 }
 
 function fallbackEligible(error, signal) {
@@ -461,10 +465,12 @@ async function* remoteCompactionStream(options, routeConfig, state, ctx, next, r
     const result = await requestNativeCompaction({
       baseURL: routeConfig.baseURL,
       model: route.model,
+      modelDescriptor: prepared.model,
       input: prepared.input,
       tools: prepared.tools ?? options.tools,
       promptCacheKey: promptCacheKey(route, routeConfig),
       promptCacheRetention: promptCacheRetention(routeConfig),
+      cacheRetention: routeConfig.cacheRetention,
       reasoningEffort: generation.reasoningEffort,
       temperature: generation.temperature,
       maxTokens: generation.maxTokens,
@@ -477,7 +483,7 @@ async function* remoteCompactionStream(options, routeConfig, state, ctx, next, r
     })
     const session = sessionFor(ctx, route.sessionId)
     const block = createNativeCheckpointBlock({
-      session, route, result, input: prepared.input, imageMap: prepared.imageMap,
+      session, route, result, input: prepared.input, ephemeralPreludeItemCount: prepared.ephemeralPreludeItemCount, imageMap: prepared.imageMap,
       retentionOptions: {
         tokenBudget: routeConfig.nativeRetentionTokenBudget,
         assistantTokenReserve: routeConfig.assistantRetentionTokenReserve,
@@ -522,6 +528,11 @@ function pressurePolicy(state, config) {
   return { auto, emergency: Math.min(99, emergency) }
 }
 
+export function compactionPressureBand(totalTokens, contextWindow, policy) {
+  const ratioPercent = totalTokens / contextWindow * 100
+  return { ratioPercent, band: ratioPercent < policy.auto ? 'below' : ratioPercent < policy.emergency ? 'native' : 'emergency' }
+}
+
 function adjustedCompactionConfig(config, target, thresholdRatio) {
   if (!config || typeof config !== 'object') return config
   const modelPolicies = Array.isArray(config.modelPolicies)
@@ -549,7 +560,7 @@ function patchCompactionPressureService(compactionValue, state, getConfig, ctx,
       return original.call(this, agentArg, trigger, activeSignal)
     }
     return record.mutex.run(activeSignal, async () => {
-      if (trigger !== 'pressure' || !state.enabled || !state.remoteCompaction || !state.autoCompaction) return callOriginal()
+      if (trigger !== 'pressure' || !state.enabled || !state.autoCompaction) return callOriginal()
       const config = getConfig()
       const target = routedTargetForAgent(agentArg, config)
       if (!target || !resolveResponsesRouteConfig(ctx, target, config)) return callOriginal()
@@ -561,11 +572,12 @@ function patchCompactionPressureService(compactionValue, state, getConfig, ctx,
       if (!Number.isFinite(contextWindow) || contextWindow <= 0) return callOriginal()
       const totalTokens = Number(tokenMeter.measure(agentArg.session)?.totalTokens ?? 0)
       const { auto, emergency } = pressurePolicy(state, config)
-      const ratioPercent = totalTokens / contextWindow * 100
-      if (ratioPercent < auto) return null
+      const pressure = compactionPressureBand(totalTokens, contextWindow, { auto, emergency })
+      const ratioPercent = pressure.ratioPercent
+      if (pressure.band === 'below') return null
       const prunerState = toolResultPrunerState(resolveAgentService(ctx, agentArg, 'toolResultPruner') ?? resolveContextService(this?.ctx, 'toolResultPruner'))
       const configState = compactionConfigState(this)
-      const nativeFirst = ratioPercent < emergency
+      const nativeFirst = pressure.band === 'native'
       const noOpPrune = () => ({ pruned: [], charsRemoved: 0 })
       const prunerPatch = nativeFirst ? patchToolResultPruner(prunerState, noOpPrune) : undefined
       const configPatch = patchCompactionConfig(configState, originalConfig => adjustedCompactionConfig(originalConfig, target, auto / 100))
@@ -604,29 +616,51 @@ function visibleWebSearchTimeout(state, getConfig) {
 function messagesContainNativeCheckpoint(messages, session) { return Boolean(session && (messages ?? []).some((message) => checkpointStateForMessage(session, message))) }
 function messagesContainLegacyCheckpoint(messages) { return (messages ?? []).some((message) => Boolean(legacyCheckpointId(message))) }
 
-async function* recursiveLlmStream(ctx, options, messages) {
-  const llm = contextService(ctx, 'llm')
-  if (!llm?.stream) throw Object.assign(new Error('LCX portable replay requires ctx.llm.stream'), { code: 'LCX_CHECKPOINT_REPLAY_UNAVAILABLE' })
-  const rewritten = { ...options, messages }
-  bypassReplayOptions.add(rewritten)
-  const stream = await llm.stream(rewritten)
-  for await (const chunk of stream) yield chunk
+function inputHasNativeState(input) {
+  return (input ?? []).some((item) => item?.type === 'compaction')
 }
 
-async function* replayCheckpointStream(options, routeConfig, ctx) {
+async function* managedResponsesStream(options, routeConfig, ctx) {
   const route = currentRoute(options, routeConfig)
-  const session = sessionFor(ctx, route.sessionId)
-  if (!session) throw Object.assign(new Error('Native checkpoint replay requires the live DSH session'), { code: 'LCX_SESSION_UNAVAILABLE' })
-  const incompatibleV4 = (options.messages ?? []).some((message) => { const state = checkpointStateForMessage(session, message); return state && !stateRouteCompatible(state, route, ctx) })
-  if (incompatibleV4) {
-    const portable = rewriteCheckpointsPortable(options.messages, session, { maxChars: routeConfig.portableReplayMaxChars })
-    yield* recursiveLlmStream(ctx, options, portable)
-    return
+  try {
+    if (options.stop !== undefined) throw Object.assign(new Error('LCX Responses does not support GenerateOptions.stop'), { code: 'LCX_RESPONSES_UNSUPPORTED_OPTION' })
+    const prepared = await serializeNativeAware(options.messages, route, routeConfig, ctx, { signal: options.signal, system: options.system, tools: options.tools })
+    const cacheSessionId = promptCacheSessionId(route, routeConfig)
+    const headers = await authenticatedHeaders(ctx, routeConfig, cacheSessionId, cacheSessionId === undefined ? null : undefined)
+    const body = buildResponsesBody({
+      model: prepared.model,
+      input: prepared.input,
+      tools: prepared.tools ?? options.tools,
+      sessionId: cacheSessionId,
+      promptCacheKey: promptCacheKey(route, routeConfig),
+      promptCacheRetention: promptCacheRetention(routeConfig),
+      cacheRetention: routeConfig.cacheRetention,
+      reasoningEffort: options.reasoningEffort,
+      temperature: options.temperature,
+      maxTokens: options.maxTokens,
+    })
+    const nativeReplay = inputHasNativeState(prepared.input)
+    if (nativeReplay) { body.tool_choice = 'auto'; body.parallel_tool_calls = true }
+    yield* streamResponsesRequest({
+      baseURL: routeConfig.baseURL,
+      provider: route.provider,
+      model: route.model,
+      piModel: prepared.model,
+      body,
+      grammarToolInputProperties: prepared.grammarToolInputProperties,
+      headers: nativeReplay ? mergeFeatureHeader(headers) : headers,
+      signal: options.signal,
+      timeoutMs: routeConfig.timeoutMs,
+      maxAttempts: 1,
+      maxResponseBytes: routeConfig.maxResponseBytes,
+    })
+  } catch (error) {
+    yield managedFailureChunk(error, options.signal)
   }
-  const prepared = await serializeNativeAware(options.messages, route, routeConfig, ctx, { signal: options.signal, system: options.system, tools: options.tools })
-  const cacheSessionId = promptCacheSessionId(route, routeConfig)
-  const headers = await authenticatedHeaders(ctx, routeConfig, cacheSessionId, cacheSessionId === undefined ? null : undefined)
-  yield* requestNativeReplay({ baseURL: routeConfig.baseURL, provider: route.provider, model: route.model, input: prepared.input, tools: prepared.tools ?? options.tools, promptCacheKey: promptCacheKey(route, routeConfig), promptCacheRetention: promptCacheRetention(routeConfig), reasoningEffort: options.reasoningEffort, temperature: options.temperature, maxTokens: options.maxTokens, headers, signal: options.signal, timeoutMs: routeConfig.timeoutMs, maxAttempts: routeConfig.maxAttempts, maxResponseBytes: routeConfig.maxResponseBytes })
+}
+
+async function* unavailableManagedRouteStream(options) {
+  yield managedFailureChunk(Object.assign(new Error('LCX is enabled but the selected DSH route cannot be resolved as an authenticated OpenAI Responses wire route'), { code: 'LCX_RESPONSES_ROUTE_UNAVAILABLE' }), options.signal)
 }
 
 function installInjected(ctx, configInput = {}) {
@@ -733,22 +767,14 @@ function installInjected(ctx, configInput = {}) {
   }, { global: true })
 
   ctx.on('llm/stream', (options, next) => {
-    if (bypassReplayOptions.delete(options)) return next()
-    if (!state.enabled || !state.remoteCompaction || options.purpose === 'session-title') return next()
+    if (!state.enabled || options.purpose === 'session-title') return next()
     const routeConfig = resolveResponsesRouteConfig(ctx, options, runtimeConfig)
     if (options.purpose === 'compaction') {
-      if (!routeConfig) return next()
+      if (!routeConfig) return unavailableManagedRouteStream(options)
       return remoteCompactionStream(options, routeConfig, state, ctx, next, requestHeaders)
     }
-    const session = sessionFor(ctx, String(options.sessionId ?? ''))
-    const hasNative = messagesContainNativeCheckpoint(options.messages, session)
-    const hasLegacy = messagesContainLegacyCheckpoint(options.messages)
-    if (!hasNative && !hasLegacy) return next()
-    if (!routeConfig) {
-      if (hasNative && session) return recursiveLlmStream(ctx, options, rewriteCheckpointsPortable(options.messages, session, { maxChars: runtimeConfig.portableReplayMaxChars }))
-      return next()
-    }
-    return replayCheckpointStream(options, routeConfig, ctx)
+    if (!routeConfig) return unavailableManagedRouteStream(options)
+    return managedResponsesStream(options, routeConfig, ctx)
   })
 
   ctx.effect?.(() => async () => {

package/lib/native-checkpoint.js

@@ -63,7 +63,7 @@ import { estimateBudgetItem, portableBudgetError, portableTokenCeiling } from '.
  * @property {unknown} [retainedAssistantCount]
  */
 /** @typedef {{ compaction: CompactionItem }} NativeCompactionResult */
-/** @typedef {{ session: NativeSession, route: RouteIdentity, result: NativeCompactionResult, input?: unknown[], imageMap?: unknown, retentionOptions?: RetentionOptions }} CreateCheckpointOptions */
+/** @typedef {{ session: NativeSession, route: RouteIdentity, result: NativeCompactionResult, input?: unknown[], ephemeralPreludeItemCount?: number, imageMap?: unknown, retentionOptions?: RetentionOptions }} CreateCheckpointOptions */
 /** @typedef {Error & { code?: string }} LcxError */
 
 export const NATIVE_BLOCK_TYPE = 'lcx-native-compaction-v5'
@@ -99,6 +99,8 @@ function assistantTextParts(item) { if (!isObject(item) || item.type !== 'messag
 function isRetainedAssistantItem(item) { return assistantTextParts(item).length > 0 }
 /** @param {unknown} item */
 function assistantText(item) { return assistantTextParts(item).map((part) => part.text).join('') }
+/** @param {unknown} item */
+function retainedAssistantPhase(item) { const phase = isObject(item) ? item.phase : undefined; return phase === 'commentary' || phase === 'final_answer' ? phase : undefined }
 
 /**
  * @param {unknown} item
@@ -107,16 +109,22 @@ function assistantText(item) { return assistantTextParts(item).map((part) => par
  */
 function truncateVisibleAssistantItem(item, maxTokens = ASSISTANT_RETENTION_PER_MESSAGE_TOKEN_CAP) {
   const text = assistantText(item); if (!text) return undefined
-  /** @param {string} retained */
-  const candidate = (retained) => ({ type: 'message', role: 'assistant', content: [{ type: 'output_text', text: retained }] })
-  const full = candidate(text)
+  const phase = retainedAssistantPhase(item)
+  const providerId = isObject(item) && typeof item.id === 'string' && item.id ? item.id : undefined
+  /** @param {string} retained @param {boolean} preserveProviderId */
+  const candidate = (retained, preserveProviderId) => ({
+    type: 'message', role: 'assistant', content: [{ type: 'output_text', text: retained }],
+    ...(phase ? { phase } : {}),
+    ...(preserveProviderId && providerId ? { id: providerId } : {}),
+  })
+  const full = candidate(text, true)
   if ((estimatedItemTokens(full) ?? Infinity) <= maxTokens) return full
   const marker = '\n…[LCX retained answer truncated]…\n'
   /** @param {number} count */
   const shortened = (count) => {
     const available = Math.max(0, count - marker.length)
     const head = Math.floor(available * 0.72); const tail = available - head
-    return candidate(`${text.slice(0, head)}${marker}${text.slice(Math.max(head, text.length - tail))}`)
+    return candidate(`${text.slice(0, head)}${marker}${text.slice(Math.max(head, text.length - tail))}`, false)
   }
   let low = 0; let high = text.length; let best
   while (low <= high) {
@@ -184,7 +192,7 @@ export function activeCompactionId(session) { if (!session?.events) return undef
  * @param {CreateCheckpointOptions} options
  * @returns {NativeCheckpointV5}
  */
-export function createNativeCheckpointBlock({ session, route, result, input = [], imageMap, retentionOptions = {} }) {
+export function createNativeCheckpointBlock({ session, route, result, input = [], ephemeralPreludeItemCount = 0, imageMap, retentionOptions = {} }) {
   const compactionId = activeCompactionId(session)
   if (!compactionId) {
     /** @type {LcxError} */
@@ -192,7 +200,10 @@ export function createNativeCheckpointBlock({ session, route, result, input = []
     error.code = 'LCX_COMPACTION_ID_UNAVAILABLE'
     throw error
   }
-  const retention = retainedConversationPlan(input, retentionOptions)
+  if (!Number.isSafeInteger(ephemeralPreludeItemCount) || ephemeralPreludeItemCount < 0 || ephemeralPreludeItemCount > input.length) {
+    throw Object.assign(new Error('Native compaction prelude provenance is invalid'), { code: 'LCX_COMPACTION_PRELUDE_PROVENANCE_INVALID' })
+  }
+  const retention = retainedConversationPlan(input.slice(ephemeralPreludeItemCount), retentionOptions)
   /** @type {NativeOutputItem[]} */
   const nativeOutput = persistNativeImageReferences([...retention.items, structuredClone(result.compaction)], imageMap)
   return { type: NATIVE_BLOCK_TYPE, version: NATIVE_BLOCK_VERSION, retentionPolicy: 'conversation-fidelity-v1', compactionId, provider: route.provider, model: route.model, baseURLFingerprint: baseURLFingerprint(route.baseURL), sourceSessionId: route.sessionId, nativeOutput, nativeCompaction: structuredClone(result.compaction), retainedInputCount: retention.items.length, retainedClientCount: retention.clientCount, retainedAssistantCount: retention.assistantCount, retainedEstimatedTokens: retention.estimatedTokens, createdAt: Date.now() }