pi-reasoning-zip 0.2.1 → 0.2.5

package/CHANGELOG.md

@@ -7,6 +7,39 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.5] - 2026-07-03
+
+### Fixed
+
+- Skip Pi `thinkingSignature` and redacted thinking blocks instead of rewriting opaque provider metadata.
+- Enforce `thresholds.targetRatio` when accepting compacted thinking output.
+
+## [0.2.4] - 2026-07-03
+
+### Fixed
+
+- Prompt injection now targets real Pi `before_provider_request` events using `ctx.model.provider`.
+
+## [0.2.3] - 2026-07-03
+
+### Added
+
+- Added strict-endpoint fallback retry for compactor requests that reject `chat_template_kwargs`.
+
+## [0.2.2] - 2026-07-03
+
+### Changed
+
+- Replaced broad extension hook `any` casts with narrow local structural hook types.
+
+### Added
+
+- Added real compactor timeout abort test.
+
+### Fixed
+
+- Disabled compactor-side Qwen/llama.cpp thinking via `chat_template_kwargs.enable_thinking=false` so compact traces are returned in `message.content`.
+
 ## [0.2.1] - 2026-07-02
 
 ### Changed
@@ -45,7 +78,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Added package motto to README.
 - Added npm release metadata: description, keywords, repository links, exports, and Node engine.
 
-[Unreleased]: https://github.com/Ryu-CZ/pi-reasoning-zip/compare/v0.2.1...HEAD
+[Unreleased]: https://github.com/Ryu-CZ/pi-reasoning-zip/compare/v0.2.5...HEAD
+[0.2.5]: https://github.com/Ryu-CZ/pi-reasoning-zip/compare/v0.2.4...v0.2.5
+[0.2.4]: https://github.com/Ryu-CZ/pi-reasoning-zip/compare/v0.2.3...v0.2.4
+[0.2.3]: https://github.com/Ryu-CZ/pi-reasoning-zip/compare/v0.2.2...v0.2.3
+[0.2.2]: https://github.com/Ryu-CZ/pi-reasoning-zip/compare/v0.2.1...v0.2.2
 [0.2.1]: https://github.com/Ryu-CZ/pi-reasoning-zip/compare/v0.2.0...v0.2.1
 [0.2.0]: https://github.com/Ryu-CZ/pi-reasoning-zip/compare/v0.1.0...v0.2.0
 [0.1.0]: https://github.com/Ryu-CZ/pi-reasoning-zip/releases/tag/v0.1.0

package/README.md

@@ -60,7 +60,7 @@ The npm library entrypoint still builds to `dist/index.js`, but Pi package metad
 - **llama.cpp-first targeting** — defaults to llama.cpp-like providers such as `llama-server=http://127.0.0.1:7484`.
 - **Prompt minimization** — optional grug-style request injection for target local providers.
 - **Fail-open safety** — preserves original messages on errors, timeouts, invalid output, or unknown payloads.
-- **Opaque reasoning guard** — skips signed/encrypted/provider-opaque reasoning metadata.
+- **Opaque reasoning guard** — skips signed, encrypted, signature-bearing, redacted, or provider-opaque reasoning metadata.
 
 ## Commands
 
@@ -125,6 +125,8 @@ The compactor must expose an OpenAI-compatible chat completions endpoint:
 POST {baseUrl}/chat/completions
 ```
 
+The extension first sends `chat_template_kwargs: { "enable_thinking": false }` so llama.cpp/Qwen-style compactor calls return the compact trace in `message.content` instead of spending tokens on compactor-side reasoning. If a stricter OpenAI-compatible endpoint rejects that extra field with HTTP 400/422, the request is retried once without it.
+
 The extension asks the compactor to produce terse output like:
 
 ```text
@@ -140,7 +142,7 @@ next:
 - ...
 ```
 
-If the compactor returns `none`, empty output, output longer than the original, or output over `thresholds.maxTraceChars`, the original block is preserved.
+If the compactor returns `none`, empty output, output above `thresholds.targetRatio` of the original length, output longer than the original, or output over `thresholds.maxTraceChars`, the original block is preserved.
 
 ## Safety model
 
@@ -157,6 +159,7 @@ It skips:
 - non-assistant messages
 - messages without array content
 - short thinking below `thresholds.minChars`
+- signature-bearing or redacted thinking blocks
 - unknown providers by default in `llama-only`
 - hosted/non-local providers in `local-only`
 

package/dist/compactorClient.js

@@ -1,25 +1,37 @@
 import { buildCompactionPrompt } from "./compactPrompt.js";
+function buildPayload(thinking, settings, disableThinking) {
+    return {
+        model: settings.compactor.model,
+        messages: [
+            { role: "system", content: "You compress reasoning traces. Output only compact trace." },
+            { role: "user", content: buildCompactionPrompt(thinking) },
+        ],
+        max_tokens: settings.compactor.maxTokens,
+        temperature: settings.compactor.temperature,
+        ...(disableThinking ? { chat_template_kwargs: { enable_thinking: false } } : {}),
+    };
+}
+async function postCompactionRequest(thinking, settings, signal, disableThinking) {
+    return await fetch(`${settings.compactor.baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${settings.compactor.apiKey}`,
+        },
+        body: JSON.stringify(buildPayload(thinking, settings, disableThinking)),
+        signal,
+    });
+}
 export async function compactWithOpenAI(thinking, settings) {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), settings.compactor.timeoutMs);
     try {
-        const response = await fetch(`${settings.compactor.baseUrl}/chat/completions`, {
-            method: "POST",
-            headers: {
-                "content-type": "application/json",
-                authorization: `Bearer ${settings.compactor.apiKey}`,
-            },
-            body: JSON.stringify({
-                model: settings.compactor.model,
-                messages: [
-                    { role: "system", content: "You compress reasoning traces. Output only compact trace." },
-                    { role: "user", content: buildCompactionPrompt(thinking) },
-                ],
-                max_tokens: settings.compactor.maxTokens,
-                temperature: settings.compactor.temperature,
-            }),
-            signal: controller.signal,
-        });
+        let response = await postCompactionRequest(thinking, settings, controller.signal, true);
+        // Some strict OpenAI-compatible endpoints reject llama.cpp/Qwen-specific
+        // chat_template_kwargs. Retry once without it for compatibility.
+        if (response.status === 400 || response.status === 422) {
+            response = await postCompactionRequest(thinking, settings, controller.signal, false);
+        }
         if (!response.ok)
             throw new Error(`Compactor HTTP ${response.status}`);
         const json = (await response.json());

package/dist/index.js

@@ -25,12 +25,13 @@ function readSettingsSection(path) {
 function readRawSettings(cwd) {
     return readSettingsSection(projectSettingsPath(cwd)) ?? readSettingsSection(globalSettingsPath());
 }
-function eventProvider(event) {
-    const message = event.message;
-    if (typeof message?.provider === "string")
-        return message.provider;
+function eventProvider(event, ctx) {
+    if (typeof event.message?.provider === "string")
+        return event.message.provider;
     if (typeof event.provider === "string")
         return event.provider;
+    if (typeof ctx.model?.provider === "string")
+        return ctx.model.provider;
     return undefined;
 }
 export default function reasoningZipExtension(pi) {
@@ -44,7 +45,7 @@ export default function reasoningZipExtension(pi) {
     });
     extension.on("before_provider_request", (event, ctx) => {
         const settings = resolveReasoningZipSettings(readRawSettings(ctx?.cwd));
-        const nextPayload = injectReasoningZipPrompt(event.payload, eventProvider(event), settings);
+        const nextPayload = injectReasoningZipPrompt(event.payload, eventProvider(event, ctx), settings);
         return nextPayload === event.payload ? undefined : nextPayload;
     });
 }

package/dist/messageTransform.js

@@ -5,8 +5,10 @@ function isThinkingBlock(block) {
 function hasOpaqueReasoningMetadata(block) {
     return (typeof block.signature === "string" ||
         typeof block.reasoning_signature === "string" ||
+        typeof block.thinkingSignature === "string" ||
         typeof block.encrypted_content === "string" ||
-        Array.isArray(block.reasoning_details));
+        Array.isArray(block.reasoning_details) ||
+        block.redacted === true);
 }
 function acceptableCompaction(original, compacted, settings) {
     const text = compacted.trim();
@@ -14,6 +16,8 @@ function acceptableCompaction(original, compacted, settings) {
         return undefined;
     if (text.length >= original.length)
         return undefined;
+    if (text.length / original.length > settings.thresholds.targetRatio)
+        return undefined;
     if (text.length > settings.thresholds.maxTraceChars)
         return undefined;
     return text;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-reasoning-zip",
-  "version": "0.2.1",
+  "version": "0.2.5",
   "private": false,
   "description": "Compact reasoning blocks to keep the context short.",
   "license": "MIT",

package/scripts/smoke-extension.mjs

@@ -15,7 +15,7 @@ try {
     JSON.stringify({
       reasoningZip: {
         mode: "llama-only",
-        thresholds: { minChars: 5, maxTraceChars: 100 },
+        thresholds: { minChars: 5, targetRatio: 1, maxTraceChars: 100 },
         compactor: { baseUrl: "http://mock.local/v1", model: "mock", timeoutMs: 1000 },
       },
     }),

package/src/compactorClient.ts

@@ -1,27 +1,47 @@
 import { buildCompactionPrompt } from "./compactPrompt.js";
 import type { ReasoningZipSettings } from "./types.js";
 
+function buildPayload(thinking: string, settings: ReasoningZipSettings, disableThinking: boolean): Record<string, unknown> {
+  return {
+    model: settings.compactor.model,
+    messages: [
+      { role: "system", content: "You compress reasoning traces. Output only compact trace." },
+      { role: "user", content: buildCompactionPrompt(thinking) },
+    ],
+    max_tokens: settings.compactor.maxTokens,
+    temperature: settings.compactor.temperature,
+    ...(disableThinking ? { chat_template_kwargs: { enable_thinking: false } } : {}),
+  };
+}
+
+async function postCompactionRequest(
+  thinking: string,
+  settings: ReasoningZipSettings,
+  signal: AbortSignal,
+  disableThinking: boolean,
+): Promise<Response> {
+  return await fetch(`${settings.compactor.baseUrl}/chat/completions`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${settings.compactor.apiKey}`,
+    },
+    body: JSON.stringify(buildPayload(thinking, settings, disableThinking)),
+    signal,
+  });
+}
+
 export async function compactWithOpenAI(thinking: string, settings: ReasoningZipSettings): Promise<string> {
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), settings.compactor.timeoutMs);
   try {
-    const response = await fetch(`${settings.compactor.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        authorization: `Bearer ${settings.compactor.apiKey}`,
-      },
-      body: JSON.stringify({
-        model: settings.compactor.model,
-        messages: [
-          { role: "system", content: "You compress reasoning traces. Output only compact trace." },
-          { role: "user", content: buildCompactionPrompt(thinking) },
-        ],
-        max_tokens: settings.compactor.maxTokens,
-        temperature: settings.compactor.temperature,
-      }),
-      signal: controller.signal,
-    });
+    let response = await postCompactionRequest(thinking, settings, controller.signal, true);
+
+    // Some strict OpenAI-compatible endpoints reject llama.cpp/Qwen-specific
+    // chat_template_kwargs. Retry once without it for compatibility.
+    if (response.status === 400 || response.status === 422) {
+      response = await postCompactionRequest(thinking, settings, controller.signal, false);
+    }
 
     if (!response.ok) throw new Error(`Compactor HTTP ${response.status}`);
     const json = (await response.json()) as { choices?: Array<{ message?: { content?: unknown } }> };

package/src/index.ts

@@ -6,6 +6,42 @@ import { compactWithOpenAI } from "./compactorClient.js";
 import { compactAssistantMessage } from "./messageTransform.js";
 import { injectReasoningZipPrompt } from "./promptInjection.js";
 import { resolveReasoningZipSettings } from "./settings.js";
+import type { PiMessage } from "./types.js";
+
+// Minimal structural types for the two Pi hooks we consume.
+// Avoids `pi as any` while staying independent of upstream type changes.
+
+interface HookContext {
+  cwd?: string;
+  model?: { provider?: string };
+}
+
+interface MessageEndEvent {
+  message: PiMessage;
+}
+
+interface BeforeProviderRequestEvent {
+  payload: unknown;
+  message?: { provider?: string };
+  provider?: string;
+}
+
+interface ReasoningZipExtension {
+  on(
+    event: "message_end",
+    handler: (
+      event: MessageEndEvent,
+      ctx: HookContext,
+    ) => Promise<{ message: PiMessage } | undefined>,
+  ): void;
+  on(
+    event: "before_provider_request",
+    handler: (
+      event: BeforeProviderRequestEvent,
+      ctx: HookContext,
+    ) => unknown | undefined,
+  ): void;
+}
 
 function globalSettingsPath(): string {
   return join(process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".pi", "agent"), "settings.json");
@@ -29,26 +65,26 @@ function readRawSettings(cwd: string | undefined): unknown {
   return readSettingsSection(projectSettingsPath(cwd)) ?? readSettingsSection(globalSettingsPath());
 }
 
-function eventProvider(event: Record<string, unknown>): string | undefined {
-  const message = event.message as { provider?: unknown } | undefined;
-  if (typeof message?.provider === "string") return message.provider;
+function eventProvider(event: BeforeProviderRequestEvent, ctx: HookContext): string | undefined {
+  if (typeof event.message?.provider === "string") return event.message.provider;
   if (typeof event.provider === "string") return event.provider;
+  if (typeof ctx.model?.provider === "string") return ctx.model.provider;
   return undefined;
 }
 
 export default function reasoningZipExtension(pi: ExtensionAPI) {
-  const extension = pi as any;
+  const extension = pi as unknown as ReasoningZipExtension;
 
-  extension.on("message_end", async (event: any, ctx: any) => {
+  extension.on("message_end", async (event, ctx) => {
     const settings = resolveReasoningZipSettings(readRawSettings(ctx?.cwd));
     const result = await compactAssistantMessage(event.message, settings, (thinking) => compactWithOpenAI(thinking, settings));
     if (result.changed) return { message: result.message };
     return undefined;
   });
 
-  extension.on("before_provider_request", (event: any, ctx: any) => {
+  extension.on("before_provider_request", (event, ctx) => {
     const settings = resolveReasoningZipSettings(readRawSettings(ctx?.cwd));
-    const nextPayload = injectReasoningZipPrompt(event.payload, eventProvider(event), settings);
+    const nextPayload = injectReasoningZipPrompt(event.payload, eventProvider(event, ctx), settings);
     return nextPayload === event.payload ? undefined : nextPayload;
   });
 }

package/src/messageTransform.ts

@@ -11,8 +11,10 @@ function hasOpaqueReasoningMetadata(block: PiMessageBlock): boolean {
   return (
     typeof block.signature === "string" ||
     typeof block.reasoning_signature === "string" ||
+    typeof block.thinkingSignature === "string" ||
     typeof block.encrypted_content === "string" ||
-    Array.isArray(block.reasoning_details)
+    Array.isArray(block.reasoning_details) ||
+    block.redacted === true
   );
 }
 
@@ -20,6 +22,7 @@ function acceptableCompaction(original: string, compacted: string, settings: Rea
   const text = compacted.trim();
   if (!text || text === "none") return undefined;
   if (text.length >= original.length) return undefined;
+  if (text.length / original.length > settings.thresholds.targetRatio) return undefined;
   if (text.length > settings.thresholds.maxTraceChars) return undefined;
   return text;
 }