pi-l1-cache 1.2.1 → 1.4.0

package/fix-l1-cache.cjs

@@ -0,0 +1,405 @@
+// fix-l1-cache.js
+// Hotfix: L1 response-cache support for pi (@earendil-works/pi-coding-agent).
+//
+// Adds two capabilities the stock extension API lacks:
+//   1. REPLAY  — an extension may serve a cached response by returning params
+//                containing `__piL1Replay: [chunks]` from before_provider_request;
+//                pi-ai then feeds the cached chunks through the normal consume
+//                path and never contacts the provider.
+//   2. CAPTURE — after a successful completion, pi-ai calls options.onStreamComplete
+//                (allChunks, requestParams); the sdk forwards them to extensions as a
+//                `provider_stream_complete` event so l1-cache can store the response.
+//
+// Layout-aware (pi >= 0.84 runs from the esbuild bundle at dist/bundle/cli.js —
+// unbundled sources are inert, so this script patches the bundles):
+//   BUNDLE (pi >= 0.84):
+//     dist/bundle/chunks/openai-completions-*.js  (5 sites)
+//     dist/bundle/chunks/chunk-*.js               (1 site: forward onStreamComplete)
+//     dist/bundle/chunks/chunk-*.js               (1 site: provider_stream_complete event)
+//   PRE-BUNDLE (pi < 0.84):
+//     node_modules/@earendil-works/pi-ai/dist/api/openai-completions.js  (5 sites)
+//     node_modules/@earendil-works/pi-ai/dist/api/simple-options.js      (1 site)
+//     dist/core/sdk.js                                                   (1 site)
+//
+// Usage: node fix-l1-cache.js
+// Idempotent: exits 0 ("already patched") when all sites are patched.
+// Bundle-era site misses print a warning but do NOT abort (L1 cache degrades
+// to pass-through; never block a pi install for an optional cache).
+//
+// NOTE: pre-bundle sites must run AFTER fix-reasoning-content.js in the
+// postinstall chain (site-2 oldText assumes the reasoning_content hotfix
+// try/catch). Bundle site 2's anchor assumes the reasoning bundle patch
+// (the async IIFE) from fix-reasoning-content.js v1.4 (bundle-aware).
+
+const fs = require("fs")
+const path = require("path")
+
+const PACKAGE_ROOT =
+  process.env.PI_PACKAGE_ROOT ||
+  path.join(__dirname, "node_modules/@earendil-works/pi-coding-agent")
+
+// --------------------------------------------------------------------------
+// File resolution
+// --------------------------------------------------------------------------
+
+// Bundle chunks live under the pi-coding-agent package (npm: nested; bun: a
+// flat sibling of pi-ai next to it). Collect candidates primary-first.
+function packageCandidates() {
+  const dirs = []
+  if (fs.existsSync(path.join(PACKAGE_ROOT, "dist"))) dirs.push(PACKAGE_ROOT)
+  const sibling =
+    path.basename(PACKAGE_ROOT) === "pi-ai"
+      ? path.join(path.dirname(PACKAGE_ROOT), "pi-coding-agent")
+      : null
+  if (sibling && fs.existsSync(path.join(sibling, "dist"))) dirs.push(sibling)
+  return dirs
+}
+
+function bundleChunksDirs(candidates) {
+  const out = []
+  for (const p of candidates) {
+    const d = path.join(p, "dist", "bundle", "chunks")
+    if (fs.existsSync(d)) out.push(d)
+  }
+  return out
+}
+
+function isBundleEra(candidates) {
+  return candidates.length > 0 && bundleChunksDirs(candidates).length > 0
+}
+
+const OPENAI_COMPLETIONS = path.join(
+  PACKAGE_ROOT,
+  "node_modules/@earendil-works/pi-ai/dist/api/openai-completions.js"
+)
+const SIMPLE_OPTIONS = path.join(
+  PACKAGE_ROOT,
+  "node_modules/@earendil-works/pi-ai/dist/api/simple-options.js"
+)
+const SDK = path.join(PACKAGE_ROOT, "dist/core/sdk.js")
+
+// --------------------------------------------------------------------------
+// Bundle phase (pi >= 0.84)
+// --------------------------------------------------------------------------
+
+// Minified exact anchors (verified against the 0.86.0 bundle; chunk-* hashes
+// change per build, so files are located by anchor presence, not filename).
+
+// openai-completions provider chunk — 5 sites.
+// Site 1: read the __piL1Replay marker out of the payload (into a var in the
+// enclosing scope) before the provider call path is set up.
+const B1_OLD =
+  'nextParams=await options?.onPayload?.(params,model);nextParams!==void 0&&(params=nextParams);let requestOptions={...options?.signal?{signal:options.signal}:{},...options?.timeoutMs!==void 0?{timeout:options.timeoutMs}:{},maxRetries:0}'
+const B1_NEW =
+  'nextParams=await options?.onPayload?.(params,model);nextParams!==void 0&&(params=nextParams);let __l1ReplayChunks;if(params&&typeof params==="object"&&Array.isArray(params.__piL1Replay)){__l1ReplayChunks=params.__piL1Replay;delete params.__piL1Replay}let requestOptions={...options?.signal?{signal:options.signal}:{},...options?.timeoutMs!==void 0?{timeout:options.timeoutMs}:{},maxRetries:0}'
+const B1_MARKER = "let __l1ReplayChunks;"
+
+// Site 2: skip the provider call on replay. Anchor assumes the fix-reasoning-
+// content.js async IIFE (bundle-aware v1.4) already wrapped the create call.
+const B2_OLD =
+  '{data:openaiStream,response}=await(async()=>{try{return await retryProviderRequest(()=>client.chat.completions.create(params,requestOptions).withResponse(),{maxRetries:options?.maxRetries,maxRetryDelayMs:options?.maxRetryDelayMs,signal:options?.signal})}catch(e){'
+const B2_NEW =
+  '{data:openaiStream,response}=await(async()=>{if(__l1ReplayChunks!==void 0)return{data:__l1ReplayChunks,response:{status:200,headers:new Headers()}};try{return await retryProviderRequest(()=>client.chat.completions.create(params,requestOptions).withResponse(),{maxRetries:options?.maxRetries,maxRetryDelayMs:options?.maxRetryDelayMs,signal:options?.signal})}catch(e){'
+const B2_MARKER = "if(__l1ReplayChunks!==void 0)return{data:__l1ReplayChunks"
+
+// Site 3: collect raw chunks in the consume loop scope.
+const B3_OLD = 'stream2.push({type:"start",partial:output});'
+const B3_NEW = 'stream2.push({type:"start",partial:output});const allChunks=[];'
+const B3_MARKER = "const allChunks=[];"
+
+// Site 4: append each streamed chunk.
+const B4_OLD =
+  'for await(let chunk of openaiStream){if(!chunk||typeof chunk!="object")continue;'
+const B4_NEW =
+  'for await(let chunk of openaiStream){if(!chunk||typeof chunk!="object")continue;allChunks.push(chunk);'
+const B4_MARKER = "allChunks.push(chunk);"
+
+// Site 5: fire capture right before the done event.
+const B5_OLD =
+  'stream2.push({type:"done",reason:output.stopReason,message:output}),stream2.end()'
+const B5_NEW =
+  'if(allChunks.length>0&&options?.onStreamComplete){try{await options.onStreamComplete(allChunks,params)}catch(_l1err){}}stream2.push({type:"done",reason:output.stopReason,message:output}),stream2.end()'
+const B5_MARKER = "options.onStreamComplete(allChunks,params)"
+
+// Site 6: forward onStreamComplete through the shared simple-options builder.
+const B6_OLD =
+  "onPayload:options?.onPayload,onResponse:options?.onResponse,timeoutMs:options?.timeoutMs"
+const B6_NEW =
+  "onPayload:options?.onPayload,onResponse:options?.onResponse,onStreamComplete:options?.onStreamComplete,timeoutMs:options?.timeoutMs"
+const B6_MARKER = "onStreamComplete:options?.onStreamComplete"
+
+// Site 7: sdk chunk — emit provider_stream_complete to extensions after a
+// successful completion. Sits inside the options object next to transformHeaders.
+const B7_OLD =
+  'transformHeaders:async requestHeaders=>{let headers=mergeProviderAttributionHeaders(requestModel,settingsManager,options2.sessionId,requestHeaders);return headerRunner?.hasHandlers("before_provider_headers")?headerRunner.emitBeforeProviderHeaders(headers??{}):headers??{}}}'
+const B7_NEW =
+  'transformHeaders:async requestHeaders=>{let headers=mergeProviderAttributionHeaders(requestModel,settingsManager,options2.sessionId,requestHeaders);return headerRunner?.hasHandlers("before_provider_headers")?headerRunner.emitBeforeProviderHeaders(headers??{}):headers??{}},onStreamComplete:async(chunks,requestParams)=>{let runner=extensionRunnerRef?.current;if(runner?.hasHandlers("provider_stream_complete")){await runner.emit({type:"provider_stream_complete",payload:requestParams,chunks})}}}'
+const B7_MARKER = 'type:"provider_stream_complete"'
+
+const BUNDLE_PROVIDER_SITES = [
+  { name: "replay-marker-read", marker: B1_MARKER, old: B1_OLD, next: B1_NEW },
+  { name: "replay-skip-provider-call", marker: B2_MARKER, old: B2_OLD, next: B2_NEW },
+  { name: "allChunks-decl", marker: B3_MARKER, old: B3_OLD, next: B3_NEW },
+  { name: "allChunks-push", marker: B4_MARKER, old: B4_OLD, next: B4_NEW },
+  { name: "onStreamComplete-call", marker: B5_MARKER, old: B5_OLD, next: B5_NEW },
+]
+const BUNDLE_FORWARD_SITES = [
+  { name: "forward-onStreamComplete", marker: B6_MARKER, old: B6_OLD, next: B6_NEW },
+]
+const BUNDLE_SDK_SITES = [
+  { name: "provider_stream_complete-event", marker: B7_MARKER, old: B7_OLD, next: B7_NEW },
+]
+
+function patchSitesInFile(file, rel, sites, fatal) {
+  let src = fs.readFileSync(file, "utf8")
+  let applied = 0
+  let already = 0
+  const missing = []
+  for (const { name, marker, old, next } of sites) {
+    if (src.includes(marker)) {
+      already++
+      continue
+    }
+    if (!src.includes(old)) {
+      missing.push(name)
+      continue
+    }
+    src = src.replace(old, next)
+    applied++
+  }
+  if (missing.length > 0) {
+    const msg = `site(s) ${missing.join(", ")} not found (layout changed?)`
+    if (fatal) {
+      console.error(`fix-l1-cache.js: ${rel}: ${msg}`)
+      process.exit(1)
+    }
+    console.error(`fix-l1-cache.js: ${rel}: ${msg} — skipped (L1 cache stays pass-through)`)
+  }
+  if (applied > 0 || missing.length > 0) fs.writeFileSync(file, src)
+  if (applied > 0 || already > 0)
+    console.log(`fix-l1-cache.js: ${rel}: ${applied} applied, ${already} already patched`)
+  return missing.length === 0
+}
+
+function patchBundles(candidates) {
+  let anyHandled = false
+  for (const chunksDir of bundleChunksDirs(candidates)) {
+    const relDir = chunksDir.includes("node_modules")
+      ? chunksDir.slice(chunksDir.indexOf("node_modules"))
+      : chunksDir
+    const files = fs.readdirSync(chunksDir).filter((f) => f.endsWith(".js"))
+    for (const name of files) {
+      const file = path.join(chunksDir, name)
+      const rel = name
+      // Chunks can be several MB (e.g. the sdk chunk) — scan the full text.
+      const srcHead = fs.readFileSync(file, "utf8")
+      let did = false
+      if (/^openai-completions-.*\.js$/.test(name)) {
+        // Provider chunk: the openai-completions stream() consumer. Identify by
+        // anchor presence so a re-run or a different build still finds it.
+        const isProvider = srcHead.includes(B2_OLD) || srcHead.includes(B2_MARKER)
+        if (isProvider) {
+          if (patchSitesInFile(file, rel, BUNDLE_PROVIDER_SITES, false)) anyHandled = true
+          did = true
+        }
+      }
+      if (/^chunk-.*\.js$/.test(name)) {
+        if (srcHead.includes(B6_OLD) || srcHead.includes(B6_MARKER)) {
+          patchSitesInFile(file, rel, BUNDLE_FORWARD_SITES, false)
+          anyHandled = true
+          did = true
+        }
+        if (srcHead.includes(B7_OLD) || srcHead.includes(B7_MARKER)) {
+          patchSitesInFile(file, rel, BUNDLE_SDK_SITES, false)
+          anyHandled = true
+          did = true
+        }
+      }
+      void did
+    }
+  }
+  return anyHandled
+}
+
+// --------------------------------------------------------------------------
+// Pre-bundle phase (pi < 0.84 — readable sources are the runtime)
+// --------------------------------------------------------------------------
+
+function fail(file, why) {
+  console.error(`fix-l1-cache.js: ${file}: ${why}`)
+  process.exit(1)
+}
+
+function patch(file, sites) {
+  if (!fs.existsSync(file)) fail(file, "file not found")
+  let src = fs.readFileSync(file, "utf8")
+  let applied = 0
+  let already = 0
+  for (const { name, marker, oldText, newText } of sites) {
+    if (src.includes(marker)) {
+      already++
+      continue
+    }
+    if (!src.includes(oldText))
+      fail(file, `site "${name}" not found (layout changed upstream?)`)
+    src = src.replace(oldText, newText)
+    applied++
+  }
+  fs.writeFileSync(file, src)
+  console.log(
+    `fix-l1-cache.js: ${path.relative(PACKAGE_ROOT, file)}: ${applied} applied, ${already} already patched`
+  )
+  return applied + already
+}
+
+function patchReadable() {
+  patch(OPENAI_COMPLETIONS, [
+    {
+      name: "replay-marker-read",
+      marker: "__piL1Replay",
+      oldText: `            const nextParams = await options?.onPayload?.(params, model);
+            if (nextParams !== undefined) {
+                params = nextParams;
+            }
+            const requestOptions = {`,
+      newText: `            const nextParams = await options?.onPayload?.(params, model);
+            if (nextParams !== undefined) {
+                params = nextParams;
+            }
+            // L1 cache replay: an extension may serve a cached response by
+            // returning params with a __piL1Replay array of OpenAI stream chunks.
+            // The cached chunks are fed through the normal consume path below,
+            // so parsing/usage/stop-reason handling stays identical.
+            let __l1ReplayChunks;
+            if (params && typeof params === "object" && Array.isArray(params.__piL1Replay)) {
+                __l1ReplayChunks = params.__piL1Replay;
+                delete params.__piL1Replay;
+            }
+            const requestOptions = {`,
+    },
+    {
+      name: "replay-skip-provider-call",
+      marker: "else try {",
+      oldText: `            let openaiStream, response;
+            try {
+                ({ data: openaiStream, response } = await retryProviderRequest(() => client.chat.completions.create(params, requestOptions).withResponse(), {
+                    maxRetries: options?.maxRetries,
+                    maxRetryDelayMs: options?.maxRetryDelayMs,
+                    signal: options?.signal,
+                }));
+            } catch (firstError) {`,
+      newText: `            let openaiStream, response;
+            if (__l1ReplayChunks !== undefined) {
+                response = { status: 200, headers: new Headers() };
+                openaiStream = __l1ReplayChunks;
+            }
+            else try {
+                ({ data: openaiStream, response } = await retryProviderRequest(() => client.chat.completions.create(params, requestOptions).withResponse(), {
+                    maxRetries: options?.maxRetries,
+                    maxRetryDelayMs: options?.maxRetryDelayMs,
+                    signal: options?.signal,
+                }));
+            } catch (firstError) {`,
+    },
+    {
+      name: "allChunks-decl",
+      marker: "const allChunks = [];",
+      oldText: `            await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
+            stream.push({ type: "start", partial: output });`,
+      newText: `            await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
+            stream.push({ type: "start", partial: output });
+            const allChunks = [];`,
+    },
+    {
+      name: "allChunks-push",
+      marker: "allChunks.push(chunk);",
+      oldText: `            for await (const chunk of openaiStream) {
+                if (!chunk || typeof chunk !== "object")
+                    continue;`,
+      newText: `            for await (const chunk of openaiStream) {
+                if (!chunk || typeof chunk !== "object")
+                    continue;
+                allChunks.push(chunk);`,
+    },
+    {
+      name: "onStreamComplete-call",
+      marker: "options.onStreamComplete(allChunks, params)",
+      oldText: `            if ((compat.supportsFinishReason && !hasFinishReason) || output.stopReason === "pending") {
+                throw new Error("Stream ended without finish_reason");
+            }
+            stream.push({ type: "done", reason: output.stopReason, message: output });`,
+      newText: `            if ((compat.supportsFinishReason && !hasFinishReason) || output.stopReason === "pending") {
+                throw new Error("Stream ended without finish_reason");
+            }
+            if (allChunks.length > 0 && options?.onStreamComplete) {
+                try {
+                    await options.onStreamComplete(allChunks, params);
+                }
+                catch (_l1err) { }
+            }
+            stream.push({ type: "done", reason: output.stopReason, message: output });`,
+    },
+  ])
+
+  patch(SIMPLE_OPTIONS, [
+    {
+      name: "forward-onStreamComplete",
+      marker: "onStreamComplete: options?.onStreamComplete",
+      oldText: `        onPayload: options?.onPayload,
+        onResponse: options?.onResponse,`,
+      newText: `        onPayload: options?.onPayload,
+        onResponse: options?.onResponse,
+        onStreamComplete: options?.onStreamComplete,`,
+    },
+  ])
+
+  patch(SDK, [
+    {
+      name: "provider_stream_complete-event",
+      marker: 'type: "provider_stream_complete"',
+      oldText: `                transformHeaders: async (requestHeaders) => {
+                    const headers = mergeProviderAttributionHeaders(model, settingsManager, options?.sessionId, requestHeaders);
+                    return headerRunner?.hasHandlers("before_provider_headers")
+                        ? headerRunner.emitBeforeProviderHeaders(headers ?? {})
+                        : (headers ?? {});
+                },
+            });`,
+      newText: `                transformHeaders: async (requestHeaders) => {
+                    const headers = mergeProviderAttributionHeaders(model, settingsManager, options?.sessionId, requestHeaders);
+                    return headerRunner?.hasHandlers("before_provider_headers")
+                        ? headerRunner.emitBeforeProviderHeaders(headers ?? {})
+                        : (headers ?? {});
+                },
+                onStreamComplete: async (chunks, requestParams) => {
+                    const runner = extensionRunnerRef.current;
+                    if (!runner?.hasHandlers("provider_stream_complete")) {
+                        return;
+                    }
+                    await runner.emit({
+                        type: "provider_stream_complete",
+                        payload: requestParams,
+                        chunks,
+                    });
+                },
+            });`,
+    },
+  ])
+}
+
+// --------------------------------------------------------------------------
+// Main
+// --------------------------------------------------------------------------
+
+const candidates = packageCandidates()
+if (isBundleEra(candidates)) {
+  const ok = patchBundles(candidates)
+  if (ok)
+    console.log("fix-l1-cache.js: bundle sites OK (replay + capture wired into the runtime bundle)")
+  else
+    console.error(
+      "fix-l1-cache.js: bundle era detected but no chunk matched the anchors — L1 cache stays pass-through."
+    )
+} else {
+  patchReadable()
+  console.log("fix-l1-cache.js: all sites OK")
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-l1-cache",
-  "version": "1.2.1",
-  "description": "L1 in-memory cache extension for pi — CPU/RAM optimized, production-ready",
+  "version": "1.4.0",
+  "description": "L1 response cache for pi with replay, disk persistence, and working capture",
   "type": "module",
   "main": "./src/index.ts",
   "engines": {
@@ -20,10 +20,11 @@
   ],
   "files": [
     "src",
+    "fix-l1-cache.cjs",
     "README.md",
     "LICENSE"
   ],
-  "author": "Tobias Weiß <weissto@hrz.uni-marburg.de>",
+  "author": "Tobias Weiß <info@graphwiz.ai>",
   "license": "MIT",
   "homepage": "https://github.com/tobias-weiss-ai-xr/pi-l1-cache",
   "repository": {
@@ -34,14 +35,24 @@
     "url": "https://github.com/tobias-weiss-ai-xr/pi-l1-cache/issues"
   },
   "pi": {
-    "extensions": ["./src/index.ts"],
+    "extensions": [
+      "./src/index.ts"
+    ],
     "minPiVersion": "0.4.0"
   },
   "scripts": {
-    "test": "node --test src/*.test.ts",
-    "test:watch": "node --watch --test src/*.test.ts"
+    "test": "tsx --test src/*.test.ts",
+    "test:watch": "tsx --watch --test src/*.test.ts",
+    "typecheck": "tsc --noEmit --skipLibCheck",
+    "pack": "npm pack --dry-run"
   },
   "devDependencies": {
-    "@types/node": "^20.0.0"
+    "@earendil-works/pi-coding-agent": "^0.84.0",
+    "@types/node": "^20.0.0",
+    "tsx": "^4.23.12",
+    "typescript": "^5.8.0"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*"
   }
 }