billion-context-omp 0.2.6 → 0.2.8

package/dist/messages.d.ts

@@ -20,7 +20,26 @@ export interface StreamCompressCall {
     }[];
 }
 export declare function findCompressCalls(message: AgentMessage): StreamCompressCall[];
+/** Extract a compress tool's arguments from a stream toolCall. Two call
+ *  shapes exist: (1) top-level — our tools are registered with
+ *  loadMode:"essential" so omp's tools.xdev does NOT mount them as xd://
+ *  devices; the stream shows name:"compress" directly. (2) legacy xd:// —
+ *  sessions recorded before that change (or hosts with tools.xdev forcing
+ *  discoverable mounting) invoked compress through the write tool with path
+ *  "xd://compress" and the tool args JSON-encoded in the content field. Both
+ *  shapes must replay from the stream. Returns normalized compress args
+ *  (content array
+ *  plus optional topic / summaryMaxChars from wherever they live). */
+export declare function compressToolArgs(call: {
+    name: string;
+    arguments?: unknown;
+}): {
+    content: unknown[];
+    topic?: unknown;
+    summaryMaxChars?: unknown;
+} | null;
 export declare function extractText(content: unknown, stripTags?: boolean): string;
+export declare function stripRefTag(text: string): string;
 export declare function messageIdentity(message: unknown): string;
 export declare function matchesStoredText(stored: string, visible: string): boolean;
 export declare function coreOutToAgentMessages(coreOut: CoreMessage[], originalById: Map<string, AgentMessage>): AgentMessage[];

package/dist/runtime.d.ts

@@ -1,6 +1,7 @@
 import type { ExtensionContext } from "@oh-my-pi/pi-coding-agent";
 import { type CompressionCore, type CompressionState, type Config, type CoreMessage, type Prompts } from "acp-kernel";
 import { type AdapterConfig } from "./config.js";
+import type { BiliMessage } from "acp-kernel/wire";
 import { type AgentMessage } from "./messages.js";
 export interface FoldResult {
     state: CompressionState;
@@ -8,6 +9,13 @@ export interface FoldResult {
     originalById: Map<string, AgentMessage>;
     streamLen: number;
 }
+/** Core-space fold result (provider mode): no originalById — the output
+ *  rebuilds straight onto the wire via the kernel codecs. */
+export interface CoreFoldResult {
+    state: CompressionState;
+    coreMessages: BiliMessage[];
+    streamLen: number;
+}
 export interface AcpRuntime {
     core: CompressionCore;
     adapter: AdapterConfig;
@@ -17,10 +25,17 @@ export interface AcpRuntime {
     liveContextLimit(ctx: ExtensionContext): number;
     configFor(ctx: ExtensionContext): Config;
     foldStream(ctx: ExtensionContext, stream: AgentMessage[]): FoldResult;
+    /** Core-space fold (provider mode): the wire payload already parsed to
+   *  BiliMessage[] by the kernel codec; same incremental LCP + replay
+   *  semantics as foldStream, content-hash id space (wire-fold.ts). */
+    foldStreamCore(ctx: ExtensionContext, stream: BiliMessage[]): CoreFoldResult;
     stateFor(ctx: ExtensionContext): Promise<{
         state: CompressionState;
         coreMessages: CoreMessage[];
     }>;
+    /** Commit the folded state to the slot space the session's CURRENT mode
+     *  folds in (provider -> core slot, context -> context slot) — the mirror
+     *  of stateFor: a commit must land where the next read goes (issue #90). */
     commitFoldState(ctx: ExtensionContext, state: CompressionState, toolCallId?: string): void;
     /** Record the identity sequence of the last rebuilt output so the next
      *  foldStream can recognize omp re-feeding it (issue #52). */
@@ -32,7 +47,7 @@ export interface AcpRuntime {
     forgetSession(sid: string): void;
     /** Rebuild blocks from the persisted session at session_start so /acp and
      *  acp_status show them BEFORE the first LLM call of a resumed session.
-     *  Provider mode folds the WIRE projection (viewToWireStream mirror — the
+     *  Provider mode folds the WIRE projection (wire-fold.ts mirrors — the
      *  authoritative fold runs on the wire-synthesized stream, which differs
      *  from the raw session view; issue #64). The slot is marked preview and
      *  always re-folded authoritatively at the first live event (the live

package/dist/transform-mode.d.ts

@@ -0,0 +1,5 @@
+import type { AdapterConfig } from "./config.js";
+export declare function hostVersionAtLeast(min: readonly [number, number, number], version?: string): boolean;
+export declare function resolveTransformMode(adapter: Pick<AdapterConfig, "transformMode">, model: {
+    api?: string;
+} | undefined, hostVersion?: string): "context" | "provider";

package/dist/wire-fold.d.ts

@@ -0,0 +1,140 @@
+import { type BiliMessage } from "acp-kernel/wire";
+import { type CompressionState, type Config, type CoreMessage } from "acp-kernel";
+import type { AgentMessage, BlockLike, StreamCompressCall } from "./messages.js";
+export type ProviderWireFormat = "anthropic" | "openai";
+/** Kernel format detection narrowed to the formats the omp pipeline can
+ *  rebuild onto the wire. null = fail-open (pass the payload through). */
+export declare function detectProviderWireFormat(payload: unknown): ProviderWireFormat | null;
+export declare function payloadToCore(payload: unknown, fmt: ProviderWireFormat): {
+    msgs: BiliMessage[];
+    cacheControls?: Map<string, unknown>;
+};
+export declare function coreToPayloadMessages(msgs: BiliMessage[], fmt: ProviderWireFormat, cacheControls?: Map<string, unknown>): unknown[];
+export type Representability = {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+/** Whether the payloadToCore → coreToPayloadMessages round-trip can rebuild
+ *  this payload WITHOUT content loss. The sets above mirror the kernel
+ *  codec switches; everything they do not parse is dropped or flattened on
+ *  the rebuild. Unrepresentable payloads must fail the transform OPEN —
+ *  pass through untouched rather than lose content (issue #3 review). */
+export declare function payloadRepresentable(payload: unknown, fmt: ProviderWireFormat): Representability;
+export type WireTagRenderScope = {
+    config: Config;
+    tokenCount: number;
+};
+/** omp's wire tag contract (issue #66) on top of the kernel's "text-only"
+ *  render: the proxy keeps tool content pristine, but omp's nudge ranges
+ *  target tool results — the model must be able to cite them by ref, so tag
+ *  the tool-result pieces (kernel renderer, format single-sourced). The
+ *  kernel's "text-only" also tags assistant text — strip it: the model
+ *  echoes tags it sees on its own responses (the contract patchRefTag
+ *  enforced in the AgentMessage bridge). Tool-call args stay clean (replay
+ *  JSON-parses them).
+ *
+ *  Rendering goes through the kernel's render-refs NODE so token counts in
+ *  the tags come from the fold state's tokenSnapshot (written once per ref,
+ *  reused forever) instead of being recomputed per call; the updated
+ *  snapshot is written back into the fold state in place. Tool names are
+ *  re-attached from the call pieces first — the codecs drop them on
+ *  tool-result pieces and classifyType would render type="tool" where the
+ *  context path (and the system-prompt contract) shows the real name. */
+export declare function applyWireTagContract(msgs: BiliMessage[], state: CompressionState, scope: WireTagRenderScope): BiliMessage[];
+/** Stable cross-turn identity for the core-space LCP fold. The text carries
+ *  our own <acp> ref tags from the previous turn's output (the model sees
+ *  them and they ride back in the next request) — stripped before hashing
+ *  so re-folds of an unmutated prefix stay incremental. */
+export declare function coreIdentity(msg: BiliMessage): string;
+/** toolCallId → toolName from the stream's tool-call pieces. The kernel
+ *  codecs do not carry tool names on tool-result pieces, so protection
+ *  checks (compress results stay ref-BLOCKED) resolve the name here. */
+export declare function toolCallNames(msgs: BiliMessage[]): Map<string, string>;
+export declare function toolResultTextsCore(msgs: BiliMessage[]): Map<string, string>;
+/** Compress calls carried by a core tool-call piece. Same two shapes as the
+ *  AgentMessage stream (direct compress; legacy xd://compress via write),
+ *  with the arguments JSON-encoded in the piece's text. */
+export declare function findCompressCallsCore(msg: BiliMessage): StreamCompressCall[];
+/** Span fingerprint in content-hash space: hash the content keys of the
+ *  exact first/last covered pieces. Boundary ids are pre-resolved (byRef /
+ *  block lookup) — unlike the pN-space spanFingerprint there is no
+ *  position parsing, ids are unique per piece. */
+export declare function spanFingerprintCore(coreMessages: CoreMessage[], startId: string, endId: string): string;
+/** Index-based span fingerprint (issue #91 replay fallback): hash the content
+ *  keys of the pieces AT the given stream positions. The stored fp still
+ *  decides keep/drop — the position is only a recovery hint for a drifted
+ *  boundary whose content-hash id no longer matches, so a benign tail drift
+ *  (first-4096 intact) is kept while a real rewrite mismatches. */
+export declare function spanFingerprintCoreIdx(coreMessages: CoreMessage[], startIdx: number, endIdx: number): string;
+/** Resolve a range boundary to the exact id of the piece it names, in
+ *  content-hash space. Message refs go through byRef; block refs resolve to
+ *  the earliest (min) or latest (max) covered piece by STREAM ORDER
+ *  (index in coreMessages — the hash ids carry no position). */
+export declare function boundaryRawCore(ref: string, byRef: Record<string, string>, blocks: BlockLike[], coreMessages: CoreMessage[], pick: "min" | "max"): string;
+/** Resolve a range boundary to its STREAM INDEX in content-hash space. byRef /
+ *  block lookup first (the exact piece it names, by array order); on a missed
+ *  id (a drift re-hashed the piece so its carried ref dangles) fall back to
+ *  the compress-time recorded index — the position hint, issue #91. -1 =
+ *  unresolvable. */
+export declare function boundaryIndexCore(ref: string, byRef: Record<string, string>, blocks: BlockLike[], coreMessages: CoreMessage[], pick: "min" | "max", fallbackIdx?: number): number;
+/** Structured replay-guard verdict (issue #91, rework): the position
+ *  fallback recovers the STREAM INDEX of a drifted boundary, but the kernel
+ *  resolves ranges by REF — so when a recorded m-ref dangles, the replay
+ *  must re-apply that boundary under the CURRENT ref of the recovered piece.
+ *  `remap` carries exactly that (only dangling m-refs are remapped; block
+ *  refs resolve themselves inside the kernel and are never touched). */
+export type ReplayRangeVerdict = {
+    /** Stale: the range must be dropped (master semantics, unchanged). */
+    reject?: string;
+    /** Dangling m-refs recovered by position, remapped to current refs. */
+    remap?: {
+        startRef?: string;
+        endRef?: string;
+    };
+    /** True when the result text carried a [pos=] pair for this range —
+     *  with `reject` set it marks a RECOVERY FAILURE (always logged). */
+    hint?: boolean;
+    /** Diagnostics — always logged when a recovery happens. */
+    recovered?: {
+        pos: string;
+        startIdx: number;
+        endIdx: number;
+    };
+};
+/** Current m-ref of the piece at stream index idx (inverse byRef scan).
+ *  "" when the piece has no ref (protected) — the replay must fail closed
+ *  rather than hand the kernel a ref it does not know. Replay-time only
+ *  (replayed compress calls), so the O(refs) scan stays off the hot path. */
+export declare function refOfPieceCore(coreMessages: BiliMessage[], idx: number, byRef: Record<string, string>): string;
+export declare function staleRangeCore(r: {
+    startRef: string;
+    endRef: string;
+}, rangeIndex: number, resultText: string, coreMessages: BiliMessage[], callIndex: number, byRef: Record<string, string>, blocks: BlockLike[]): ReplayRangeVerdict;
+/** One fingerprint per range for the replay guard, content-hash space
+ *  (mirrors rangeFingerprints for the pN space). */
+export declare function rangeFingerprintsCore(ranges: Array<{
+    startRef: string;
+    endRef: string;
+}>, coreMessages: BiliMessage[], byRef: Record<string, string>, blocks: BlockLike[]): string[];
+/** One boundary-index pair per range for the replay fallback (issue #91),
+ *  aligned with rangeFingerprintsCore: the stream index of each range's exact
+ *  first/last covered piece at record time ("-1" pair when a boundary can't
+ *  be positioned), so the replay can recover a drifted boundary by position. */
+export declare function rangePositionsCore(ranges: Array<{
+    startRef: string;
+    endRef: string;
+}>, coreMessages: CoreMessage[], byRef: Record<string, string>, blocks: BlockLike[]): string[];
+/** Rebuild the WIRE-SHAPE projection of the persisted session (the mirror
+ *  of the host's convertToLlm for openai chat) and parse it with the kernel
+ *  codec, so primeFold (provider mode) folds exactly the space the live
+ *  provider requests fold: system prompt first (it takes m00001), one
+ *  tool-result piece per tool result, thinking dropped (issue #64). */
+export declare function viewToCoreStream(view: AgentMessage[], systemText: string): BiliMessage[];
+/** Anthropic-flavoured wire mirror for primeFold: the live anthropic
+ *  request carries the system prompt as the TOP-LEVEL `system` field (out
+ *  of the fold space) and folds tool results into user messages — mirror
+ *  exactly that, or the preview lands in a different ref space than the
+ *  live request (issue #64). */
+export declare function viewToAnthropicCore(view: AgentMessage[]): BiliMessage[];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "billion-context-omp",
-	"version": "0.2.6",
+	"version": "0.2.8",
 	"description": "One billion, not one million. Model-driven context management for the oh-my-pi (omp) coding agent.",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -62,13 +62,13 @@
 		"@oh-my-pi/omptype": ">=17.0.0"
 	},
 	"devDependencies": {
-		"@oh-my-pi/omptype": "17.3.2",
-		"@oh-my-pi/pi-agent-core": "17.3.2",
-		"@oh-my-pi/pi-ai": "17.3.2",
-		"@oh-my-pi/pi-coding-agent": "17.3.2",
-		"@oh-my-pi/pi-utils": "17.3.2",
+		"@oh-my-pi/omptype": "17.3.8",
+		"@oh-my-pi/pi-agent-core": "17.3.8",
+		"@oh-my-pi/pi-ai": "17.3.8",
+		"@oh-my-pi/pi-coding-agent": "17.3.8",
+		"@oh-my-pi/pi-utils": "17.3.8",
 		"@types/node": "^26.1.2",
-		"acp-kernel": "0.0.25",
+		"acp-kernel": "0.0.28",
 		"billion-context-kit": "0.2.0",
 		"bun-types": "^1.3.14",
 		"tsup": "^8.5.1",

package/dist/wire-transform.d.ts

@@ -1,71 +0,0 @@
-import type { AgentMessage } from "./messages.js";
-import type { AnthropicRequestBody } from "acp-kernel/wire";
-export type WireFormat = "anthropic" | "openai" | "unknown";
-interface AnthropicBlock {
-    type?: string;
-    text?: string;
-    id?: string;
-    name?: string;
-    input?: unknown;
-    tool_use_id?: string;
-    content?: unknown;
-    is_error?: boolean;
-    cache_control?: unknown;
-    [k: string]: unknown;
-}
-interface AnthropicWireMessage {
-    role: string;
-    content: string | AnthropicBlock[];
-    [k: string]: unknown;
-}
-interface OpenAIWireMessage {
-    role: string;
-    content?: unknown;
-    tool_calls?: Array<{
-        id: string;
-        function?: {
-            name?: string;
-            arguments?: string;
-        };
-    }>;
-    tool_call_id?: string;
-    [k: string]: unknown;
-}
-export interface SynthesisResult {
-    stream: AgentMessage[];
-    back: Array<{
-        wi: number;
-        kind: "text" | "toolCall" | "toolResult";
-    }>;
-    format: WireFormat;
-}
-export declare function detectWireFormat(payload: unknown): WireFormat;
-export declare function synthesizeStream(payload: unknown, format: WireFormat): SynthesisResult;
-/** Rebuild the wire payload from the transformed stream. Survivors reuse the
- *  ORIGINAL wire message objects (patched text only) so every field we do not
- *  understand — cache_control, citations, provider extras — passes through
- *  byte-identical. Only synthesized messages (nudge) are built from scratch.
- *  Returns the ORIGINAL payload object when nothing changed (cache-safe). */
-export declare function rebuildWirePayload(rebuilt: AgentMessage[], payload: unknown, synth: SynthesisResult): unknown;
-/** Rebuild the WIRE-SHAPE view of the persisted session (the mirror of the
- *  host's convertToLlm) and run it through the SAME synthesizeStream the
- *  live provider fold uses, so primeFold (provider mode) folds exactly the
- *  authoritative projection. The raw session view is NOT equivalent: for
- *  openai-style payloads the system prompt is a message in the wire body —
- *  it becomes the first core piece and takes m00001 — and the openai
- *  synthesis cannot recover tool names for `role:"tool"` entries (a
- *  compress result gets toolName "" instead of "compress", so it is not
- *  ref-BLOCKED there). Folding the raw view puts the fold in a different
- *  ref/fingerprint space: stored span fingerprints mismatch, the guard
- *  rejects every in-stream replay, and a resumed session shows
- *  "Blocks: none" until the first provider request (issue #64).
- *
- *  Message shapes mirror the captured live payload (openai chat):
- *  system first; assistant text and/or tool_calls (content "" when only
- *  calls); one `role:"tool"` message per tool result; thinking dropped
- *  (the host does not carry it in this format). */
-export declare function viewToWireStream(view: AgentMessage[], systemText: string): AgentMessage[];
-/** True when the payload carries no messages we could fold (e.g. an empty
- *  tools-only probe). The caller bypasses instead of transforming. */
-export declare function synthesisIsEmpty(synth: SynthesisResult): boolean;
-export type { AnthropicRequestBody, OpenAIWireMessage, AnthropicWireMessage };