@pikiloom/kernel 0.1.3 → 0.1.4

package/dist/drivers/claude.d.ts

@@ -1,5 +1,5 @@
 import type { AgentDriver, AgentTurnInput, DriverContext, DriverResult, DriverEvent, TuiInput, TuiSpec } from '../contracts/driver.js';
-import type { UniversalPlan } from '../protocol/index.js';
+import type { UniversalUsage, UniversalPlan } from '../protocol/index.js';
 export declare class ClaudeDriver implements AgentDriver {
     private readonly bin;
     readonly id = "claude";
@@ -14,6 +14,17 @@ export declare class ClaudeDriver implements AgentDriver {
     run(input: AgentTurnInput, ctx: DriverContext): Promise<DriverResult>;
     private usage;
 }
+export interface ClaudeUsageState {
+    input: number | null;
+    output: number | null;
+    cached: number | null;
+    cacheCreation?: number | null;
+    contextWindow?: number | null;
+    turnOutputTokensBase?: number | null;
+}
+export declare function claudeUsageOf(s: ClaudeUsageState): UniversalUsage;
+export declare function claudeContextWindowFromModel(model: unknown): number | null;
+export declare function claudeEffectiveContextWindow(advertised: number | null): number | null;
 export declare function handleClaudeEvent(ev: any, s: any, emit: (e: DriverEvent) => void): void;
 export declare function claudeUserMessage(text: string): string;
 export declare function emitClaudeImages(blocks: any[], s: any, emit: (e: DriverEvent) => void): void;

package/dist/drivers/claude.js

@@ -46,6 +46,8 @@ export class ClaudeDriver {
             sessionId: null, model: null,
             stopReason: null, error: null,
             input: null, output: null, cached: null,
+            cacheCreation: null,
+            contextWindow: null, turnOutputTokensBase: 0,
             subAgents: new Map(),
             tools: new Map(),
         };
@@ -141,9 +143,45 @@ export class ClaudeDriver {
         });
     }
     usage(s) {
-        return { inputTokens: s.input, outputTokens: s.output, cachedInputTokens: s.cached, contextPercent: null };
+        return claudeUsageOf(s);
     }
 }
+export function claudeUsageOf(s) {
+    const used = (s.input ?? 0) + (s.cached ?? 0) + (s.cacheCreation ?? 0) + (s.output ?? 0);
+    const window = s.contextWindow ?? null;
+    const contextPercent = window && used > 0 ? Math.min(99.9, Math.round((used / window) * 1000) / 10) : null;
+    const turnOutput = (s.turnOutputTokensBase ?? 0) + (s.output ?? 0);
+    return {
+        inputTokens: s.input,
+        outputTokens: s.output,
+        cachedInputTokens: s.cached,
+        contextUsedTokens: used > 0 ? used : null,
+        contextPercent,
+        turnOutputTokens: turnOutput > 0 ? turnOutput : null,
+    };
+}
+// Advertised context window by Claude model id (best-effort; unknown -> null so the
+// percent simply stays absent rather than wrong). Anchor-free so vendor-prefixed ids
+// (us.anthropic.claude-…) still match.
+export function claudeContextWindowFromModel(model) {
+    const id = String(model ?? '').trim().toLowerCase();
+    if (!id)
+        return null;
+    if (id === 'haiku' || /claude-haiku-/.test(id))
+        return 200_000;
+    if (id === 'opus' || id === 'sonnet' || id === 'fable')
+        return 1_000_000;
+    if (/claude-(opus|sonnet)-/.test(id) || /claude-fable-/.test(id))
+        return 1_000_000;
+    return null;
+}
+// Usable window = advertised minus Claude's max-output (20k) + autocompact (13k) reserve.
+const CLAUDE_USABLE_WINDOW_RESERVE = 33_000;
+export function claudeEffectiveContextWindow(advertised) {
+    if (advertised == null)
+        return null;
+    return advertised <= CLAUDE_USABLE_WINDOW_RESERVE ? advertised : advertised - CLAUDE_USABLE_WINDOW_RESERVE;
+}
 // Parse one claude stream-json event into kernel DriverEvents (pure + exported for
 // hermetic testing). Faithful to pikiloom's claudeParse shapes.
 export function handleClaudeEvent(ev, s, emit) {
@@ -178,16 +216,21 @@ export function handleClaudeEvent(ev, s, emit) {
             emit({ type: 'session', sessionId: ev.session_id });
         }
         s.model = ev.model ?? s.model;
+        s.contextWindow = claudeEffectiveContextWindow(claudeContextWindowFromModel(s.model)) ?? s.contextWindow;
         return;
     }
     if (t === 'stream_event') {
         const inner = ev.event || {};
         if (inner.type === 'message_start') {
             const u = inner.message?.usage;
-            if (u) {
-                s.input = u.input_tokens ?? s.input;
-                s.cached = u.cache_read_input_tokens ?? s.cached;
-            }
+            // Claude emits one message per tool-use round within a single turn. Carry the prior
+            // message's output into the per-turn base, then reset to the new message's prompt size
+            // so contextUsedTokens tracks current occupancy while turnOutputTokens sums the turn.
+            s.turnOutputTokensBase = (s.turnOutputTokensBase ?? 0) + (s.output ?? 0);
+            s.input = u?.input_tokens ?? 0;
+            s.cached = u?.cache_read_input_tokens ?? 0;
+            s.cacheCreation = u?.cache_creation_input_tokens ?? 0;
+            s.output = 0;
         }
         else if (inner.type === 'content_block_delta') {
             const d = inner.delta || {};
@@ -211,7 +254,9 @@ export function handleClaudeEvent(ev, s, emit) {
                     s.input = u.input_tokens;
                 if (u.cache_read_input_tokens != null)
                     s.cached = u.cache_read_input_tokens;
-                emit({ type: 'usage', usage: { inputTokens: s.input, outputTokens: s.output, cachedInputTokens: s.cached, contextPercent: null } });
+                if (u.cache_creation_input_tokens != null)
+                    s.cacheCreation = u.cache_creation_input_tokens;
+                emit({ type: 'usage', usage: claudeUsageOf(s) });
             }
             if (inner.delta?.stop_reason)
                 s.stopReason = inner.delta.stop_reason;
@@ -312,6 +357,8 @@ export function handleClaudeEvent(ev, s, emit) {
             const cached = u.cache_read_input_tokens ?? u.cached_input_tokens;
             if (s.cached == null && cached != null)
                 s.cached = cached;
+            if (s.cacheCreation == null && u.cache_creation_input_tokens != null)
+                s.cacheCreation = u.cache_creation_input_tokens;
         }
         return;
     }

package/dist/drivers/codex.d.ts

@@ -1,4 +1,5 @@
 import type { AgentDriver, AgentTurnInput, DriverContext, DriverResult, TuiInput, TuiSpec } from '../contracts/driver.js';
+import type { UniversalUsage } from '../protocol/index.js';
 export declare class CodexDriver implements AgentDriver {
     private readonly bin;
     readonly id = "codex";
@@ -12,3 +13,12 @@ export declare class CodexDriver implements AgentDriver {
     run(input: AgentTurnInput, ctx: DriverContext): Promise<DriverResult>;
     tui(input: TuiInput): TuiSpec;
 }
+export interface CodexUsageState {
+    input: number | null;
+    output: number | null;
+    cached: number | null;
+    contextUsed?: number | null;
+    contextWindow?: number | null;
+}
+export declare function applyCodexTokenUsage(s: CodexUsageState, rawUsage: any): void;
+export declare function codexUsageOf(s: CodexUsageState): UniversalUsage;

package/dist/drivers/codex.js

@@ -173,7 +173,7 @@ export class CodexDriver {
         // to the native account.
         const config = [...(input.configOverrides || [])];
         const srv = new AppServer(this.bin, config, input.env);
-        const state = { text: '', reasoning: '', sessionId: input.sessionId ?? null, input: null, output: null, cached: null, status: null, error: null, turnId: null };
+        const state = { text: '', reasoning: '', sessionId: input.sessionId ?? null, input: null, output: null, cached: null, contextUsed: null, contextWindow: null, status: null, error: null, turnId: null };
         const phases = new Map();
         const toolSummaries = new Map();
         let steerRegistered = false;
@@ -264,14 +264,8 @@ export class CodexDriver {
                         break;
                     }
                     case 'thread/tokenUsage/updated': {
-                        const u = params?.tokenUsage || params?.usage || {};
-                        if (u.input_tokens != null || u.inputTokens != null)
-                            state.input = u.input_tokens ?? u.inputTokens;
-                        if (u.output_tokens != null || u.outputTokens != null)
-                            state.output = u.output_tokens ?? u.outputTokens;
-                        if (u.cached_input_tokens != null || u.cachedInputTokens != null)
-                            state.cached = u.cached_input_tokens ?? u.cachedInputTokens;
-                        ctx.emit({ type: 'usage', usage: { inputTokens: state.input, outputTokens: state.output, cachedInputTokens: state.cached, contextPercent: null } });
+                        applyCodexTokenUsage(state, params?.tokenUsage || params?.usage);
+                        ctx.emit({ type: 'usage', usage: codexUsageOf(state) });
                         break;
                     }
                     case 'turn/completed': {
@@ -279,6 +273,8 @@ export class CodexDriver {
                         state.status = turn.status ?? 'completed';
                         if (turn.error)
                             state.error = turn.error.message || turn.error.code || 'turn error';
+                        applyCodexTokenUsage(state, params?.tokenUsage || turn.tokenUsage || turn.usage);
+                        ctx.emit({ type: 'usage', usage: codexUsageOf(state) });
                         settle();
                         break;
                     }
@@ -309,7 +305,7 @@ export class CodexDriver {
             if (turnResp.error)
                 return { ok: false, text: state.text, error: turnResp.error.message || 'turn/start failed', stopReason: 'error', sessionId: state.sessionId };
             await turnDone;
-            const usage = { inputTokens: state.input, outputTokens: state.output, cachedInputTokens: state.cached, contextPercent: null };
+            const usage = codexUsageOf(state);
             const ok2 = (state.status === 'completed' || state.status == null) && !state.error && !ctx.signal.aborted;
             return {
                 ok: ok2,
@@ -344,3 +340,76 @@ function buildTurnInput(prompt, attachments) {
     input.push({ type: 'text', text: prompt });
     return input;
 }
+function codexNum(...vals) {
+    for (const v of vals) {
+        const n = typeof v === 'number' ? v : Number(v);
+        if (Number.isFinite(n))
+            return n;
+    }
+    return null;
+}
+// Context occupancy from one usage record: prefer total_tokens, else input(+output).
+function codexContextUsed(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const total = codexNum(raw.total_tokens, raw.totalTokens);
+    if (total != null && total >= 0)
+        return total;
+    const i = codexNum(raw.input_tokens, raw.inputTokens);
+    const o = codexNum(raw.output_tokens, raw.outputTokens);
+    if (i != null && o != null)
+        return i + o;
+    return i;
+}
+// Fold a codex tokenUsage payload into driver state: last-turn counts, context
+// occupancy, and the model window. Tolerant of nested {info:{…}} and flat shapes.
+export function applyCodexTokenUsage(s, rawUsage) {
+    if (!rawUsage || typeof rawUsage !== 'object')
+        return;
+    const info = rawUsage.info && typeof rawUsage.info === 'object' ? rawUsage.info : rawUsage;
+    const last = info.last ?? info.lastTokenUsage ?? info.last_token_usage ?? rawUsage.last;
+    const li = codexNum(last?.input_tokens, last?.inputTokens);
+    const lo = codexNum(last?.output_tokens, last?.outputTokens);
+    const lc = codexNum(last?.cached_input_tokens, last?.cachedInputTokens);
+    if (li != null)
+        s.input = li;
+    if (lo != null)
+        s.output = lo;
+    if (lc != null)
+        s.cached = lc;
+    const used = codexContextUsed(last);
+    if (used != null)
+        s.contextUsed = used;
+    // Cumulative total as fallback for the per-turn counts (the trailing `?? rawUsage`
+    // also catches the flat shape, where there is no nested `last`).
+    const total = info.total ?? info.totalTokenUsage ?? info.total_token_usage ?? rawUsage.total ?? rawUsage;
+    if (total && typeof total === 'object') {
+        const ti = codexNum(total.input_tokens, total.inputTokens);
+        const to = codexNum(total.output_tokens, total.outputTokens);
+        const tc = codexNum(total.cached_input_tokens, total.cachedInputTokens);
+        if (li == null && ti != null)
+            s.input = ti;
+        if (lo == null && to != null)
+            s.output = to;
+        if (lc == null && tc != null)
+            s.cached = tc;
+    }
+    const cw = codexNum(info.modelContextWindow, info.model_context_window, rawUsage.modelContextWindow, rawUsage.model_context_window);
+    if (cw != null && cw > 0)
+        s.contextWindow = cw;
+}
+export function codexUsageOf(s) {
+    const fallback = (s.input ?? 0) + (s.cached ?? 0);
+    const used = s.contextUsed ?? (fallback > 0 ? fallback : null);
+    const window = s.contextWindow ?? null;
+    const contextPercent = used != null && window ? Math.min(99.9, Math.round((used / window) * 1000) / 10) : null;
+    const turnOutput = s.output ?? 0;
+    return {
+        inputTokens: s.input,
+        outputTokens: s.output,
+        cachedInputTokens: s.cached,
+        contextUsedTokens: used,
+        contextPercent,
+        turnOutputTokens: turnOutput > 0 ? turnOutput : null,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikiloom/kernel",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Heterogeneous coding agents (Claude / Codex / Gemini / ACP) -> an interaction-friendly, accumulating session snapshot + control handle, over pluggable surfaces (IM, Web, tunnel, TUI). The reusable core pikiloom itself is built on.",
   "type": "module",
   "license": "MIT",