system-prompt-omni 0.2.0 → 0.3.0

package/README.md

@@ -46,18 +46,35 @@ confirmation. Run `/reload` after exporting to load the new file.
 
 ## Prompt recording
 
-Before each provider request, the package compares the SHA-256 hash of the effective system
-prompt with the latest snapshot on the active session branch. When it changes, a durable custom
-session entry with type `pi-system-prompt` records:
+Before each provider request, the package compares the SHA-256 hashes of the effective system
+prompt and serialized active tool definitions with the latest snapshot on the active session
+branch. When either changes, a durable custom session entry with type `pi-system-prompt` records:
 
 - the full effective system prompt, its hash, and UTF-8 byte length;
 - provider, model, API, and thinking-level metadata;
-- active tool names and definitions; and
+- `serializedTools`, the tool-definition value copied from Pi's final provider payload and
+  encoded as a compact JSON string; and
 - provider-level system/developer instructions extracted from the serialized request.
 
+No second tool representation is stored. Tool definitions are not rebuilt or sorted, so array
+order and provider-specific structure stay identical to the `before_provider_request` payload.
+For OpenAI Chat Completions, for example, the value has the same shape as
+`current_harness_tools.json`:
+
+```json
+{
+  "serializedTools": "[{\"type\":\"function\",\"function\":{\"name\":\"read\",\"description\":\"Read files\",\"parameters\":{\"type\":\"object\"}}}]"
+}
+```
+
+The exact representation follows the active API. OpenAI Responses, Anthropic, Google, Bedrock,
+and `pi-messages` therefore retain their own transmitted tool schema rather than being converted
+to the Chat Completions shape. Load this package after extensions that rewrite provider requests
+so it observes their final tool order and definitions.
+
 The recorder never stores the complete provider payload, never adds its custom entries to the
-LLM context, and returns the payload unchanged. Load this package after extensions that rewrite
-provider requests if you want those rewritten provider instructions included in the snapshot.
+LLM context, and returns the payload unchanged. Loading it last also ensures rewritten provider
+instructions are included in the snapshot.
 
 ## Install
 

package/extensions/pi-system-prompt-recorder.ts

@@ -1,5 +1,5 @@
 /**
- * Persist the effective system prompt when it changes.
+ * Persist the effective system prompt or provider tool definitions when either changes.
  *
  * Custom entries are durable but are not added to the LLM context. Load this
  * extension last if another extension rewrites the serialized provider payload
@@ -8,8 +8,9 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 import {
+  extractSerializedTools,
   extractProviderSystemInstructions,
-  latestSystemPromptSha256,
+  latestSystemPromptSnapshotHashes,
   sha256,
   SYSTEM_PROMPT_ENTRY_SCHEMA_VERSION,
   SYSTEM_PROMPT_ENTRY_TYPE,
@@ -19,22 +20,24 @@ export default function systemPromptRecorder(pi: ExtensionAPI): void {
   pi.on("before_provider_request", (event, ctx) => {
     const systemPrompt = ctx.getSystemPrompt();
     const systemPromptSha256 = sha256(systemPrompt);
+    const serializedTools = extractSerializedTools(event.payload);
+    const serializedToolsSha256 =
+      serializedTools === undefined ? undefined : sha256(serializedTools);
 
-    // Compare with the latest snapshot on the active branch. This also avoids
-    // duplicates after process restarts, session resume, and extension reloads.
-    if (latestSystemPromptSha256(ctx.sessionManager.getBranch()) === systemPromptSha256) {
+    // Compare both prompt and tool definitions with the latest snapshot on the
+    // active branch. This also avoids duplicates after process restarts,
+    // session resume, and extension reloads.
+    const latestHashes = latestSystemPromptSnapshotHashes(ctx.sessionManager.getBranch());
+    if (
+      latestHashes?.systemPromptSha256 === systemPromptSha256 &&
+      latestHashes.capturesSerializedTools &&
+      latestHashes.serializedToolsSha256 === serializedToolsSha256
+    ) {
       return undefined;
     }
 
     const providerSystemInstructions = extractProviderSystemInstructions(event.payload);
     const model = ctx.model;
-    const activeTools = pi.getActiveTools();
-    const toolsByName = new Map(pi.getAllTools().map((tool) => [tool.name, tool]));
-    const tools = activeTools.flatMap((name) => {
-      const tool = toolsByName.get(name);
-      if (!tool) return [];
-      return [{ name: tool.name, description: tool.description, parameters: tool.parameters }];
-    });
 
     pi.appendEntry(SYSTEM_PROMPT_ENTRY_TYPE, {
       schemaVersion: SYSTEM_PROMPT_ENTRY_SCHEMA_VERSION,
@@ -47,8 +50,7 @@ export default function systemPromptRecorder(pi: ExtensionAPI): void {
       modelId: model?.id,
       api: model?.api,
       thinkingLevel: pi.getThinkingLevel(),
-      activeTools,
-      tools,
+      ...(serializedTools === undefined ? {} : { serializedTools }),
       providerSystemInstructions,
     });
 

package/lib/system-prompt-recorder.ts

@@ -1,7 +1,13 @@
 import { createHash } from "node:crypto";
 
 export const SYSTEM_PROMPT_ENTRY_TYPE = "pi-system-prompt";
-export const SYSTEM_PROMPT_ENTRY_SCHEMA_VERSION = 1;
+export const SYSTEM_PROMPT_ENTRY_SCHEMA_VERSION = 2;
+
+export interface SystemPromptSnapshotHashes {
+  systemPromptSha256?: string;
+  serializedToolsSha256?: string;
+  capturesSerializedTools: boolean;
+}
 
 interface CustomEntryLike {
   type?: unknown;
@@ -21,6 +27,45 @@ function jsonSnapshot(value: unknown): unknown {
   }
 }
 
+function valueAtPath(root: Record<string, unknown>, path: readonly string[]): unknown {
+  let value: unknown = root;
+  for (const segment of path) {
+    if (!isRecord(value) || !Object.prototype.hasOwnProperty.call(value, segment)) {
+      return undefined;
+    }
+    value = value[segment];
+  }
+  return value;
+}
+
+/**
+ * Serialize the tool definitions from Pi's final provider payload without
+ * rebuilding, sorting, or normalizing them. The paths cover Pi's current
+ * provider transports, including OpenAI, Anthropic, Google, Bedrock, and the
+ * pi-messages API.
+ */
+export function extractSerializedTools(payload: unknown): string | undefined {
+  if (!isRecord(payload)) return undefined;
+
+  const toolPaths = [
+    ["tools"],
+    ["config", "tools"],
+    ["toolConfig", "tools"],
+    ["context", "tools"],
+    ["body", "tools"],
+    ["body", "config", "tools"],
+    ["body", "toolConfig", "tools"],
+    ["body", "context", "tools"],
+  ] as const;
+
+  for (const path of toolPaths) {
+    const tools = valueAtPath(payload, path);
+    if (tools === undefined) continue;
+    return JSON.stringify(tools);
+  }
+  return undefined;
+}
+
 function pushField(
   result: Array<Record<string, unknown>>,
   root: Record<string, unknown>,
@@ -109,3 +154,31 @@ export function latestSystemPromptSha256(entries: readonly CustomEntryLike[]): s
   }
   return undefined;
 }
+
+/** Return the hashes from the newest recorder snapshot on the active branch. */
+export function latestSystemPromptSnapshotHashes(
+  entries: readonly CustomEntryLike[],
+): SystemPromptSnapshotHashes | undefined {
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index];
+    if (entry?.type !== "custom" || entry.customType !== SYSTEM_PROMPT_ENTRY_TYPE) continue;
+    if (!isRecord(entry.data)) continue;
+
+    const systemPromptSha256 =
+      typeof entry.data.systemPromptSha256 === "string"
+        ? entry.data.systemPromptSha256
+        : typeof entry.data.systemPrompt === "string"
+          ? sha256(entry.data.systemPrompt)
+          : undefined;
+    const serializedToolsSha256 =
+      typeof entry.data.serializedTools === "string"
+        ? sha256(entry.data.serializedTools)
+        : undefined;
+    const capturesSerializedTools =
+      typeof entry.data.schemaVersion === "number" &&
+      entry.data.schemaVersion >= SYSTEM_PROMPT_ENTRY_SCHEMA_VERSION;
+
+    return { systemPromptSha256, serializedToolsSha256, capturesSerializedTools };
+  }
+  return undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "system-prompt-omni",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "description": "Display, export, and record the effective pi coding agent system prompt",
   "keywords": ["pi-package", "pi-extension", "system-prompt", "debugging", "recorder"],