@zosmaai/pi-llm-wiki 0.10.4 → 0.10.6

package/README.md

@@ -440,6 +440,13 @@ Thanks to everyone who has contributed! This list is regenerated automatically b
                     <sub><b>Akshay</b></sub>
                 </a>
             </td>
+            <td align="center">
+                <a href="https://github.com/danielnaab">
+                    <img src="https://avatars.githubusercontent.com/u/136512?v=4" width="64;" alt="danielnaab"/>
+                    <br />
+                    <sub><b>Daniel Naab</b></sub>
+                </a>
+            </td>
             <td align="center">
                 <a href="https://github.com/mystery4f">
                     <img src="https://avatars.githubusercontent.com/u/40482524?v=4" width="64;" alt="mystery4f"/>

package/extensions/llm-wiki/index.ts

@@ -2,7 +2,7 @@ import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, join } from "node:path";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { installGuardrails } from "./lib/guardrails.js";
-import { buildAgentStartInjection } from "./lib/inject.js";
+import { buildAgentStartInjection, normalizeSystemPrompt } from "./lib/inject.js";
 import { registerWikiModelCommand } from "./lib/model-command.js";
 import {
   buildSessionNotice,
@@ -303,13 +303,12 @@ Then call wiki_bootstrap with the inferred topic and mode to finalize the setup.
 
     // Split into a cache-stable system prompt (static footer only) and a
     // volatile tail message (issue #92). See lib/inject.ts for the contract.
-    const { systemPrompt, message } = buildAgentStartInjection(event.systemPrompt || "", [
-      dynamicContext,
-    ]);
+    const priorSystemPrompt = normalizeSystemPrompt(event.systemPrompt);
+    const { systemPrompt, message } = buildAgentStartInjection(priorSystemPrompt, [dynamicContext]);
 
     // Only claim a systemPrompt change when the footer actually altered the
     // string (a carry-forward turn already carries it, so this no-ops).
-    const systemPromptChanged = systemPrompt !== event.systemPrompt;
+    const systemPromptChanged = systemPrompt !== priorSystemPrompt;
     if (!systemPromptChanged && !message) return;
     return {
       ...(systemPromptChanged ? { systemPrompt } : {}),

package/extensions/llm-wiki/lib/embeddings.ts

@@ -285,14 +285,94 @@ function embeddingsRequestPath(basePath: string): string {
 }
 
 interface EmbeddingApiResponse {
-  data?: Array<{ index: number; embedding: number[] }>;
+  data?: Array<{ index?: number; embedding: number[] }>;
   error?: { message?: string };
+  /** Some OpenAI-compatible gateways (e.g. GSA USAi / Vertex) nest errors here. */
+  detail?: unknown;
+}
+
+/**
+ * Max inputs per embeddings request. Providers cap batch size server-side
+ * (OpenAI 2048, Google Vertex `text-embedding-*` 250, Cohere v3 96); we chunk
+ * under the smallest common limit so a reindex of hundreds of pages never
+ * overruns the cap. Exported so tests and callers can reference the default.
+ */
+export const DEFAULT_MAX_EMBED_BATCH = 96;
+
+/**
+ * Approx per-request character budget. Providers also cap *total tokens* per
+ * request (Google Vertex `text-embedding-*` = 20,000 tokens). Tokenizing here
+ * would add a dependency, so we approximate with a conservative char budget
+ * (~2.8 chars/token observed for wiki prose, with headroom) — the request
+ * stays well under the token cap without counting tokens.
+ */
+export const DEFAULT_MAX_EMBED_BATCH_CHARS = 45_000;
+
+/**
+ * Split `texts` into batches that stay under BOTH a count cap and a total
+ * char budget. A single oversized text is emitted as its own batch rather than
+ * dropped, so every input is always embedded. Pure — unit-testable with no
+ * network.
+ */
+export function chunkByBudget(texts: string[], maxCount: number, maxChars: number): string[][] {
+  const batches: string[][] = [];
+  let batch: string[] = [];
+  let chars = 0;
+  for (const text of texts) {
+    // Close the current batch before adding a text that would exceed either
+    // cap — but never emit an empty batch (an oversized text stands alone).
+    if (batch.length > 0 && (batch.length >= maxCount || chars + text.length > maxChars)) {
+      batches.push(batch);
+      batch = [];
+      chars = 0;
+    }
+    batch.push(text);
+    chars += text.length;
+  }
+  if (batch.length > 0) batches.push(batch);
+  return batches;
+}
+
+/**
+ * Parse an OpenAI-compatible embeddings response into row-ordered vectors,
+ * throwing on any error shape so failures are never silently stored as empty
+ * vectors. Handles gateways that report errors via a nested `detail` field
+ * (GSA USAi / Vertex) or via HTTP status alone, and providers that omit the
+ * per-row `index` (returning rows in request order). Pure — unit-testable.
+ */
+export function parseEmbeddingResponse(
+  status: number,
+  body: EmbeddingApiResponse,
+  expectedCount: number,
+): number[][] {
+  if (body.error || body.detail !== undefined || status < 200 || status >= 300) {
+    const message =
+      body.error?.message ??
+      (typeof body.detail === "string"
+        ? body.detail
+        : body.detail !== undefined
+          ? JSON.stringify(body.detail)
+          : `HTTP ${status}`);
+    throw new Error(`embedding API error: ${message}`);
+  }
+  const rows = body.data ?? [];
+  if (rows.length !== expectedCount) {
+    throw new Error(`embedding API returned ${rows.length} vectors for ${expectedCount} inputs`);
+  }
+  const ordered = rows.every((r) => typeof r.index === "number")
+    ? [...rows].sort((a, b) => (a.index as number) - (b.index as number))
+    : rows;
+  return ordered.map((r) => r.embedding);
 }
 
 /**
  * Create an `EmbedFn` backed by an OpenAI-compatible `/v1/embeddings`
  * endpoint. Uses node's http/https directly (no SDK) so it works against
  * OpenAI, Azure (with an api-key header), or any compatible gateway.
+ *
+ * Inputs are split into batches under both the instance-count and total-char
+ * caps (see `chunkByBudget`) and re-joined in request order, so provider batch
+ * limits never truncate a reindex. Any request error is thrown, not swallowed.
  */
 export function createOpenAIEmbedFn(cfg: {
   apiKey: string;
@@ -306,7 +386,7 @@ export function createOpenAIEmbedFn(cfg: {
   const useHttp = parsed.protocol === "http:";
   const port = parsed.port ? Number(parsed.port) : undefined;
 
-  return (texts) =>
+  const embedBatch = (texts: string[]): Promise<number[][]> =>
     new Promise<number[][]>((resolve, reject) => {
       if (texts.length === 0) {
         resolve([]);
@@ -333,17 +413,17 @@ export function createOpenAIEmbedFn(cfg: {
             data += chunk.toString();
           });
           res.on("end", () => {
+            let parsedBody: EmbeddingApiResponse;
             try {
-              const parsedBody = JSON.parse(data) as EmbeddingApiResponse;
-              if (parsedBody.error) {
-                reject(new Error(`embedding API error: ${parsedBody.error.message ?? "unknown"}`));
-                return;
-              }
-              const rows = parsedBody.data ?? [];
-              const sorted = [...rows].sort((a, b) => a.index - b.index);
-              resolve(sorted.map((d) => d.embedding));
+              parsedBody = JSON.parse(data) as EmbeddingApiResponse;
             } catch (err) {
               reject(new Error(`failed to parse embedding response: ${(err as Error).message}`));
+              return;
+            }
+            try {
+              resolve(parseEmbeddingResponse(res.statusCode ?? 0, parsedBody, texts.length));
+            } catch (err) {
+              reject(err as Error);
             }
           });
         },
@@ -352,6 +432,18 @@ export function createOpenAIEmbedFn(cfg: {
       req.write(body);
       req.end();
     });
+
+  return async (texts) => {
+    const out: number[][] = [];
+    for (const batch of chunkByBudget(
+      texts,
+      DEFAULT_MAX_EMBED_BATCH,
+      DEFAULT_MAX_EMBED_BATCH_CHARS,
+    )) {
+      out.push(...(await embedBatch(batch)));
+    }
+    return out;
+  };
 }
 
 /**

package/extensions/llm-wiki/lib/inject.ts

@@ -33,6 +33,14 @@ export function appendWikiStatus(systemPrompt: string): string {
   return `${base}\n\n${WIKI_STATUS_BLOCK}`;
 }
 
+/** Normalize upstream Pi and OMP system-prompt representations. */
+export function normalizeSystemPrompt(
+  systemPrompt: string | readonly string[] | null | undefined,
+): string {
+  if (Array.isArray(systemPrompt)) return systemPrompt.join("\n\n");
+  return typeof systemPrompt === "string" ? systemPrompt : "";
+}
+
 /** customType of the hidden tail message carrying volatile per-turn context. */
 export const WIKI_RECALL_MESSAGE_TYPE = "wiki-recall-context";
 
@@ -69,10 +77,10 @@ export interface AgentStartInjection {
  * Pure and side-effect free — see test/agent-start-injection.test.ts.
  */
 export function buildAgentStartInjection(
-  baseSystemPrompt: string,
+  baseSystemPrompt: string | readonly string[] | null | undefined,
   dynamicBlocks: Array<string | undefined>,
 ): AgentStartInjection {
-  const systemPrompt = appendWikiStatus(baseSystemPrompt);
+  const systemPrompt = appendWikiStatus(normalizeSystemPrompt(baseSystemPrompt));
   const content = dynamicBlocks
     .map((b) => b?.trim())
     .filter((b): b is string => Boolean(b))

package/extensions/llm-wiki/lib/observation.ts

@@ -348,10 +348,11 @@ export function registerObservationReminder(
     reminderState.observeDoneThisSession = false;
   });
 
-  // After compaction, reset the reminder state so reminders resume
+  // After compaction, reset turn counter so reminders resume
+  // BUT preserve observeDoneThisSession — if the model already called
+  // wiki_observe this session, compaction should not resurrect the nag.
   pi.on("session_compact", async () => {
     turnsSinceLastReminder = 0;
-    reminderState.observeDoneThisSession = false;
   });
 
   pi.on("agent_end", async (event, _ctx) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zosmaai/pi-llm-wiki",
-  "version": "0.10.4",
+  "version": "0.10.6",
   "description": "Self-maintaining LLM Wiki for Pi — Karpathy-pattern knowledge base with immutable source capture, automated ingestion, search, linting, and Obsidian-compatible vault. auto-updating personal & company wiki.",
   "keywords": [
     "pi",