localpi 0.4.0 → 0.5.0

package/README.md

@@ -1,10 +1,10 @@
 # localpi
 
-Localpi is a local Pi launcher for open-weight models.
+Localpi is a Swiss army knife for running Pi with local inference engines.
 
 By default, Localpi discovers available local providers, lets you choose when more than one model is loaded, points Pi at the selected model, and writes Pi config for the other discovered models so `/model` can switch among them during the session.
 
-Localpi supports LM Studio, vLLM, custom OpenAI-compatible servers, and an optional managed `llama-server` fallback.
+Localpi is meant to be the practical bridge from Pi to local inference stacks such as llama.cpp/`llama-server`, vLLM, SGLang, LM Studio, Ollama, and custom provider endpoints.
 
 Localpi is intentionally generic. It does not contain classifier prompts, dataset workflows, GitHub routing logic, or final-schema output machinery. Structured classifier runs belong in caller tools such as `localpager-agent`.
 

package/dist/src/pi/app.js

@@ -4,6 +4,18 @@ const localpiAppIdentity = {
     name: "localpi",
     version: localpiVersion
 };
+const demoLaunchOverrideBooleanFlags = new Set([
+    "--no-tools",
+    "-nt",
+    "--no-builtin-tools",
+    "-nbt",
+    "--approve",
+    "-a",
+    "--no-approve",
+    "-na"
+]);
+const demoLaunchOverrideValueFlags = new Set(["--tools", "-t", "--exclude-tools", "-xt"]);
+const demoLaunchOverrideEqualsFlags = ["--tools=", "--exclude-tools="];
 export function createLocalpiAppDefinition(options, connection, extensions) {
     return {
         ...localpiAppIdentity,
@@ -22,9 +34,37 @@ function appDirectories(options) {
 function piCommand(options) {
     return {
         piCommand: options.piCommand,
-        forwardedArgs: options.forwardedArgs
+        forwardedArgs: options.demo ? demoForwardedArgs(options.forwardedArgs) : options.forwardedArgs
     };
 }
+function demoForwardedArgs(args) {
+    return [...withoutConflictingDemoFlags(args), "--no-tools", "--no-approve"];
+}
+function withoutConflictingDemoFlags(args) {
+    const filtered = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === undefined) {
+            continue;
+        }
+        if (isDemoLaunchOverrideFlag(arg)) {
+            if (isValueFlag(arg) && !arg.includes("=")) {
+                index += 1;
+            }
+            continue;
+        }
+        filtered.push(arg);
+    }
+    return filtered;
+}
+function isDemoLaunchOverrideFlag(arg) {
+    return (demoLaunchOverrideBooleanFlags.has(arg) ||
+        isValueFlag(arg) ||
+        demoLaunchOverrideEqualsFlags.some((flag) => arg.startsWith(flag)));
+}
+function isValueFlag(arg) {
+    return demoLaunchOverrideValueFlags.has(arg);
+}
 function runtimeSelection(options, connection) {
     const selection = {
         providers: providersForConnection(options, connection),

package/dist/src/pi/extension-sources/demo-mode.js

@@ -1,29 +1,67 @@
 export function demoModeExtensionSource(prompts) {
     const initialPromptSource = JSON.stringify(prompts.initial);
     const followupPromptSource = JSON.stringify(prompts.followup);
-    return `import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+    return `import type { ExtensionAPI, ExtensionContext, TurnEndEvent } from "@earendil-works/pi-coding-agent";
 
 const initialPrompt = ${initialPromptSource};
 const followupPrompt = ${followupPromptSource};
+const compactAtContextPercent = 70;
+const demoCompactionInstructions = [
+  "Preserve the demo narrative state, named entities, current setting,",
+  "unresolved plot threads, and latest user direction.",
+  "Keep the summary concise so the story can continue after compaction."
+].join(" ");
 
 export default function localpiDemoMode(pi: ExtensionAPI): void {
   let started = false;
   let stopped = false;
+  let compacting = false;
 
-  pi.on("session_start", (event, ctx) => {
-    if (started || stopped || event.reason !== "startup" || ctx.mode !== "tui") {
-      return;
-    }
-    started = true;
+  function queueInitialPrompt(): void {
     queueMicrotask(() => {
       if (!stopped) {
         pi.sendUserMessage(initialPrompt);
       }
     });
+  }
+
+  function queueFollowup(): void {
+    queueMicrotask(() => {
+      if (!stopped && !compacting) {
+        pi.sendUserMessage(followupPrompt, { deliverAs: "followUp" });
+      }
+    });
+  }
+
+  function compactThenFollowup(ctx: ExtensionContext): void {
+    if (compacting) {
+      return;
+    }
+    compacting = true;
+    ctx.compact({
+      customInstructions: demoCompactionInstructions,
+      onComplete: () => {
+        compacting = false;
+        queueFollowup();
+      },
+      onError: (error) => {
+        compacting = false;
+        stopped = true;
+        ctx.ui.notify("Demo compaction failed: " + error.message, "error");
+      }
+    });
+  }
+
+  pi.on("session_start", (event, ctx) => {
+    if (started || stopped || event.reason !== "startup" || ctx.mode !== "tui") {
+      return;
+    }
+    started = true;
+    queueInitialPrompt();
   });
 
   pi.on("turn_end", (event, ctx) => {
-    if (!started || stopped || ctx.mode !== "tui") {
+    if (!started || stopped || compacting || ctx.mode !== "tui") {
       return;
     }
     if (event.message.role !== "assistant") {
@@ -37,16 +75,36 @@ export default function localpiDemoMode(pi: ExtensionAPI): void {
       case "toolUse":
         return;
     }
-    queueMicrotask(() => {
-      if (!stopped) {
-        pi.sendUserMessage(followupPrompt, { deliverAs: "followUp" });
-      }
-    });
+    if (shouldCompactBeforeFollowup(event, ctx)) {
+      compactThenFollowup(ctx);
+      return;
+    }
+    queueFollowup();
   });
 
   pi.on("session_shutdown", () => {
     stopped = true;
   });
 }
+
+function shouldCompactBeforeFollowup(event: TurnEndEvent, ctx: ExtensionContext): boolean {
+  const contextPercent = currentContextPercent(event, ctx);
+  return contextPercent !== undefined && contextPercent >= compactAtContextPercent;
+}
+
+function currentContextPercent(event: TurnEndEvent, ctx: ExtensionContext): number | undefined {
+  const usage = ctx.getContextUsage();
+  if (usage?.percent !== undefined && usage.percent !== null) {
+    return usage.percent;
+  }
+  if (event.message.role !== "assistant") {
+    return undefined;
+  }
+  const contextWindow = ctx.model?.contextWindow;
+  if (contextWindow === undefined || contextWindow <= 0) {
+    return undefined;
+  }
+  return (event.message.usage.totalTokens / contextWindow) * 100;
+}
 `;
 }

package/dist/src/pi/extension-sources/token-status.js

@@ -11,6 +11,7 @@ type Usage = {
 
 type TurnState = {
   startedAt: number;
+  firstOutputAt?: number;
   outputText: string;
   estimatedOutputTokens: number;
   lastStatusAt: number;
@@ -33,6 +34,7 @@ export default function localpiTokenStatus(pi: ExtensionAPI): void {
     if (!ctx.hasUI || state === undefined) {
       return;
     }
+    const now = Date.now();
     const update = textUpdateFromUnknown(event.assistantMessageEvent ?? event.message ?? event);
     if (update.kind === "delta") {
       state.outputText += update.text;
@@ -40,11 +42,14 @@ export default function localpiTokenStatus(pi: ExtensionAPI): void {
       state.outputText = update.text;
     }
     state.estimatedOutputTokens = Math.ceil(state.outputText.length / 4);
-    if (Date.now() - state.lastStatusAt < 250) {
+    if (state.firstOutputAt === undefined && state.outputText.length > 0) {
+      state.firstOutputAt = now;
+    }
+    if (now - state.lastStatusAt < 250) {
       return;
     }
-    state.lastStatusAt = Date.now();
-    ctx.ui.setStatus("localpi-perf", ctx.ui.theme.fg("dim", statusText(state)));
+    state.lastStatusAt = now;
+    ctx.ui.setStatus("localpi-perf", ctx.ui.theme.fg("dim", statusText(state, now)));
   });
 
   pi.on("turn_end", (event, ctx) => {
@@ -65,7 +70,10 @@ export default function localpiTokenStatus(pi: ExtensionAPI): void {
     const input = usage?.input ?? 0;
     const cacheRead = usage?.cacheRead ?? 0;
     const cacheWrite = usage?.cacheWrite ?? 0;
-    const elapsedSeconds = elapsed(state);
+    const now = Date.now();
+    const elapsedSeconds = elapsed(state, now);
+    const decodeSeconds = generationElapsed(state, now);
+    const prefillText = prefillStatusText(state, input, cacheWrite);
     const context = ctx.getContextUsage();
     const contextText =
       context && context.percent !== null
@@ -77,7 +85,8 @@ export default function localpiTokenStatus(pi: ExtensionAPI): void {
       ctx.ui.theme.fg(
         "dim",
         [
-          \`\${(output / elapsedSeconds).toFixed(1)} tok/s\`,
+          \`gen \${(output / decodeSeconds).toFixed(1)} tok/s\`,
+          prefillText,
           \`out \${output}\`,
           \`in \${input}\`,
           cacheRead > 0 ? \`cache \${cacheRead}\` : undefined,
@@ -98,13 +107,48 @@ export default function localpiTokenStatus(pi: ExtensionAPI): void {
   });
 }
 
-function statusText(state: TurnState): string {
-  const elapsedSeconds = elapsed(state);
-  return \`\${(state.estimatedOutputTokens / elapsedSeconds).toFixed(1)} tok/s | out ~\${state.estimatedOutputTokens} | \${elapsedSeconds.toFixed(1)}s\`;
+function statusText(state: TurnState, now: number): string {
+  const elapsedSeconds = elapsed(state, now);
+  if (state.firstOutputAt === undefined) {
+    return \`prefill \${elapsedSeconds.toFixed(1)}s | out ~\${state.estimatedOutputTokens}\`;
+  }
+  const decodeSeconds = generationElapsed(state, now);
+  const prefillSeconds = secondsBetween(state.startedAt, state.firstOutputAt);
+  return [
+    \`gen \${(state.estimatedOutputTokens / decodeSeconds).toFixed(1)} tok/s\`,
+    \`out ~\${state.estimatedOutputTokens}\`,
+    \`prefill \${prefillSeconds.toFixed(1)}s\`,
+    \`total \${elapsedSeconds.toFixed(1)}s\`
+  ].join(" | ");
+}
+
+function prefillStatusText(
+  state: TurnState,
+  input: number,
+  cacheWrite: number
+): string | undefined {
+  const tokens = prefillTokenCount(input, cacheWrite);
+  if (state.firstOutputAt === undefined || tokens <= 0) {
+    return undefined;
+  }
+  const seconds = secondsBetween(state.startedAt, state.firstOutputAt);
+  return \`prefill \${(tokens / seconds).toFixed(1)} tok/s\`;
+}
+
+function prefillTokenCount(input: number, cacheWrite: number): number {
+  return Math.max(input + cacheWrite, 0);
+}
+
+function generationElapsed(state: TurnState, now: number): number {
+  return secondsBetween(state.firstOutputAt ?? state.startedAt, now);
+}
+
+function elapsed(state: TurnState, now: number): number {
+  return secondsBetween(state.startedAt, now);
 }
 
-function elapsed(state: TurnState): number {
-  return Math.max((Date.now() - state.startedAt) / 1000, 0.001);
+function secondsBetween(start: number, end: number): number {
+  return Math.max((end - start) / 1000, 0.001);
 }
 
 type TextUpdate = {

package/docs/runtime-specification.md

@@ -150,7 +150,7 @@ session dir: ~/.local/state/localpi/sessions
 Localpi installs two default extensions:
 
 - tool approval gate: ask before each tool call, and tell the model clearly when a tool call was blocked
-- token status: show live output token estimate while streaming and final exact token stats when usage data is available
+- token status: show live generation speed while streaming, then final prefill and generation rates when usage data is available
 
 ## System Prompt
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "localpi",
-  "version": "0.4.0",
-  "description": "Pi-compatible local model launcher with managed llama-server support.",
+  "version": "0.5.0",
+  "description": "Swiss army knife for running Pi with local inference engines.",
   "type": "module",
   "license": "MIT",
   "repository": {