pi-reasoning-zip 0.2.0 → 0.2.4

package/CHANGELOG.md

@@ -7,6 +7,38 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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
+
+- Pi package metadata now loads readable source from `./extensions` and ships `src` for transparency.
+
 ## [0.2.0] - 2026-07-02
 
 ### Added
@@ -39,6 +71,10 @@ 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.0...HEAD
+[Unreleased]: https://github.com/Ryu-CZ/pi-reasoning-zip/compare/v0.2.4...HEAD
+[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

@@ -44,13 +44,14 @@ npm run check
 npm run smoke
 ```
 
-For local development you can also load the built extension directly:
+For local development you can also load the readable source extension directly:
 
 ```bash
-npm run build
-pi -e ./dist/index.js
+pi -e ./extensions
 ```
 
+The npm library entrypoint still builds to `dist/index.js`, but Pi package metadata points at `./extensions` so Pi can inspect the source it loads.
+
 ## Features
 
 - **Forward-only compaction** — modifies only the new assistant message being finalized.
@@ -124,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
@@ -188,6 +191,7 @@ npm test
 npm run build
 npm run check
 npm run smoke
+pi -e ./extensions --no-extensions --offline --list-models
 npm pack --dry-run
 ```
 
@@ -220,11 +224,12 @@ npm pack --dry-run
    [0.1.0]: https://github.com/Ryu-CZ/pi-reasoning-zip/releases/tag/v0.1.0
    ```
 
-4. Verify build, smoke test, package contents, and npm publish metadata.
+4. Verify build, source-extension load, smoke test, package contents, and npm publish metadata.
 
    ```bash
    npm run check
    npm run smoke
+   pi -e ./extensions --no-extensions --offline --list-models
    npm pack --dry-run
    npm publish --dry-run
    ```

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/extensions/index.ts

@@ -0,0 +1,3 @@
+// Source entrypoint for Pi package loading.
+// The npm library entrypoint remains dist/index.js, but Pi loads this readable source path.
+export { default } from "../src/index.ts";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-reasoning-zip",
-  "version": "0.2.0",
+  "version": "0.2.4",
   "private": false,
   "description": "Compact reasoning blocks to keep the context short.",
   "license": "MIT",
@@ -10,6 +10,8 @@
   "types": "dist/index.d.ts",
   "files": [
     "dist",
+    "src",
+    "extensions",
     "scripts/smoke-extension.mjs",
     "README.md",
     "CHANGELOG.md",
@@ -57,7 +59,7 @@
   },
   "pi": {
     "extensions": [
-      "dist/index.js"
+      "./extensions"
     ],
     "image": "https://raw.githubusercontent.com/Ryu-CZ/pi-reasoning-zip/main/media/banner.webp"
   },

package/src/compactPrompt.ts

@@ -0,0 +1,12 @@
+export function buildCompactionPrompt(thinking: string): string {
+  return `Compress this model reasoning into a compact decision trace for future coding-agent context.
+
+Keep exact paths, commands, symbols, errors, decisions, constraints, failed attempts, and next actions.
+Drop self-talk, repeated planning, obvious reasoning, filler, and prose.
+Use terse bullets under: facts, decisions, constraints, failed, next.
+Target 10-20% of original length.
+If no useful content remains, output exactly: none
+
+Reasoning:
+${thinking}`;
+}

package/src/compactorClient.ts

@@ -0,0 +1,54 @@
+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 {
+    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 } }> };
+    const content = json.choices?.[0]?.message?.content;
+    if (typeof content !== "string") throw new Error("Compactor response missing message content");
+    return content.trim();
+  } finally {
+    clearTimeout(timeout);
+  }
+}

package/src/index.ts

@@ -0,0 +1,90 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+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");
+}
+
+function projectSettingsPath(cwd: string | undefined): string | undefined {
+  return cwd ? join(cwd, ".pi", "settings.json") : undefined;
+}
+
+function readSettingsSection(path: string | undefined): unknown {
+  if (!path) return undefined;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8")) as { reasoningZip?: unknown };
+    return parsed.reasoningZip;
+  } catch {
+    return undefined;
+  }
+}
+
+function readRawSettings(cwd: string | undefined): unknown {
+  return readSettingsSection(projectSettingsPath(cwd)) ?? readSettingsSection(globalSettingsPath());
+}
+
+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 unknown as ReasoningZipExtension;
+
+  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, ctx) => {
+    const settings = resolveReasoningZipSettings(readRawSettings(ctx?.cwd));
+    const nextPayload = injectReasoningZipPrompt(event.payload, eventProvider(event, ctx), settings);
+    return nextPayload === event.payload ? undefined : nextPayload;
+  });
+}

package/src/messageTransform.ts

@@ -0,0 +1,59 @@
+import type { PiMessage, PiMessageBlock, ReasoningZipSettings } from "./types.js";
+import { shouldHandleMessage } from "./target.js";
+
+export type CompactText = (thinking: string) => Promise<string>;
+
+function isThinkingBlock(block: PiMessageBlock): block is PiMessageBlock & { thinking: string } {
+  return block.type === "thinking" && typeof block.thinking === "string";
+}
+
+function hasOpaqueReasoningMetadata(block: PiMessageBlock): boolean {
+  return (
+    typeof block.signature === "string" ||
+    typeof block.reasoning_signature === "string" ||
+    typeof block.encrypted_content === "string" ||
+    Array.isArray(block.reasoning_details)
+  );
+}
+
+function acceptableCompaction(original: string, compacted: string, settings: ReasoningZipSettings): string | undefined {
+  const text = compacted.trim();
+  if (!text || text === "none") return undefined;
+  if (text.length >= original.length) return undefined;
+  if (text.length > settings.thresholds.maxTraceChars) return undefined;
+  return text;
+}
+
+export async function compactAssistantMessage(
+  message: PiMessage,
+  settings: ReasoningZipSettings,
+  compactText: CompactText,
+): Promise<{ message: PiMessage; changed: boolean }> {
+  if (!shouldHandleMessage(message, settings)) return { message, changed: false };
+  if (!Array.isArray(message.content)) return { message, changed: false };
+
+  let changed = false;
+  const nextContent: PiMessageBlock[] = [];
+
+  for (const block of message.content) {
+    if (!isThinkingBlock(block) || hasOpaqueReasoningMetadata(block) || block.thinking.length < settings.thresholds.minChars) {
+      nextContent.push(block);
+      continue;
+    }
+
+    try {
+      const compacted = acceptableCompaction(block.thinking, await compactText(block.thinking), settings);
+      if (!compacted) {
+        nextContent.push(block);
+        continue;
+      }
+      nextContent.push({ ...block, thinking: compacted });
+      changed = true;
+    } catch {
+      nextContent.push(block);
+    }
+  }
+
+  if (!changed) return { message, changed: false };
+  return { message: { ...message, content: nextContent }, changed: true };
+}

package/src/promptInjection.ts

@@ -0,0 +1,43 @@
+import { shouldTargetProvider } from "./target.js";
+import type { ReasoningZipSettings } from "./types.js";
+
+export const PROMPT_MARKER = "<!-- pi-reasoning-zip -->";
+export const PROMPT_INJECTION = `${PROMPT_MARKER}\nYou are Grug. Save token, save world.\nVisible reasoning: terse, keyword-heavy trace only. Keep facts, decisions, constraints, failed paths, next action. No prose reasoning, no self-talk.\nFinal answer: no conversational fluff, no repeated question, minimal markdown. If code is enough, give only code. Think hard, output few tokens.`;
+
+type ChatMessage = { role?: unknown; content?: unknown; [key: string]: unknown };
+
+type Payload = { messages?: unknown; [key: string]: unknown };
+
+function appendToContent(content: unknown): unknown {
+  if (typeof content === "string") {
+    if (content.includes(PROMPT_MARKER)) return content;
+    return `${content}\n\n${PROMPT_INJECTION}`;
+  }
+  if (Array.isArray(content)) {
+    if (content.some((part) => typeof part === "object" && part && "text" in part && typeof part.text === "string" && part.text.includes(PROMPT_MARKER))) {
+      return content;
+    }
+    return [...content, { type: "text", text: PROMPT_INJECTION }];
+  }
+  return content;
+}
+
+export function injectReasoningZipPrompt(payload: unknown, provider: string | undefined, settings: ReasoningZipSettings): unknown {
+  if (!settings.injectPrompt || !shouldTargetProvider(provider, settings)) return payload;
+  if (!payload || typeof payload !== "object") return payload;
+  const typed = payload as Payload;
+  if (!Array.isArray(typed.messages)) return payload;
+
+  const messages = typed.messages as ChatMessage[];
+  const existing = JSON.stringify(messages).includes(PROMPT_MARKER);
+  if (existing) return payload;
+
+  const index = messages.findIndex((message) => message.role === "system" || message.role === "developer");
+  if (index >= 0) {
+    const nextMessages = messages.slice();
+    nextMessages[index] = { ...messages[index], content: appendToContent(messages[index].content) };
+    return { ...typed, messages: nextMessages };
+  }
+
+  return { ...typed, messages: [{ role: "system", content: PROMPT_INJECTION }, ...messages] };
+}

package/src/settings.ts

@@ -0,0 +1,71 @@
+import type { ReasoningZipMode, ReasoningZipSettings, ReasoningZipStorageMode } from "./types.js";
+
+export const DEFAULT_SETTINGS: ReasoningZipSettings = {
+  enabled: true,
+  mode: "llama-only",
+  storageMode: "compact-new",
+  injectPrompt: true,
+  compactor: {
+    baseUrl: "http://127.0.0.1:7484/v1",
+    model: "unsloth",
+    apiKey: "sk-placeholder",
+    maxTokens: 512,
+    temperature: 0.1,
+    timeoutMs: 30000,
+  },
+  thresholds: {
+    minChars: 1000,
+    targetRatio: 0.15,
+    maxTraceChars: 2000,
+  },
+};
+
+const modes = new Set<ReasoningZipMode>(["llama-only", "local-only", "all", "disabled"]);
+const storageModes = new Set<ReasoningZipStorageMode>(["compact-new", "off"]);
+
+function asObject(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : {};
+}
+
+function stringValue(value: unknown, fallback: string): string {
+  return typeof value === "string" && value.length > 0 ? value : fallback;
+}
+
+function booleanValue(value: unknown, fallback: boolean): boolean {
+  return typeof value === "boolean" ? value : fallback;
+}
+
+function numberValue(value: unknown, fallback: number, min = 0): number {
+  return typeof value === "number" && Number.isFinite(value) && value >= min ? value : fallback;
+}
+
+export function resolveReasoningZipSettings(input: unknown): ReasoningZipSettings {
+  const root = asObject(input);
+  const compactor = asObject(root.compactor);
+  const thresholds = asObject(root.thresholds);
+
+  const mode = modes.has(root.mode as ReasoningZipMode) ? (root.mode as ReasoningZipMode) : DEFAULT_SETTINGS.mode;
+  const storageMode = storageModes.has(root.storageMode as ReasoningZipStorageMode)
+    ? (root.storageMode as ReasoningZipStorageMode)
+    : DEFAULT_SETTINGS.storageMode;
+
+  return {
+    enabled: booleanValue(root.enabled, DEFAULT_SETTINGS.enabled),
+    mode,
+    storageMode,
+    injectPrompt: booleanValue(root.injectPrompt, DEFAULT_SETTINGS.injectPrompt),
+    compactor: {
+      baseUrl: stringValue(compactor.baseUrl, DEFAULT_SETTINGS.compactor.baseUrl).replace(/\/$/, ""),
+      model: stringValue(compactor.model, DEFAULT_SETTINGS.compactor.model),
+      apiKey: stringValue(compactor.apiKey, DEFAULT_SETTINGS.compactor.apiKey),
+      maxTokens: numberValue(compactor.maxTokens, DEFAULT_SETTINGS.compactor.maxTokens, 1),
+      temperature: numberValue(compactor.temperature, DEFAULT_SETTINGS.compactor.temperature, 0),
+      timeoutMs: numberValue(compactor.timeoutMs, DEFAULT_SETTINGS.compactor.timeoutMs, 1),
+    },
+    thresholds: {
+      minChars: numberValue(thresholds.minChars, DEFAULT_SETTINGS.thresholds.minChars, 0),
+      targetRatio: numberValue(thresholds.targetRatio, DEFAULT_SETTINGS.thresholds.targetRatio, 0),
+      maxTraceChars: numberValue(thresholds.maxTraceChars, DEFAULT_SETTINGS.thresholds.maxTraceChars, 1),
+    },
+  };
+}

package/src/target.ts

@@ -0,0 +1,36 @@
+import type { PiMessage, ReasoningZipSettings } from "./types.js";
+
+export function isLlamaProvider(providerId: string | undefined): boolean {
+  if (!providerId) return false;
+  const id = providerId.toLowerCase();
+  return id.startsWith("llama-server=") || id.includes("llama.cpp") || id.includes("llamacpp");
+}
+
+export function isLocalUrl(value: string | undefined): boolean {
+  if (!value) return false;
+  try {
+    const url = new URL(value.includes("://") ? value : `http://${value}`);
+    return ["127.0.0.1", "localhost", "::1", "0.0.0.0"].includes(url.hostname);
+  } catch {
+    return false;
+  }
+}
+
+export function shouldHandleMessage(message: PiMessage, settings: ReasoningZipSettings): boolean {
+  if (!settings.enabled || settings.mode === "disabled" || settings.storageMode !== "compact-new") return false;
+  if (message.role !== "assistant") return false;
+
+  const provider = typeof message.provider === "string" ? message.provider : undefined;
+  if (settings.mode === "all") return true;
+  if (settings.mode === "llama-only") return isLlamaProvider(provider);
+  if (settings.mode === "local-only") return isLocalUrl(provider) || isLlamaProvider(provider);
+  return false;
+}
+
+export function shouldTargetProvider(provider: string | undefined, settings: ReasoningZipSettings): boolean {
+  if (!settings.enabled || settings.mode === "disabled") return false;
+  if (settings.mode === "all") return true;
+  if (settings.mode === "llama-only") return isLlamaProvider(provider);
+  if (settings.mode === "local-only") return isLocalUrl(provider) || isLlamaProvider(provider);
+  return false;
+}

package/src/types.ts

@@ -0,0 +1,38 @@
+export type ReasoningZipMode = "llama-only" | "local-only" | "all" | "disabled";
+export type ReasoningZipStorageMode = "compact-new" | "off";
+
+export interface ReasoningZipSettings {
+  enabled: boolean;
+  mode: ReasoningZipMode;
+  storageMode: ReasoningZipStorageMode;
+  injectPrompt: boolean;
+  compactor: {
+    baseUrl: string;
+    model: string;
+    apiKey: string;
+    maxTokens: number;
+    temperature: number;
+    timeoutMs: number;
+  };
+  thresholds: {
+    minChars: number;
+    targetRatio: number;
+    maxTraceChars: number;
+  };
+}
+
+export interface PiMessageBlock {
+  type?: string;
+  text?: string;
+  thinking?: string;
+  [key: string]: unknown;
+}
+
+export interface PiMessage {
+  role?: string;
+  content?: string | PiMessageBlock[];
+  provider?: string;
+  model?: string;
+  api?: string;
+  [key: string]: unknown;
+}