@pure01fx/dsh-openai-codex-auth 0.13.2 → 0.13.4

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## Unreleased
 
+## 0.13.4
+
+- Extends the replacement meter to supply the UI context-pressure projection. Estimated occupancy includes native encrypted replay while measured input remains unchanged; per-session request routes, model-window matching, and compatible sample selection isolate conversations and model switches. Projection checkpoints recompute policy-dependent views on restore, and ownership changes rebuild the single pressure registration.
+
+## 0.13.3
+
+- Supplies a replacement token-meter service through the package composition patch, so Codex encrypted reasoning participates in retained-history pricing and pressure reductions after compaction without changing Harness source. Reuses ordinary host pricing, preserves fixed heuristic projections, and corrects usage anchors without double-counting reasoning output. Preserves an explicitly reported zero reasoning count so it does not trigger the missing-detail fallback.
+
 ## 0.13.2
 
 - Stops putting `is_error` on a replayed `function_call_output`. The Responses wire has no such field (Codex reports a failed tool through the output text and keeps its own `success` flag internal), one Lite model answers the unknown item field with a 400 `INVALID_REQUEST`, and because the item is replayed from durable history, a single failed tool call then fails every later request in that session.

package/README.md

@@ -253,13 +253,45 @@ $DSH_HOME/openai-codex-auth.json
 
 `path` 的优先级高于 `dshHome`。
 
+### 关闭或恢复计量服务替代
+
+计量服务的选择由组合节点控制，目前不是 `openai-codex-auth` 的 `config` 开关。要保留 Codex Provider、OAuth 和 UI 功能，同时恢复 DSH 默认计量器，将以下覆盖项放到 profile 最后应用的补丁中（在本包补丁之后）：
+
+```yaml
+- id: token-meter
+  disabled: false
+
+- id: codex-token-meter
+  disabled: true
+```
+
+两项必须同时设置，确保只有一个 `ctx.tokenMeter`；关闭替代后，本包的隐藏推理保留预算修正及 UI 预计占用修正都会停用。`nativeAdapter: false` 只切换 Provider 行为，不会恢复 base 的计量节点。自定义 profile 如果使用不同节点 ID，应替换上面的 ID。
+
+保存覆盖配置后重新启动该 profile，使服务选择在启动时生效，避免在线切换过程中出现两个计量服务同时挂载。
+
+要重新启用本包计量器，反向覆盖这两项并重新启动 profile：
+
+```yaml
+- id: token-meter
+  disabled: true
+
+- id: codex-token-meter
+  disabled: false
+```
+
 ### 原生 Codex transport 与组合边界
 
 本包跟踪的上游 Codex repository、commit、release 与 Catalog client version 只在 `src/upstream.ts` 维护；升级上游时先更新该文件，再刷新 fixtures、生成产物和兼容测试，避免多个散落 hash 漂移。
 
 从 0.6 开始，Native Adapter 是插件默认 Provider，并持有生产 route `openai-codex`。旧预览会话确实需要时，可显式设置 `nativeCompatibilityRoute: true`，让同一个 adapter 同时注册 `openai-codex-native` 兼容 route；启用兼容 route 时两者仍原子注册，任一 route 已被占用都会整体失败。默认只暴露生产 route。
 
-本包只定义 Codex Provider，不发布或改写任何具体 Profile。整合包必须在挂载本插件前释放已有的 `openai-codex` route，例如从自己的 `llm-pi-ai` provider map 中移除该项；本包不会清空未知的 sibling providers。只想复用 OAuth/UI 并继续使用外部 Provider 的组合可以显式设置 `nativeAdapter: false`。从 pi-ai 切到 Native 时，旧 foreign replay 会降级为可见持久历史；反向切回 pi-ai 后，已产生 Native replay 的进行中 session 不保证可续跑，应新建 session。
+本包提供 Codex Provider 和计量服务替代入口，不发布具体 Profile。整合包必须在挂载本插件前释放已有的 `openai-codex` route，例如从自己的 `llm-pi-ai` provider map 中移除该项；本包不会清空未知的 sibling providers。只想复用 OAuth/UI 并继续使用外部 Provider 的组合可以显式设置 `nativeAdapter: false`。从 pi-ai 切到 Native 时，旧 foreign replay 会降级为可见持久历史；反向切回 pi-ai 后，已产生 Native replay 的进行中 session 不保证可续跑，应新建 session。
+
+`cordis.patch.yml` 会禁用 base bundle 的 `token-meter` 节点，并挂载本包 `/token-meter` 入口作为唯一的 `ctx.tokenMeter`；无需修改 DSH 源码。自定义组合应禁用自己的默认计量服务，再挂载同一入口，不能同时运行两个计量服务。服务复用宿主的文本、图片、文件计价及用量、组成投影，只对源 route 与目标 route 属于同一个活跃 Native Codex adapter 的历史补充加密推理价格；`nativeAdapter: false` 和其他模型沿用宿主价格。
+
+加密推理计量优先使用原始响应的 `usage.reasoningTokens`，每次响应计一次；缺少推理细分时以 `outputTokens` 作为生成推理的保守上界，连用量也没有时才用解码密文的字节数作体积估算。这些都是重放占用估计，不是精确的服务端输入计费。计量会同时修正节点 `tokens`、`surfaceTokens`、完整锚点与有符号的 `surfaceDeltaTokens`，服务端已计入的推理不会再加一次，压缩移除历史时会扣减隐藏占用；`heuristicTokens`、持久消息和服务端用量保持原语义。UI 的 `contextPressure` 由本包注册一个纯投影，复用同一隐藏推理定价函数；`pressureTokens` 仍是最近服务端实测输入，`projectedTokens` 是预计下一次请求占用，适用的加密推理会计入增长和压缩扣减。每个对话根据已提交的 `request/header` 独立选择路由，稳定的其他模型对话沿用原投影规则；模型或请求信封改变后重新估算，并在匹配的 `request/context` 到达前不显示旧模型窗口。
+
+UI 投影的缓存保存与当前路由策略无关的每来源价格和采样总量，读取旧格式缓存会完整回放；同格式缓存读取时重新计算展示值，因此重启、分支恢复及 Native 路由归属变化不会沿用旧展示缓存。无法确认兼容性的跨 route 用量样本会使用完整估算，实测输入字段不变。路由归属变化会重建投影；宿主注册接口不主动推送空闲对话，现有订阅在下一次会话事件或快照读取时看到新值。尚未提交为请求信封的模型选择不属于该日志投影的输入。
 
 上游 Native Codex Responses 请求没有输出 token 上限字段，因此普通会话若显式设置 `maxTokens` 仍会在 Provider I/O 前失败。DSH 的压缩与会话标题辅助调用会固定携带 `maxTokens`，并分别通过 `purpose: compaction` 与 `purpose: session-title` 标识；本适配器允许这两类 hint 通过，但不会把它序列化为 `max_output_tokens`，实际输出长度仍由 Native Codex 决定。
 

package/cordis.patch.yml

@@ -1,5 +1,10 @@
 # Native Codex is the package default. Integration bundles own any removal or
 # replacement of an existing openai-codex route before mounting this plugin.
+# Replace the service provider without renaming the base token-meter row.
+- id: token-meter
+  disabled: true
 - insert:
     - id: openai-codex-auth
       name: '@pure01fx/dsh-openai-codex-auth'
+    - id: codex-token-meter
+      name: '@pure01fx/dsh-openai-codex-auth/token-meter'

package/lib/index.js

@@ -9,7 +9,7 @@ import { createHash, randomBytes } from 'node:crypto';
 import { readFile, stat, unlink } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { INVALID_CREDENTIAL_CODE, LlmError } from '@deepseek-ai/dsh-llm';
-import { CODEX_PROVIDER, NATIVE_CODEX_PROVIDER, NativeCodexAdapter, } from './native-adapter.js';
+import { CODEX_PROVIDER, NATIVE_CODEX_PROVIDER, NativeCodexAdapter, registerNativeCodexAdapter, } from './native-adapter.js';
 export { CODEX_PROVIDER, NATIVE_CODEX_PROVIDER } from './native-adapter.js';
 import { NativeCodexCatalog } from './catalog.js';
 import { NativeCodexHttpTransport } from './native-http.js';
@@ -795,7 +795,7 @@ export class OpenAICodexAuth extends Service {
                 ctx.effect(() => () => { transport.dispose(); }, 'openai-codex-auth: dispose native WebSockets');
             }
             ctx.inject(['llm'], (llmCtx) => {
-                llmCtx.llm.registerAdapter([
+                registerNativeCodexAdapter(llmCtx, [
                     CODEX_PROVIDER,
                     ...(this.routeConfig.nativeCompatibilityRoute ? [NATIVE_CODEX_PROVIDER] : []),
                 ], new NativeCodexAdapter(catalog, transport));

package/lib/native-adapter.d.ts

@@ -1,10 +1,41 @@
 /** Native Codex adapter with live catalog and HTTP/WebSocket transport delegation. */
-import { LlmAdapter, type GenerateOptions, type LlmModelInfo, type LlmProviderInfo, type LlmResolvedModelInfo, type ResolvedRetryPolicy, type StreamChunk } from '@deepseek-ai/dsh-llm';
+import { LlmAdapter, type GenerateOptions, type LlmModelInfo, type LlmRuntime, type LlmProviderInfo, type LlmResolvedModelInfo, type ResolvedRetryPolicy, type StreamChunk } from '@deepseek-ai/dsh-llm';
+import { type Context } from '@deepseek-ai/cordis';
 import type { NativeCodexModel, NativeCodexModelCatalog } from './catalog.js';
 /** Production provider route owned by the package native Codex adapter after M6 cutover. */
 export declare const CODEX_PROVIDER = "openai-codex";
 /** Compatibility route retained for sessions created during the native preview. */
 export declare const NATIVE_CODEX_PROVIDER = "openai-codex-native";
+declare module '@deepseek-ai/cordis' {
+    interface Events {
+        /**
+         * Native replay ownership changed.
+         * @mode emit
+         */
+        'codex/replay-owners-updated'(): void;
+    }
+}
+/**
+ * Snapshot immutable provider groups for a pure projection's replay policy.
+ * @param runtime - current LLM service, or undefined before it is available.
+ * @returns sorted groups; each group is owned by one native adapter instance.
+ */
+export declare function nativeCodexReplayGroups(runtime: LlmRuntime | undefined): readonly (readonly string[])[];
+/**
+ * Register native routes and their replay-pricing ownership in the same Cordis scope.
+ * @param ctx - scope owning the native adapter registration.
+ * @param providers - canonical and optional compatibility routes for this instance.
+ * @param adapter - native adapter that will replay its own continuation state.
+ */
+export declare function registerNativeCodexAdapter(ctx: Context, providers: string[], adapter: NativeCodexAdapter): void;
+/**
+ * Match the runtime's same-adapter ownership rule for native continuation replay.
+ * @param runtime - current global LLM service instance.
+ * @param sourceProvider - provider that produced the historical assistant message.
+ * @param targetProvider - provider preparing the measured request.
+ * @returns whether both routes are currently owned by the same native adapter.
+ */
+export declare function canReplayNativeCodex(runtime: LlmRuntime, sourceProvider: string, targetProvider: string): boolean;
 export declare const CODEX_FAST_ALIAS_SUFFIX = "-fast";
 export declare const CODEX_FAST_SERVICE_TIER = "priority";
 /** Pure network establishment failure; retried without consuming the finite stream budget. */

package/lib/native-adapter.js

@@ -1,10 +1,72 @@
 /** Native Codex adapter with live catalog and HTTP/WebSocket transport delegation. */
 import { LlmAdapter, LlmError, ReasoningEffortId, } from '@deepseek-ai/dsh-llm';
+import { symbols } from '@deepseek-ai/cordis';
 /** Production provider route owned by the package native Codex adapter after M6 cutover. */
 export const CODEX_PROVIDER = 'openai-codex';
 /** Compatibility route retained for sessions created during the native preview. */
 export const NATIVE_CODEX_PROVIDER = 'openai-codex-native';
 const OWNED_CODEX_PROVIDERS = new Set([CODEX_PROVIDER, NATIVE_CODEX_PROVIDER]);
+const replayOwners = new WeakMap();
+/**
+ * Snapshot immutable provider groups for a pure projection's replay policy.
+ * @param runtime - current LLM service, or undefined before it is available.
+ * @returns sorted groups; each group is owned by one native adapter instance.
+ */
+export function nativeCodexReplayGroups(runtime) {
+    if (runtime === undefined)
+        return Object.freeze([]);
+    const groups = new Map();
+    for (const [provider, adapter] of replayOwners.get(runtimeKey(runtime)) ?? []) {
+        const group = groups.get(adapter) ?? [];
+        group.push(provider);
+        groups.set(adapter, group);
+    }
+    return Object.freeze([...groups.values()].map(group => Object.freeze(group.sort()))
+        .sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b))));
+}
+// Cordis returns scope-traced views; use the original service for ownership identity.
+function runtimeKey(runtime) {
+    return Reflect.get(runtime, symbols.original) ?? runtime;
+}
+/**
+ * Register native routes and their replay-pricing ownership in the same Cordis scope.
+ * @param ctx - scope owning the native adapter registration.
+ * @param providers - canonical and optional compatibility routes for this instance.
+ * @param adapter - native adapter that will replay its own continuation state.
+ */
+export function registerNativeCodexAdapter(ctx, providers, adapter) {
+    const runtime = ctx.get('llm');
+    if (runtime === undefined)
+        throw new Error('native Codex registration requires llm');
+    ctx.llm.registerAdapter(providers, adapter);
+    ctx.effect(() => {
+        let owners = replayOwners.get(runtimeKey(runtime));
+        if (owners === undefined)
+            replayOwners.set(runtimeKey(runtime), owners = new Map());
+        for (const provider of providers)
+            owners.set(provider, adapter);
+        ctx.emit('codex/replay-owners-updated');
+        return () => {
+            for (const provider of providers) {
+                if (owners.get(provider) === adapter)
+                    owners.delete(provider);
+            }
+            ctx.emit('codex/replay-owners-updated');
+        };
+    });
+}
+/**
+ * Match the runtime's same-adapter ownership rule for native continuation replay.
+ * @param runtime - current global LLM service instance.
+ * @param sourceProvider - provider that produced the historical assistant message.
+ * @param targetProvider - provider preparing the measured request.
+ * @returns whether both routes are currently owned by the same native adapter.
+ */
+export function canReplayNativeCodex(runtime, sourceProvider, targetProvider) {
+    const owners = replayOwners.get(runtimeKey(runtime));
+    const adapter = owners?.get(targetProvider);
+    return adapter !== undefined && owners?.get(sourceProvider) === adapter;
+}
 export const CODEX_FAST_ALIAS_SUFFIX = '-fast';
 export const CODEX_FAST_SERVICE_TIER = 'priority';
 /** Pure network establishment failure; retried without consuming the finite stream budget. */

package/lib/pressure-projection.d.ts

@@ -0,0 +1,69 @@
+import { type Context } from '@deepseek-ai/cordis';
+import { z } from 'zod';
+import { SessionSeq } from '@deepseek-ai/dsh-session';
+import type { ProjectionDefinition, SessionProjectionMap, SessionProjectionStateMap } from '@deepseek-ai/dsh-session-projection';
+type BaseState = SessionProjectionStateMap['contextPressure'];
+type View = SessionProjectionMap['contextPressure'];
+type PressureDefinition = ProjectionDefinition<'contextPressure'> & {
+    wire: NonNullable<ProjectionDefinition<'contextPressure'>['wire']>;
+};
+declare const extraSchema: z.ZodObject<{
+    header: z.ZodNullable<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+        fingerprint: z.ZodString;
+        tools: z.ZodNumber;
+    }, z.core.$strict>>;
+    sample: z.ZodNullable<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+        fingerprint: z.ZodString;
+        tools: z.ZodNumber;
+    }, z.core.$strict>>;
+    sampleNative: z.ZodNullable<z.ZodBoolean>;
+    nativeHistory: z.ZodBoolean;
+    context: z.ZodNullable<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+    }, z.core.$strict>>;
+    nodes: z.ZodArray<z.ZodObject<{
+        seq: z.ZodPipe<z.ZodNumber, z.ZodTransform<SessionSeq, number>>;
+        position: z.ZodPipe<z.ZodNumber, z.ZodTransform<SessionSeq, number>>;
+        provider: z.ZodString;
+        tokens: z.ZodNumber;
+    }, z.core.$strict>>;
+    positions: z.ZodArray<z.ZodObject<{
+        seq: z.ZodPipe<z.ZodNumber, z.ZodTransform<SessionSeq, number>>;
+        position: z.ZodPipe<z.ZodNumber, z.ZodTransform<SessionSeq, number>>;
+    }, z.core.$strict>>;
+    sampledHidden: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strict>;
+type Extra = z.infer<typeof extraSchema> & {
+    view: View;
+};
+type State = BaseState & {
+    codex: Extra;
+};
+/**
+ * Withhold only the host pressure registration in an isolated service view.
+ * All other registrations use the original caller-traced registry and disposer.
+ * @param ctx - scope owning the replacement meter.
+ * @returns scoped constructor context and the captured host pressure definition.
+ */
+export declare function capturePressureRegistration(ctx: Context): {
+    context: Context;
+    readonly definition: PressureDefinition;
+    register<S extends BaseState>(definition: ProjectionDefinition<'contextPressure', S>): () => void;
+};
+/**
+ * Add hidden replay to the existing UI pressure fields using only logged data.
+ * Native groups are immutable policy; source prices and sample totals stay
+ * policy-independent so checkpoints can be safely restored after ownership changes.
+ * @param base - host pressure fold, schema, and wire view.
+ * @param groups - provider routes grouped by their active native adapter.
+ * @returns one pure pressure unit with a policy-independent checkpoint format.
+ */
+export declare function codexPressureProjection(base: PressureDefinition, groups: readonly (readonly string[])[]): ProjectionDefinition<'contextPressure', State> & {
+    wire: NonNullable<ProjectionDefinition<'contextPressure', State>['wire']>;
+};
+export {};

package/lib/pressure-projection.js

@@ -0,0 +1,216 @@
+/** Pure, route-aware UI pressure pricing and scoped host registration forwarding. */
+import { createHash } from 'node:crypto';
+import { symbols } from '@deepseek-ai/cordis';
+import { z } from 'zod';
+import { lastAssistantStreamChunk } from '@deepseek-ai/dsh-llm';
+import { canonicalHeader, deriveEventMessage, isSurfaceEvent, SessionSeq, } from '@deepseek-ai/dsh-session';
+import { estimateToolsTokens } from '@deepseek-ai/dsh-token-meter/estimate';
+import { CODEX_PROVIDER, NATIVE_CODEX_PROVIDER } from './native-adapter.js';
+import { estimateNativeCodexReplayTokens, hasNativeCodexReplayKind } from './replay.js';
+const sequence = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).transform(SessionSeq);
+const count = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+const routeSchema = z.object({ provider: z.string(), model: z.string(), fingerprint: z.string(), tools: count }).strict();
+const extraSchema = z.object({
+    header: routeSchema.nullable(),
+    sample: routeSchema.nullable(),
+    sampleNative: z.boolean().nullable(),
+    nativeHistory: z.boolean(),
+    context: z.object({ provider: z.string(), model: z.string() }).strict().nullable(),
+    nodes: z.array(z.object({ seq: sequence, position: sequence, provider: z.string(), tokens: count }).strict()),
+    positions: z.array(z.object({ seq: sequence, position: sequence }).strict()),
+    sampledHidden: z.record(z.string(), count),
+}).strict();
+function route(header) {
+    const normalized = canonicalHeader(header);
+    return {
+        provider: normalized.config.provider,
+        model: normalized.config.model,
+        fingerprint: createHash('sha256').update(JSON.stringify({
+            config: {
+                provider: normalized.config.provider, model: normalized.config.model,
+                reasoningEffort: normalized.config.reasoningEffort, temperature: normalized.config.temperature,
+                maxTokens: normalized.config.maxTokens, stop: normalized.config.stop,
+            },
+            adapterDefaults: {
+                reasoningEffort: normalized.adapterDefaults?.reasoningEffort,
+                maxTokens: normalized.adapterDefaults?.maxTokens,
+            },
+            tools: normalized.tools ?? [],
+        })).digest('hex'),
+        tools: estimateToolsTokens(normalized),
+    };
+}
+function sums(nodes) {
+    const totals = {};
+    for (const node of nodes)
+        totals[node.provider] = (totals[node.provider] ?? 0) + node.tokens;
+    return totals;
+}
+function sameView(a, b) {
+    return a.pressureTokens === b.pressureTokens && a.projectedTokens === b.projectedTokens
+        && a.contextWindow === b.contextWindow;
+}
+/**
+ * Withhold only the host pressure registration in an isolated service view.
+ * All other registrations use the original caller-traced registry and disposer.
+ * @param ctx - scope owning the replacement meter.
+ * @returns scoped constructor context and the captured host pressure definition.
+ */
+export function capturePressureRegistration(ctx) {
+    const registry = ctx.sessionProjections;
+    const originalRegister = registry.register;
+    let captured;
+    const register = (definition) => {
+        if (definition.key === 'contextPressure') {
+            if (definition.wire === undefined)
+                throw new Error('host pressure projection has no wire view');
+            captured = { ...definition, wire: definition.wire };
+            return () => { };
+        }
+        return Reflect.apply(originalRegister, registry, [definition]);
+    };
+    const forwarded = new Proxy(registry, {
+        get(target, key, receiver) {
+            // Suppress another Cordis trace wrapper, which would bypass the register trap.
+            if (key === symbols.tracker)
+                return undefined;
+            if (key === 'register')
+                return register;
+            return Reflect.get(target, key, receiver);
+        },
+    });
+    const context = ctx.isolate('sessionProjections');
+    context.provide('sessionProjections', forwarded);
+    return { context, register(definition) {
+            return Reflect.apply(originalRegister, registry, [definition]);
+        }, get definition() {
+            if (captured === undefined)
+                throw new Error('host token meter did not register contextPressure');
+            return captured;
+        } };
+}
+/**
+ * Add hidden replay to the existing UI pressure fields using only logged data.
+ * Native groups are immutable policy; source prices and sample totals stay
+ * policy-independent so checkpoints can be safely restored after ownership changes.
+ * @param base - host pressure fold, schema, and wire view.
+ * @param groups - provider routes grouped by their active native adapter.
+ * @returns one pure pressure unit with a policy-independent checkpoint format.
+ */
+export function codexPressureProjection(base, groups) {
+    const owners = new Map(groups.flatMap((group, index) => group.map(provider => [provider, index])));
+    const hidden = (totals, target) => {
+        const owner = owners.get(target);
+        if (owner === undefined)
+            return 0;
+        return Object.entries(totals).reduce((n, [provider, tokens]) => n + (owners.get(provider) === owner ? tokens : 0), 0);
+    };
+    const view = (state, extra) => {
+        const original = base.wire.view(state);
+        const header = extra.header;
+        if (header === null)
+            return original;
+        const native = owners.has(header.provider);
+        const sampleProvider = extra.sample?.provider;
+        const changedEnvelope = extra.sample !== null && extra.sample.fingerprint !== header.fingerprint;
+        if (!native && !extra.nativeHistory && extra.sampleNative !== true
+            && !owners.has(sampleProvider ?? '') && !changedEnvelope)
+            return original;
+        const current = hidden(sums(extra.nodes), header.provider);
+        const sampled = hidden(extra.sampledHidden, header.provider);
+        const sampledSources = Object.entries(extra.sampledHidden).filter(([, tokens]) => tokens > 0);
+        const policyCompatible = native
+            ? sampledSources.every(([source]) => source === extra.sample?.provider
+                && owners.get(source) === owners.get(header.provider))
+            : extra.sampleNative === false || sampledSources.length === 0 && extra.sampleNative !== true;
+        const compatible = extra.sample?.fingerprint === header.fingerprint
+            && (extra.sampleNative === null || extra.sampleNative === native) && policyCompatible
+            && state.pressureTokens !== undefined
+            && state.sampledSurfaceTokens !== undefined
+            && state.pressureTokens >= state.sampledSurfaceTokens + header.tools + sampled;
+        const projectedTokens = compatible
+            ? Math.max(0, state.pressureTokens + state.surfaceTokens - state.sampledSurfaceTokens + current - sampled)
+            : state.surfaceTokens + header.tools + current;
+        const { contextWindow: _oldWindow, ...reported } = original;
+        return {
+            ...reported, projectedTokens,
+            ...extra.context?.provider === header.provider && extra.context.model === header.model
+                && original.contextWindow !== undefined ? { contextWindow: original.contextWindow } : {},
+        };
+    };
+    const stateSchema = z.record(z.string(), z.unknown()).transform((value, ctx) => {
+        const { codex, ...legacy } = value;
+        const parsedBase = base.stateSchema.safeParse(legacy);
+        const parsedExtra = extraSchema.safeParse(typeof codex === 'object' && codex !== null
+            ? Object.fromEntries(Object.entries(codex).filter(([key]) => key !== 'view')) : codex);
+        if (!parsedBase.success || !parsedExtra.success) {
+            ctx.addIssue({ code: 'custom', message: 'invalid Codex pressure checkpoint' });
+            return z.NEVER;
+        }
+        return { ...parsedBase.data, codex: { ...parsedExtra.data, view: view(parsedBase.data, parsedExtra.data) } };
+    });
+    return {
+        key: 'contextPressure', stateVersion: 6, stateSchema,
+        init: (header, inherited) => {
+            const initial = base.init(header, inherited);
+            const extra = {
+                header: null, sample: null, sampleNative: null, nativeHistory: false, context: null,
+                nodes: [], positions: [], sampledHidden: {},
+            };
+            return { ...initial, codex: { ...extra, view: view(initial, extra) } };
+        },
+        apply: (state, event) => {
+            const next = base.apply(state, event);
+            let extra = state.codex;
+            if (event.type === 'request/header') {
+                const nextRoute = route(event.data.header);
+                if (nextRoute.fingerprint !== extra.header?.fingerprint)
+                    extra = { ...extra, header: nextRoute };
+            }
+            if (event.type === 'request/context')
+                extra = { ...extra, context: { provider: event.data.provider, model: event.data.model } };
+            if (event.type === 'assistant/message' || event.type === 'assistant/attempt') {
+                const usage = event.type === 'assistant/message' && event.data.usage !== undefined
+                    ? event.data.usage : lastAssistantStreamChunk(event.data.stream, 'usage')?.usage;
+                if (usage !== undefined) {
+                    const finish = lastAssistantStreamChunk(event.data.stream, 'finish');
+                    const replay = finish?.replayState ?? (event.type === 'assistant/message'
+                        && event.data.message.source.kind === 'model' ? event.data.message.source.replayState : undefined);
+                    const native = replay === undefined || replay === null ? null : hasNativeCodexReplayKind(replay);
+                    extra = { ...extra, sample: extra.header, sampledHidden: sums(extra.nodes), sampleNative: native,
+                        nativeHistory: extra.nativeHistory || native === true };
+                }
+            }
+            if (isSurfaceEvent(event)) {
+                const message = deriveEventMessage(event);
+                const source = message?.role === 'assistant' && message.source.kind === 'model' ? message.source : undefined;
+                const originalNative = source !== undefined && hasNativeCodexReplayKind(source.replayState)
+                    && (source.provider === CODEX_PROVIDER || source.provider === NATIVE_CODEX_PROVIDER);
+                const price = originalNative ? estimateNativeCodexReplayTokens(source, event.type === 'assistant/message' ? event.data.usage : undefined) : 0;
+                let nodes = extra.nodes;
+                let positions = extra.positions;
+                let position = event.seq;
+                if (event.surfaceOp !== 'append') {
+                    const { startSeq, endSeq } = event.surfaceOp;
+                    const first = positions.find(node => node.seq === startSeq)?.position ?? startSeq;
+                    const last = positions.find(node => node.seq === endSeq)?.position ?? endSeq;
+                    if (last < first)
+                        throw new Error('Codex pressure: invalid positional replacement');
+                    position = first;
+                    nodes = nodes.filter(node => node.position < first || node.position > last);
+                    positions = [...positions.filter(node => node.position < first || node.position > last), { seq: event.seq, position }];
+                }
+                if (price > 0 && source !== undefined)
+                    nodes = [...nodes, { seq: event.seq, position, provider: source.provider, tokens: price }];
+                if (nodes !== extra.nodes || positions !== extra.positions || originalNative && !extra.nativeHistory) {
+                    extra = { ...extra, nodes, positions, nativeHistory: extra.nativeHistory || originalNative };
+                }
+            }
+            if (next === state && extra === state.codex)
+                return state;
+            const output = view(next, extra);
+            return { ...next, codex: { ...extra, view: sameView(output, state.codex.view) ? state.codex.view : output } };
+        },
+        wire: { viewSchema: base.wire.viewSchema, view: state => state.codex.view },
+    };
+}

package/lib/replay.d.ts

@@ -1,5 +1,5 @@
 /** Versioned Codex Responses continuation state. */
-import { type ContentBlock } from '@deepseek-ai/dsh-llm';
+import { type AssistantProviderMetadata, type ContentBlock, type TokenUsage } from '@deepseek-ai/dsh-llm';
 export declare const NATIVE_CODEX_REPLAY_KIND = "openai-codex-native.responses-replay";
 export declare const NATIVE_CODEX_REPLAY_VERSION = 1;
 export type CodexMessagePhase = 'commentary' | 'partial_answer' | 'final_answer';
@@ -36,6 +36,16 @@ export interface NativeCodexReplaySource {
 export declare function replayableItemId(value: string | undefined): string | undefined;
 /** True only for legacy raw state or an rc.2 envelope emitted by this package. */
 export declare function hasNativeCodexReplayKind(value: unknown): boolean;
+/**
+ * Estimate hidden reasoning only when the native continuation replays encrypted items.
+ * A response's reasoning usage is charged once, not once per reasoning item.
+ * Without reasoning details, output usage bounds the generated reasoning; without
+ * usage, decoded ciphertext bytes are a size heuristic, not exact token billing.
+ * @param source - original provider/model and native continuation state.
+ * @param usage - original response usage, when available in the durable event.
+ * @returns additional hidden replay tokens; zero for non-native or unencrypted state.
+ */
+export declare function estimateNativeCodexReplayTokens(source: AssistantProviderMetadata, usage?: TokenUsage): number;
 /** Attempt-local accumulator for completed replay descriptors. */
 export declare class NativeCodexReplayCapture {
     private readonly provider;

package/lib/replay.js

@@ -125,6 +125,29 @@ function parseState(value) {
         items,
     };
 }
+/**
+ * Estimate hidden reasoning only when the native continuation replays encrypted items.
+ * A response's reasoning usage is charged once, not once per reasoning item.
+ * Without reasoning details, output usage bounds the generated reasoning; without
+ * usage, decoded ciphertext bytes are a size heuristic, not exact token billing.
+ * @param source - original provider/model and native continuation state.
+ * @param usage - original response usage, when available in the durable event.
+ * @returns additional hidden replay tokens; zero for non-native or unencrypted state.
+ */
+export function estimateNativeCodexReplayTokens(source, usage) {
+    if (!hasNativeCodexReplayKind(source.replayState))
+        return 0;
+    const state = parseState(source.replayState);
+    if (state.provider !== source.provider || state.model !== source.model) {
+        throw failure('native Codex replay identity does not match its assistant message');
+    }
+    const encrypted = state.items.flatMap(item => item.type === 'reasoning' && item.encryptedContent !== undefined ? [item.encryptedContent] : []);
+    if (encrypted.length === 0)
+        return 0;
+    if (usage !== undefined)
+        return usage.reasoningTokens ?? usage.outputTokens;
+    return encrypted.reduce((total, content) => total + Buffer.byteLength(content, 'base64'), 0);
+}
 /** Attempt-local accumulator for completed replay descriptors. */
 export class NativeCodexReplayCapture {
     provider;

package/lib/responses.js

@@ -289,7 +289,7 @@ export function mapResponsesUsage(usage) {
         inputTokens: uncached, outputTokens: output,
         ...cached === 0 ? {} : { cacheReadTokens: cached },
         ...written === 0 ? {} : { cacheWriteTokens: written },
-        ...reasoning === 0 ? {} : { reasoningTokens: reasoning },
+        ...usage.output_tokens_details?.reasoning_tokens === undefined ? {} : { reasoningTokens: reasoning },
     };
 }
 function retryDelay(message) {

package/lib/token-meter.d.ts

@@ -0,0 +1,30 @@
+/** Codex hidden-replay pricing layered over the host's ordinary token meter. */
+import { TokenMeter } from '@deepseek-ai/dsh-token-meter';
+import type { TokenMeasurement, TokenMeterConfig } from '@deepseek-ai/dsh-token-meter';
+import type { Context } from '@deepseek-ai/cordis';
+import type { EpochHeader, Session } from '@deepseek-ai/dsh-session';
+/**
+ * Replacement tokenMeter service that charges native Codex encrypted reasoning.
+ * Ordinary prices, usage, and breakdown projections come from the host meter.
+ * The UI pressure unit adds the same hidden pricing per logged request route. Hidden prices apply
+ * only between routes currently owned by the same native adapter; fixed
+ * heuristicTokens stay unchanged. Provider usage is not charged a second time.
+ */
+export declare class CodexTokenMeter extends TokenMeter {
+    static inject: string[];
+    private readonly hiddenFolds;
+    constructor(ctx: Context, config?: TokenMeterConfig);
+    /**
+     * Return a detached measurement including opaque native replay in node prices,
+     * surface totals, and signed anchor deltas. Recheck usage conservatism against
+     * the corrected full anchor before reusing the provider sample.
+     * @param session - session to price through its current durable tail.
+     * @param requestHeader - optional effective routed request envelope.
+     * @returns immutable request pressure and positional message prices.
+     */
+    measure(session: Session, requestHeader?: EpochHeader): TokenMeasurement;
+    /** Track only replay metadata and surface positions; the host validates each event first. */
+    private syncHidden;
+    private foldHidden;
+}
+export default CodexTokenMeter;

package/lib/token-meter.js

@@ -0,0 +1,156 @@
+/** Codex hidden-replay pricing layered over the host's ordinary token meter. */
+import { TokenMeter } from '@deepseek-ai/dsh-token-meter';
+import { capturePressureRegistration, codexPressureProjection } from './pressure-projection.js';
+import { estimateToolsTokens } from '@deepseek-ai/dsh-token-meter/estimate';
+import { assembleAssistantStream } from '@deepseek-ai/dsh-llm';
+import { canonicalHeader, deriveEventMessage, headerEquals, isSurfaceEvent, SessionSeq, } from '@deepseek-ai/dsh-session';
+import { canReplayNativeCodex, nativeCodexReplayGroups } from './native-adapter.js';
+import { estimateNativeCodexReplayTokens } from './replay.js';
+function replayPrice(message, usage) {
+    if (message?.role !== 'assistant' || message.source.kind !== 'model')
+        return undefined;
+    return { source: message.source, usage };
+}
+function sameHeader(a, b) {
+    return a === undefined || b === undefined ? a === b : headerEquals(a, b);
+}
+/**
+ * Replacement tokenMeter service that charges native Codex encrypted reasoning.
+ * Ordinary prices, usage, and breakdown projections come from the host meter.
+ * The UI pressure unit adds the same hidden pricing per logged request route. Hidden prices apply
+ * only between routes currently owned by the same native adapter; fixed
+ * heuristicTokens stay unchanged. Provider usage is not charged a second time.
+ */
+export class CodexTokenMeter extends TokenMeter {
+    static inject = ['sessionProjections', 'llm'];
+    hiddenFolds = new WeakMap();
+    constructor(ctx, config) {
+        const capture = capturePressureRegistration(ctx);
+        super(capture.context, config);
+        let unregister;
+        let policy;
+        const refresh = () => {
+            const groups = nativeCodexReplayGroups(ctx.get('llm'));
+            const fingerprint = JSON.stringify(groups);
+            if (fingerprint === policy)
+                return;
+            unregister?.();
+            unregister = capture.register(codexPressureProjection(capture.definition, groups));
+            policy = fingerprint;
+        };
+        refresh();
+        ctx.on('codex/replay-owners-updated', refresh);
+        ctx.effect(() => () => { unregister?.(); });
+    }
+    /**
+     * Return a detached measurement including opaque native replay in node prices,
+     * surface totals, and signed anchor deltas. Recheck usage conservatism against
+     * the corrected full anchor before reusing the provider sample.
+     * @param session - session to price through its current durable tail.
+     * @param requestHeader - optional effective routed request envelope.
+     * @returns immutable request pressure and positional message prices.
+     */
+    measure(session, requestHeader) {
+        const base = super.measure(session, requestHeader);
+        const state = this.syncHidden(session, base.logRevision);
+        const header = requestHeader === undefined ? state.header : canonicalHeader(requestHeader);
+        const runtime = this.ctx.get('llm');
+        const provider = header?.config?.provider;
+        if (runtime === undefined || provider === undefined)
+            return base;
+        const price = (replay) => {
+            if (replay === undefined || !canReplayNativeCodex(runtime, replay.source.provider, provider))
+                return 0;
+            return replay.tokens ??= estimateNativeCodexReplayTokens(replay.source, replay.usage);
+        };
+        const current = new Map(state.nodes.map(node => [node.seq, price(node.replay)]));
+        const hiddenCurrent = base.nodes.reduce((total, node) => total + (current.get(node.seq) ?? 0), 0);
+        const anchor = state.anchor;
+        const matched = anchor !== undefined && sameHeader(anchor.header, header);
+        const hiddenAnchor = matched
+            ? anchor.nodes.reduce((total, node) => total + price(node.replay), 0) + price(anchor.assistant)
+            : 0;
+        if (hiddenCurrent === 0 && hiddenAnchor === 0)
+            return base;
+        let baseline = base.baseline;
+        let surfaceDeltaTokens = base.surfaceDeltaTokens;
+        if (matched) {
+            surfaceDeltaTokens += hiddenCurrent - hiddenAnchor;
+            if (base.baseline.kind === 'usage') {
+                const estimatedAnchor = estimateToolsTokens(header)
+                    + base.surfaceTokens - base.surfaceDeltaTokens + hiddenAnchor;
+                if (base.baseline.tokens < estimatedAnchor) {
+                    baseline = Object.freeze({ kind: 'estimated', tokens: estimatedAnchor });
+                }
+            }
+            else if (base.baseline.kind === 'estimated') {
+                baseline = Object.freeze({ kind: 'estimated', tokens: base.baseline.tokens + hiddenAnchor });
+            }
+        }
+        else if (base.baseline.kind === 'estimated') {
+            baseline = Object.freeze({ kind: 'estimated', tokens: base.baseline.tokens + hiddenCurrent });
+        }
+        const nodes = Object.freeze(base.nodes.map(node => Object.freeze({
+            ...node, tokens: node.tokens + (current.get(node.seq) ?? 0),
+        })));
+        return Object.freeze({
+            ...base,
+            baseline,
+            surfaceDeltaTokens,
+            totalTokens: Math.max(0, baseline.tokens + surfaceDeltaTokens),
+            surfaceTokens: base.surfaceTokens + hiddenCurrent,
+            nodes,
+        });
+    }
+    /** Track only replay metadata and surface positions; the host validates each event first. */
+    syncHidden(session, revision) {
+        let state = this.hiddenFolds.get(session);
+        if (state === undefined) {
+            state = { consumed: 0, header: undefined, nodes: [], anchor: undefined };
+            this.hiddenFolds.set(session, state);
+        }
+        while (state.consumed < revision) {
+            const event = session.eventAt(SessionSeq(state.consumed));
+            if (event === undefined)
+                throw new Error('Codex token meter: missing consumed session event');
+            this.foldHidden(state, event);
+            state.consumed++;
+        }
+        return state;
+    }
+    foldHidden(state, event) {
+        const header = event.type === 'request/header' ? canonicalHeader(event.data.header) : state.header;
+        const node = isSurfaceEvent(event) ? {
+            seq: event.seq,
+            replay: replayPrice(deriveEventMessage(event), event.type === 'assistant/message' ? event.data.usage : undefined),
+        } : undefined;
+        let anchor = state.anchor;
+        if (event.type === 'assistant/message') {
+            const route = header?.config;
+            const original = event.data.usage !== undefined && route !== undefined
+                ? { source: {
+                        provider: route.provider,
+                        model: route.model,
+                        replayState: assembleAssistantStream(event.data.stream).replayState,
+                    }, usage: event.data.usage }
+                : node?.replay;
+            anchor = { header, nodes: state.nodes.slice(), assistant: original };
+        }
+        if (node !== undefined && isSurfaceEvent(event)) {
+            if (event.surfaceOp === 'append') {
+                state.nodes.push(node);
+            }
+            else {
+                const { startSeq, endSeq } = event.surfaceOp;
+                const first = state.nodes.findIndex(item => item.seq === startSeq);
+                const last = state.nodes.findIndex(item => item.seq === endSeq);
+                if (first < 0 || last < first)
+                    throw new Error('Codex token meter: invalid surface replacement');
+                state.nodes.splice(first, last - first + 1, node);
+            }
+        }
+        state.header = header;
+        state.anchor = anchor;
+    }
+}
+export default CodexTokenMeter;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pure01fx/dsh-openai-codex-auth",
-  "version": "0.13.2",
+  "version": "0.13.4",
   "description": "Native ChatGPT Codex provider, device-code-first login, and same-origin Web integration for DeepSeek Harness",
   "license": "MIT",
   "publishConfig": {
@@ -27,6 +27,10 @@
       "types": "./lib/index.d.ts",
       "default": "./lib/index.js"
     },
+    "./token-meter": {
+      "types": "./lib/token-meter.d.ts",
+      "default": "./lib/token-meter.js"
+    },
     "./client": "./client.js",
     "./locale/*.json": "./locale/*.json",
     "./package.json": "./package.json"
@@ -55,6 +59,10 @@
     "lib/responses.d.ts",
     "lib/replay.js",
     "lib/replay.d.ts",
+    "lib/token-meter.js",
+    "lib/token-meter.d.ts",
+    "lib/pressure-projection.js",
+    "lib/pressure-projection.d.ts",
     "lib/retry-after.js",
     "lib/retry-after.d.ts",
     "lib/rate-limits.js",
@@ -116,12 +124,15 @@
     }
   },
   "peerDependencies": {
+    "@deepseek-ai/dsh-session": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-session-projection": "0.2.0-rc.2",
     "@deepseek-ai/cordis": "~4.0.4",
     "@deepseek-ai/dsh-attachment": "0.2.0-rc.2",
     "@deepseek-ai/dsh-credentials": "0.2.0-rc.2",
     "@deepseek-ai/dsh-fs": "0.2.0-rc.2",
     "@deepseek-ai/dsh-host-webserver": "0.2.0-rc.2",
     "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-token-meter": "0.2.0-rc.2",
     "@deepseek-ai/dsh-sandbox": "0.2.0-rc.2",
     "@deepseek-ai/dsh-sandbox-policy": "0.2.0-rc.2",
     "@deepseek-ai/dsh-shell": "0.2.0-rc.2",
@@ -134,11 +145,18 @@
     "https-proxy-agent": "7.0.6",
     "image-size": "^2.0.2",
     "proxy-from-env": "1.1.0",
-    "ws": "8.21.3"
+    "ws": "8.21.3",
+    "zod": "^4.4.3"
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "~4.0.4",
+    "@deepseek-ai/cordis-plugin-loader": "1.0.5",
+    "@deepseek-ai/cordis-plugin-include": "1.0.9",
+    "js-yaml": "^4.1.0",
+    "@types/js-yaml": "^4.0.9",
     "@deepseek-ai/dsh-agent": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-compaction-basic": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-session-projection": "0.2.0-rc.2",
     "@deepseek-ai/dsh-attachment": "0.2.0-rc.2",
     "@deepseek-ai/dsh-attachment-local": "0.2.0-rc.2",
     "@deepseek-ai/dsh-client-store": "0.2.0-rc.2",
@@ -147,6 +165,7 @@
     "@deepseek-ai/dsh-fs": "0.2.0-rc.2",
     "@deepseek-ai/dsh-host-webserver": "0.2.0-rc.2",
     "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-token-meter": "0.2.0-rc.2",
     "@deepseek-ai/dsh-sandbox": "0.2.0-rc.2",
     "@deepseek-ai/dsh-sandbox-policy": "0.2.0-rc.2",
     "@deepseek-ai/dsh-scope": "0.2.0-rc.2",