agent-sh 0.15.7 → 0.15.8

package/dist/agent/agent-loop.d.ts

@@ -84,6 +84,9 @@ export declare class AgentLoop implements AgentBackend {
     kill(): void;
     private cancel;
     private reasoningParams;
+    /** Resume-stable conversation id from the frontend (e.g. ashi); undefined
+     *  when the frontend tracks no session. */
+    private currentSessionId;
     private resolveEndpoint;
     private pullModels;
     private emitIdentity;

package/dist/agent/agent-loop.js

@@ -390,6 +390,17 @@ export class AgentLoop {
         const effort = this.thinkingLevel === "xhigh" ? "high" : this.thinkingLevel;
         return { reasoning_effort: effort };
     }
+    /** Resume-stable conversation id from the frontend (e.g. ashi); undefined
+     *  when the frontend tracks no session. */
+    currentSessionId() {
+        try {
+            const id = this.handlers.call("session:current-id");
+            return typeof id === "string" && id ? id : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
     resolveEndpoint(m) {
         try {
             return this.handlers.call("agent:resolve-endpoint", { provider: m.provider, id: m.id });
@@ -1251,7 +1262,12 @@ export class AgentLoop {
             ...this.reasoningParams(),
         };
         this.bus.emit("llm:request", requestParams);
-        const stream = await this.llmClient.stream({ ...requestParams, signal });
+        const headers = this.activeEndpoint?.buildRequestHeaders?.({ sessionId: this.currentSessionId() });
+        const stream = await this.llmClient.stream({
+            ...requestParams,
+            signal,
+            ...(headers && Object.keys(headers).length ? { headers } : {}),
+        });
         try {
             for await (const chunk of stream) {
                 if (signal.aborted)

package/dist/agent/events.d.ts

@@ -21,6 +21,9 @@ declare module "../core/event-bus.js" {
             id: string;
             reasoningParams?: (level: string, model?: string) => Record<string, unknown>;
             cacheTokens?: (usage: Record<string, unknown>) => number | undefined;
+            requestHeaders?: (info: {
+                sessionId?: string;
+            }) => Record<string, string>;
         };
         "agent:models-changed": Record<string, never>;
         "config:switch-provider": {

package/dist/agent/host-types.d.ts

@@ -85,6 +85,9 @@ export interface ModelEndpoint {
     baseURL?: string;
     buildReasoningParams?: (level: string) => Record<string, unknown>;
     extractCachedTokens?: (usage: Record<string, unknown>) => number | undefined;
+    buildRequestHeaders?: (info: {
+        sessionId?: string;
+    }) => Record<string, string>;
 }
 /**
  * Capabilities the agent host adds on top of CoreContext. Only available
@@ -100,6 +103,9 @@ export interface AgentSurface {
         configure: (id: string, opts: {
             reasoningParams?: (level: string, model?: string) => Record<string, unknown>;
             cacheTokens?: (usage: Record<string, unknown>) => number | undefined;
+            requestHeaders?: (info: {
+                sessionId?: string;
+            }) => Record<string, string>;
         }) => void;
     };
     registerTool: (tool: ToolDefinition) => void;

package/dist/agent/index.js

@@ -105,6 +105,7 @@ export default function agentBackend(ctx) {
         return hook ? (level) => hook(level, model) : defaultReasoningBuilder;
     };
     const bindCacheTokens = (shapeId) => providerHooks.get(shapeId)?.cacheTokens ?? defaultCacheTokens;
+    const bindRequestHeaders = (shapeId) => providerHooks.get(shapeId)?.requestHeaders;
     const agentSurface = {
         llm: createLlmFacade({ list: ctx.list, call: ctx.call }),
         providers: {
@@ -322,6 +323,7 @@ export default function agentBackend(ctx) {
             baseURL: p.baseURL,
             buildReasoningParams: bindReasoning(shapeId, modelId),
             extractCachedTokens: bindCacheTokens(shapeId),
+            buildRequestHeaders: bindRequestHeaders(shapeId),
         };
     };
     ctx.define("agent:get-models", () => buildModels());
@@ -365,12 +367,14 @@ export default function agentBackend(ctx) {
             bus.emit("config:switch-model", { id: pendingModel, provider: pendingProvider });
         }
     });
-    bus.on("provider:configure", ({ id, reasoningParams, cacheTokens }) => {
+    bus.on("provider:configure", ({ id, reasoningParams, cacheTokens, requestHeaders }) => {
         const prev = providerHooks.get(id) ?? {};
         if (reasoningParams !== undefined)
             prev.reasoningParams = reasoningParams;
         if (cacheTokens !== undefined)
             prev.cacheTokens = cacheTokens;
+        if (requestHeaders !== undefined)
+            prev.requestHeaders = requestHeaders;
         providerHooks.set(id, prev);
     });
     bus.on("core:extensions-loaded", ({ names }) => {

package/dist/agent/llm-client.d.ts

@@ -39,6 +39,8 @@ export type StreamOpts = {
     model?: string;
     max_tokens?: number;
     signal?: AbortSignal;
+    /** Per-request transport headers, forwarded to the SDK (not request body). */
+    headers?: Record<string, string>;
 } & Record<string, unknown>;
 export type CompleteOpts = {
     messages: ChatCompletionMessageParam[];

package/dist/agent/llm-client.js

@@ -43,7 +43,7 @@ export class LlmClient {
         this.model = newConfig.model;
     }
     stream(opts) {
-        const { signal, messages, tools, model, max_tokens, ...rest } = opts;
+        const { signal, headers, messages, tools, model, max_tokens, ...rest } = opts;
         const body = {
             ...rest,
             model: model ?? this.model,
@@ -53,7 +53,7 @@ export class LlmClient {
             stream: true,
             stream_options: { include_usage: true },
         };
-        return this.client.chat.completions.create(body, { signal });
+        return this.client.chat.completions.create(body, { signal, headers });
     }
     async complete(opts) {
         const { messages, model, max_tokens, ...rest } = opts;

package/dist/agent/providers/openrouter.js

@@ -24,7 +24,17 @@ function toModalities(input) {
 }
 export default function activate(ctx) {
     const apiKey = resolveApiKey("openrouter").key;
-    ctx.agent.providers.configure("openrouter", { reasoningParams: buildReasoningParams });
+    ctx.agent.providers.configure("openrouter", {
+        reasoningParams: buildReasoningParams,
+        // x-session-id pins sticky provider routing across turns so prompt caches
+        // stay warm even when compaction rewrites the opening messages.
+        requestHeaders: ({ sessionId }) => {
+            const headers = {};
+            if (sessionId)
+                headers["x-session-id"] = sessionId;
+            return headers;
+        },
+    });
     ctx.agent.providers.register({
         id: "openrouter",
         apiKey: apiKey ?? undefined,

package/dist/shell/strategies/bash.js

@@ -40,8 +40,16 @@ export const bashStrategy = {
             '  [[ $__agent_sh_preexec_ran == 1 ]] && return',
             '  [[ -n $COMP_LINE ]] && return',
             "  __agent_sh_preexec_ran=1",
-            "  local this_cmd",
-            `  this_cmd=$(HISTTIMEFORMAT='' builtin history 1 | command sed 's/^ *[0-9]* *//')`,
+            "  local this_cmd hist_cmd",
+            `  hist_cmd=$(HISTTIMEFORMAT='' builtin history 1 | command sed 's/^ *[0-9]* *//')`,
+            "  # history 1 carries the full typed line but goes stale when the user's",
+            "  # PROMPT_COMMAND reloads history (history -c/-r). Trust it only when it",
+            "  # matches the command bash is about to run; else use $BASH_COMMAND.",
+            '  if [[ -n $hist_cmd && $hist_cmd == "$BASH_COMMAND"* ]]; then',
+            "    this_cmd=$hist_cmd",
+            "  else",
+            "    this_cmd=$BASH_COMMAND",
+            "  fi",
             `  printf '\\e]9997;${instanceTag};%s\\a' "$this_cmd"`,
             "}",
             "trap '__agent_sh_emit_preexec' DEBUG",

package/examples/extensions/ashi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guanyilun/ashi",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "Ash in an interactive TUI — agent-sh's built-in agent without the shell underneath",
   "type": "module",
   "main": "dist/cli.js",

package/examples/extensions/ashi/src/chat/assistant.ts

@@ -38,7 +38,9 @@ export class AssistantMessage {
     if (this.buffer === "") this.buffer = " ";
     const blocks = this.transform([{ type: "text", text: this.buffer }]);
     if (blocks.every((b) => b.type === "text")) {
-      this.md.setText(stripTrailing(this.buffer));
+      // Render the transformed text, not the raw buffer — transforms may rewrite
+      // content in place (e.g. inline-image sentinels) while staying all-text.
+      this.md.setText(stripTrailing(blocks.map((b) => (b.type === "text" ? b.text : "")).join("")));
       return;
     }
     this.rebuild(blocks);

package/examples/extensions/ashi/src/cli.ts

@@ -34,6 +34,7 @@ import { registerCapture, type Capture } from "./capture.js";
 import { registerRenderDefaults } from "./hooks.js";
 import { registerDefaultSchemaRenderers } from "./default-schema-renderers.js";
 import { createPiTuiRenderer } from "./renderers/pi-tui/index.js";
+import { registerInlineImage, supportsInlineImages } from "./renderers/pi-tui/inline-image.js";
 import type { Renderer } from "./renderer.js";
 import { loadRendererPreference } from "./display-config.js";
 import { applyOutputMode } from "./terminal-mode.js";
@@ -177,6 +178,8 @@ async function main(): Promise<void> {
 
   const ctx = core.extensionContext({ quit: cleanup });
 
+  ctx.define("session:current-id", () => store.current().id);
+
   activateAgent(ctx);
   activateShellContext(ctx);
   await loadBuiltinExtensions(ctx);
@@ -238,6 +241,11 @@ async function main(): Promise<void> {
   registerRenderDefaults(ctx, renderer);
   registerDefaultSchemaRenderers(ctx);
 
+  // Handler presence is how producers detect that inline images are available.
+  if (rendererName === "pi-tui" && supportsInlineImages()) {
+    ctx.define("ashi:inline-image:register", (png: Buffer) => registerInlineImage(png));
+  }
+
   ctx.advise("system-prompt:frontend", (next) => {
     const base = (next() as string) ?? "";
     return base ? `${base}\n\n${ASHI_SURFACE}` : ASHI_SURFACE;

package/examples/extensions/ashi/src/frontend.ts

@@ -399,7 +399,7 @@ export function mountAshi(
       app.requestRender();
       return;
     }
-    pendingUserShell.push({ private: !!opts?.private });
+    pendingUserShell.push({ private: !!opts?.private, command: line });
     if (opts?.private) bus.emit("shell:user-exec-exclude-next", {});
     bus.emit("shell:pty-write", { data: line + "\n" });
   };
@@ -816,12 +816,13 @@ export function mountAshi(
   bus.on("shell:foreground-busy", ({ busy }) => { shellForegroundBusy = busy; });
 
   let activeUserShell: { pair: ToolPair; command: string; isPrivate: boolean } | null = null;
-  bus.on("shell:command-start", ({ command }) => {
+  bus.on("shell:command-start", () => {
     if (agentShellActive) return;
     const intent = pendingUserShell.consume();
     if (!intent) return;
     finalizeThinking();
     if (activeAssistant) { activeAssistant.finalize(); activeAssistant = null; }
+    const command = intent.command;
     const isPrivate = intent.private;
     const name = isPrivate ? "user_bash_private" : "user_bash";
     const pair = renderToolPair({
@@ -861,7 +862,7 @@ export function mountAshi(
     // Drain shell queue before queries so its output lands in the next turn's <shell_events>.
     while (queuedShellLines.length > 0) {
       const item = queuedShellLines.shift()!;
-      pendingUserShell.push({ private: item.private });
+      pendingUserShell.push({ private: item.private, command: item.line });
       if (item.private) bus.emit("shell:user-exec-exclude-next", {});
       bus.emit("shell:pty-write", { data: item.line + "\n" });
     }

package/examples/extensions/ashi/src/renderers/pi-tui/inline-image.ts

@@ -0,0 +1,145 @@
+/**
+ * Inline images in markdown text via the kitty/Ghostty Unicode placeholder
+ * protocol. The image is transmitted out-of-band (cursor-neutral); the frame
+ * carries only `cols` width-1 placeholder cells, so the renderer's wrap/measure
+ * math is unaffected and the line is never treated as an image line. kitty-only.
+ */
+import {
+  allocateImageId,
+  getCapabilities,
+  getCellDimensions,
+  getImageDimensions,
+} from "@earendil-works/pi-tui";
+
+export const SENTINEL_RE = /\x01LI:(\d+)\x01/g;
+export const PLACEHOLDER = String.fromCodePoint(0x10eeee);
+
+// kitty rowcolumn-diacritics: the Nth entry encodes row/column index N
+// (gen/rowcolumn-diacritics.txt in the kitty source).
+const DIACRITICS = [0x0305,0x030D,0x030E,0x0310,0x0312,0x033D,0x033E,0x033F,0x0346,0x034A,0x034B,0x034C,0x0350,0x0351,0x0352,0x0357,0x035B,0x0363,0x0364,0x0365,0x0366,0x0367,0x0368,0x0369,0x036A,0x036B,0x036C,0x036D,0x036E,0x036F,0x0483,0x0484,0x0485,0x0486,0x0487,0x0592,0x0593,0x0594,0x0595,0x0597,0x0598,0x0599,0x059C,0x059D,0x059E,0x059F,0x05A0,0x05A1,0x05A8,0x05A9,0x05AB,0x05AC,0x05AF,0x05C4,0x0610,0x0611,0x0612,0x0613,0x0614,0x0615,0x0616,0x0617,0x0657,0x0658,0x0659,0x065A,0x065B,0x065D,0x065E,0x06D6,0x06D7,0x06D8,0x06D9,0x06DA,0x06DB,0x06DC,0x06DF,0x06E0,0x06E1,0x06E2,0x06E4,0x06E7,0x06E8,0x06EB,0x06EC,0x0730,0x0732,0x0733,0x0735,0x0736,0x073A,0x073D,0x073F,0x0740,0x0741,0x0743,0x0745,0x0747,0x0749,0x074A,0x07EB,0x07EC,0x07ED,0x07EE,0x07EF,0x07F0,0x07F1,0x07F3,0x0816,0x0817,0x0818,0x0819,0x081B,0x081C,0x081D,0x081E,0x081F,0x0820,0x0821,0x0822,0x0823,0x0825,0x0826,0x0827,0x0829,0x082A,0x082B,0x082C,0x082D,0x0951,0x0953,0x0954,0x0F82,0x0F83,0x0F86,0x0F87,0x135D,0x135E,0x135F,0x17DD,0x193A,0x1A17,0x1A75,0x1A76,0x1A77,0x1A78,0x1A79,0x1A7A,0x1A7B,0x1A7C,0x1B6B,0x1B6D,0x1B6E,0x1B6F,0x1B70,0x1B71,0x1B72,0x1B73,0x1CD0,0x1CD1,0x1CD2,0x1CDA,0x1CDB,0x1CE0,0x1DC0,0x1DC1,0x1DC3,0x1DC4,0x1DC5,0x1DC6,0x1DC7,0x1DC8,0x1DC9,0x1DCB,0x1DCC,0x1DD1,0x1DD2,0x1DD3,0x1DD4,0x1DD5,0x1DD6,0x1DD7,0x1DD8,0x1DD9,0x1DDA,0x1DDB,0x1DDC,0x1DDD,0x1DDE,0x1DDF,0x1DE0,0x1DE1,0x1DE2,0x1DE3,0x1DE4,0x1DE5,0x1DE6,0x1DFE,0x20D0,0x20D1,0x20D4,0x20D5,0x20D6,0x20D7,0x20DB,0x20DC,0x20E1,0x20E7,0x20E9,0x20F0,0x2CEF,0x2CF0,0x2CF1,0x2DE0,0x2DE1,0x2DE2,0x2DE3,0x2DE4,0x2DE5,0x2DE6,0x2DE7,0x2DE8,0x2DE9,0x2DEA,0x2DEB,0x2DEC,0x2DED,0x2DEE,0x2DEF,0x2DF0,0x2DF1,0x2DF2,0x2DF3,0x2DF4,0x2DF5,0x2DF6,0x2DF7,0x2DF8,0x2DF9,0x2DFA,0x2DFB,0x2DFC,0x2DFD,0x2DFE,0x2DFF,0xA66F,0xA67C,0xA67D,0xA6F0,0xA6F1,0xA8E0,0xA8E1,0xA8E2,0xA8E3,0xA8E4,0xA8E5,0xA8E6,0xA8E7,0xA8E8,0xA8E9,0xA8EA,0xA8EB,0xA8EC,0xA8ED,0xA8EE,0xA8EF,0xA8F0,0xA8F1,0xAAB0,0xAAB2,0xAAB3,0xAAB7,0xAAB8,0xAABE,0xAABF,0xAAC1,0xFE20,0xFE21,0xFE22,0xFE23,0xFE24,0xFE25,0xFE26,0x10A0F,0x10A38,0x1D185,0x1D186,0x1D187,0x1D188,0x1D189,0x1D1AA,0x1D1AB,0x1D1AC,0x1D1AD,0x1D242,0x1D243,0x1D244];
+
+const ESC = "\x1b";
+const diacritic = (i: number): string =>
+  String.fromCodePoint(DIACRITICS[Math.min(i, DIACRITICS.length - 1)]!);
+
+interface Entry {
+  base64: string;
+  widthPx: number;
+  heightPx: number;
+  transmitted: boolean;
+  placedCols: number;
+}
+
+const registry = new Map<number, Entry>();
+
+export function supportsInlineImages(): boolean {
+  return getCapabilities().images === "kitty";
+}
+
+export function registerInlineImage(png: Buffer): number | null {
+  if (!supportsInlineImages()) return null;
+  const base64 = png.toString("base64");
+  const dims = getImageDimensions(base64, "image/png");
+  if (!dims || dims.heightPx <= 0) return null;
+  const id = allocateImageId();
+  registry.set(id, { base64, widthPx: dims.widthPx, heightPx: dims.heightPx, transmitted: false, placedCols: 0 });
+  return id;
+}
+
+const maxInlineCols = (): number => Math.max(8, (process.stdout.columns ?? 80) - 4);
+
+export function inlineCols(id: number, maxCols = maxInlineCols()): number | null {
+  const e = registry.get(id);
+  if (!e) return null;
+  const cell = getCellDimensions();
+  const cols = Math.round((e.widthPx / e.heightPx) * (cell.heightPx / cell.widthPx));
+  // Column index is carried by a diacritic, so cols can't exceed the table.
+  return Math.max(1, Math.min(maxCols, DIACRITICS.length, cols));
+}
+
+// Transmits once, then re-places only when cols changes (resize). `write` must
+// target the same stream as the composed frame so the data lands before the cells.
+export function emitInlineImage(id: number, cols: number, write: (s: string) => void): void {
+  const e = registry.get(id);
+  if (!e) return;
+  if (!e.transmitted) {
+    e.transmitted = true;
+    e.placedCols = cols;
+    const b64 = e.base64;
+    const CHUNK = 4096;
+    for (let i = 0; i < b64.length; i += CHUNK) {
+      const chunk = b64.slice(i, i + CHUNK);
+      const last = i + CHUNK >= b64.length;
+      write(
+        i === 0
+          ? `${ESC}_Gq=2,a=T,U=1,f=100,t=d,i=${id},c=${cols},r=1,m=${last ? 0 : 1};${chunk}${ESC}\\`
+          : `${ESC}_Gq=2,m=${last ? 0 : 1};${chunk}${ESC}\\`,
+      );
+    }
+  } else if (e.placedCols !== cols) {
+    e.placedCols = cols;
+    write(`${ESC}_Gq=2,a=p,U=1,i=${id},c=${cols},r=1${ESC}\\`);
+  }
+}
+
+// Each cell encodes the id's low 24 bits in the fg colour and its high byte in the
+// third diacritic (row, column, id-high) — allocateImageId() ids use all 32 bits.
+// `colStart` offsets the column index so an image split across lines (wrap) keeps
+// continuous columns instead of repeating its left edge.
+export function inlinePlaceholder(id: number, count: number, colStart = 0): string {
+  const hi = diacritic((id >> 24) & 255);
+  let s = `${ESC}[38;2;${(id >> 16) & 255};${(id >> 8) & 255};${id & 255}m`;
+  for (let j = 0; j < count; j++) s += PLACEHOLDER + diacritic(0) + diacritic(colStart + j) + hi;
+  return s + `${ESC}[39m`;
+}
+
+export interface InlineItem {
+  id: number;
+  cols: number;
+}
+
+// Repaint the reserved PLACEHOLDER runs as real kitty placeholder cells. Cells are
+// partitioned by each image's reserved `cols` rather than by contiguous run, so
+// adjacent images (`$a$$b$` → one fused run) and an image the wrapper split across
+// lines both keep their ids aligned. `transmit` fires once per image, when its
+// first cell is placed. Pure apart from the injected `transmit` callback.
+export function paintInlineImages(
+  lines: string[],
+  items: InlineItem[],
+  transmit: (id: number, cols: number) => void,
+): string[] {
+  if (items.length === 0) return lines;
+  let k = 0; // index of the image currently being placed
+  let placed = 0; // cells of image k already emitted across prior lines
+  return lines.map((line) => {
+    if (k >= items.length || !line.includes(PLACEHOLDER)) return line;
+    let out = "";
+    let i = 0;
+    while (i < line.length) {
+      const ch = String.fromCodePoint(line.codePointAt(i)!);
+      if (ch === PLACEHOLDER && k < items.length) {
+        const item = items[k]!;
+        let count = 0;
+        while (
+          i < line.length &&
+          String.fromCodePoint(line.codePointAt(i)!) === PLACEHOLDER &&
+          placed + count < item.cols
+        ) {
+          count++;
+          i += PLACEHOLDER.length;
+        }
+        if (placed === 0) transmit(item.id, item.cols);
+        out += inlinePlaceholder(item.id, count, placed);
+        placed += count;
+        if (placed >= item.cols) {
+          k++;
+          placed = 0;
+        }
+      } else {
+        out += ch;
+        i += ch.length;
+      }
+    }
+    return out;
+  });
+}

package/examples/extensions/ashi/src/renderers/pi-tui/nodes.ts

@@ -14,6 +14,14 @@ import {
 } from "@earendil-works/pi-tui";
 import { theme } from "../../theme.js";
 import { markdownTheme } from "./theme-adapters.js";
+import {
+  emitInlineImage,
+  inlineCols,
+  paintInlineImages,
+  PLACEHOLDER,
+  SENTINEL_RE,
+  type InlineItem,
+} from "./inline-image.js";
 import type {
   ContainerView,
   MarkdownOptions,
@@ -118,6 +126,48 @@ class ZonedMarkdown extends Markdown {
   }
 }
 
+// Each sentinel becomes a bare run of `cols` placeholder cells so the wrapper
+// reserves the right width; render() later paints the image into that run.
+// Exported for tests: with no sentinels (latex-images off / non-kitty terminal,
+// where the sentinel producer never runs) this is a pass-through.
+export function reserveSentinels(full: string): { display: string; items: InlineItem[] } {
+  const items: InlineItem[] = [];
+  const display = full.replace(SENTINEL_RE, (_m, idStr) => {
+    const cols = inlineCols(Number(idStr));
+    if (cols === null) return "";
+    items.push({ id: Number(idStr), cols });
+    return PLACEHOLDER.repeat(cols);
+  });
+  return { display, items };
+}
+
+function injectInlineImages(lines: string[], items: InlineItem[]): string[] {
+  const write = (s: string): boolean => process.stdout.write(s);
+  return paintInlineImages(lines, items, (id, cols) => emitInlineImage(id, cols, write));
+}
+
+type MarkdownCtor = new (...args: ConstructorParameters<typeof Markdown>) => Markdown;
+
+// Subclass that flows inline images where the text carries sentinels; a no-op
+// superset of the base when none are present.
+function withInlineImages<T extends MarkdownCtor>(Base: T): T {
+  class InlineImageMarkdown extends (Base as MarkdownCtor) {
+    private inlineItems: InlineItem[] = [];
+    override setText(full: string): void {
+      const { display, items } = reserveSentinels(full);
+      this.inlineItems = items;
+      super.setText(display);
+    }
+    override render(width: number): string[] {
+      return injectInlineImages(super.render(width), this.inlineItems);
+    }
+  }
+  return InlineImageMarkdown as unknown as T;
+}
+
+const InlineMarkdown = withInlineImages(Markdown);
+const InlineZonedMarkdown = withInlineImages(ZonedMarkdown);
+
 class FooterSlot extends Container {
   constructor(private readonly hasContentAbove: () => boolean) {
     super();
@@ -157,7 +207,7 @@ export function createNodes(opts: { imageScale?: number } = {}): RenderNodes {
         opts?.color || opts?.bgColor
           ? { ...(opts.color ? { color: opts.color } : {}), ...(opts.bgColor ? { bgColor: opts.bgColor } : {}) }
           : undefined;
-      const Ctor = opts?.osc133Zones ? ZonedMarkdown : Markdown;
+      const Ctor = opts?.osc133Zones ? InlineZonedMarkdown : InlineMarkdown;
       const md = new Ctor("", opts?.paddingX ?? 0, opts?.paddingY ?? 0, markdownTheme(), colorOpts);
       const view: MarkdownView = {
         node: asNode(md),

package/examples/extensions/ashi/src/user-shell-intents.ts

@@ -1,7 +1,10 @@
 /** Pending intents for ashi-issued shell pty-writes. shell:command-start fires
- *  for any OSC 9997 — orphans (bash DEBUG-trap noise) are dropped on consume. */
+ *  for any OSC 9997 — orphans (bash DEBUG-trap noise) are dropped on consume.
+ *  Carries the command ashi sent so the rendered label is the exact text we
+ *  wrote to the pty, not whatever the shell echoes back. */
 export interface UserShellIntent {
   private: boolean;
+  command: string;
 }
 
 export class UserShellIntents {

package/examples/extensions/latex-images.ts

@@ -22,7 +22,10 @@ import * as path from "node:path";
 import type { ExtensionContext } from "agent-sh/types";
 
 // Settings loaded in activate() via ctx.getExtensionSettings
-let config = { dpi: 300, fgColor: "d4d4d4" };
+// inlineScale: inline math font vs ~1 em of text (1.0 ≈ text, <1 smaller).
+let config = { dpi: 300, fgColor: "d4d4d4", inlineScale: 1.0 };
+
+let magickBin: string | null = null;
 
 /** Encode PNG as iTerm2 or Kitty inline image escape sequence. */
 function encodeImage(data: Buffer): string {
@@ -56,6 +59,17 @@ $\\displaystyle ${equation}$
 \\end{document}
 `;
 
+// Inline equations: text-style (no \displaystyle) so sizing matches a text line.
+const LATEX_INLINE_TEMPLATE = (equation: string, fg: string) => `
+\\documentclass[border=1pt]{standalone}
+\\usepackage{amsmath,amssymb,amsfonts}
+\\usepackage{xcolor}
+\\begin{document}
+\\color[HTML]{${fg}}
+$ ${equation} $
+\\end{document}
+`;
+
 let tmpDir: string | null = null;
 let renderCounter = 0;
 
@@ -66,7 +80,10 @@ function ensureTmpDir(): string {
   return tmpDir;
 }
 
-function renderEquation(equation: string): Buffer | null {
+function renderEquation(
+  equation: string,
+  template: (eq: string, fg: string) => string,
+): Buffer | null {
   const dir = ensureTmpDir();
   const idx = renderCounter++;
   const texPath = path.join(dir, `eq${idx}.tex`);
@@ -74,7 +91,7 @@ function renderEquation(equation: string): Buffer | null {
   const pngPath = path.join(dir, `eq${idx}.png`);
 
   try {
-    fs.writeFileSync(texPath, LATEX_TEMPLATE(equation, config.fgColor));
+    fs.writeFileSync(texPath, template(equation, config.fgColor));
 
     execSync(
       `latex -interaction=nonstopmode -output-directory="${dir}" "${texPath}"`,
@@ -98,10 +115,50 @@ function renderEquation(equation: string): Buffer | null {
 
 const equationCache = new Map<string, Buffer | null>();
 function renderEquationCached(equation: string): Buffer | null {
-  if (!equationCache.has(equation)) {
-    equationCache.set(equation, renderEquation(equation));
+  const key = `d:${equation}`;
+  if (!equationCache.has(key)) {
+    equationCache.set(key, renderEquation(equation, LATEX_TEMPLATE));
+  }
+  return equationCache.get(key) ?? null;
+}
+
+// 1 TeX pt = 1/72.27 inch; standalone's default body font is 10pt.
+const PT_PER_INCH = 72.27;
+
+// Pad each equation's height up to a shared ~1 em reference (transparent, centered)
+// so short and tall expressions render at the same font — only their heights differ.
+// Cols are derived downstream from this padded height. No-op for already-tall content.
+function normalizeInlineHeight(buf: Buffer): Buffer {
+  if (!magickBin) return buf;
+  const w = buf.readUInt32BE(16);
+  const h = buf.readUInt32BE(20);
+  const emPx = (config.dpi * 10) / PT_PER_INCH;
+  const scale = config.inlineScale > 0 ? config.inlineScale : 1;
+  const targetH = Math.round(emPx / scale);
+  if (h >= targetH) return buf;
+  const dir = ensureTmpDir();
+  const idx = renderCounter++;
+  const inPath = path.join(dir, `pad${idx}-in.png`);
+  const outPath = path.join(dir, `pad${idx}-out.png`);
+  try {
+    fs.writeFileSync(inPath, buf);
+    execSync(
+      `${magickBin} "${inPath}" -background none -gravity center -extent ${w}x${targetH} "${outPath}"`,
+      { timeout: 10000, stdio: "pipe" },
+    );
+    return fs.readFileSync(outPath);
+  } catch {
+    return buf;
   }
-  return equationCache.get(equation) ?? null;
+}
+
+function renderInlineCached(equation: string): Buffer | null {
+  const key = `i:${equation}`;
+  if (!equationCache.has(key)) {
+    const png = renderEquation(equation, LATEX_INLINE_TEMPLATE);
+    equationCache.set(key, png ? normalizeInlineHeight(png) : null);
+  }
+  return equationCache.get(key) ?? null;
 }
 
 const EQ_DELIM = "$$";
@@ -132,6 +189,65 @@ function splitEquations(text: string): Block[] {
   return out;
 }
 
+// ── Inline math ($…$) ────────────────────────────────────────────
+
+// KaTeX-style `$…$` rules so prose/currency don't false-match: no space after the
+// opening `$`; no space before the closing `$` and no digit after it; one line; \$.
+export function matchInline(text: string, open: number): { eq: string; end: number } | null {
+  if (open + 1 >= text.length || /\s/.test(text[open + 1]!)) return null;
+  for (let j = open + 1; j < text.length; j++) {
+    const ch = text[j]!;
+    if (ch === "\n") return null;
+    if (ch === "\\") { j++; continue; }
+    if (ch !== "$") continue;
+    if (/\s/.test(text[j - 1]!)) continue;
+    if (/[0-9]/.test(text[j + 1] ?? "")) continue;
+    const eq = text.slice(open + 1, j);
+    return eq.trim() === "" ? null : { eq, end: j + 1 };
+  }
+  return null;
+}
+
+// Replace inline `$…$` with `\x01LI:<id>\x01` sentinels; leaves escapes and inline
+// code spans untouched, and falls back to literal text when register() returns null.
+export function replaceInline(text: string, register: (eq: string) => number | null): string {
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    const c = text[i]!;
+    if (c === "\\") { out += text.slice(i, i + 2); i += 2; continue; }
+    if (c === "`") {
+      // Code span: a run of N backticks closes on the next run of exactly N.
+      // An unmatched opening run is a literal backtick — keep scanning after it.
+      let n = 1;
+      while (text[i + n] === "`") n++;
+      let j = i + n;
+      let close = -1;
+      while (j < text.length) {
+        if (text[j] === "`") {
+          let m = 1;
+          while (text[j + m] === "`") m++;
+          if (m === n) { close = j; break; }
+          j += m;
+        } else j++;
+      }
+      if (close === -1) { out += text.slice(i, i + n); i += n; continue; }
+      out += text.slice(i, close + n); i = close + n; continue;
+    }
+    if (c === "$" && text[i + 1] !== "$") {
+      const m = matchInline(text, i);
+      if (m) {
+        const id = register(m.eq);
+        out += id === null ? text.slice(i, m.end) : `\x01LI:${id}\x01`;
+        i = m.end;
+        continue;
+      }
+    }
+    out += c; i++;
+  }
+  return out;
+}
+
 // ── Extension entry point ────────────────────────────────────────
 
 export default function activate(ctx: ExtensionContext) {
@@ -151,6 +267,15 @@ export default function activate(ctx: ExtensionContext) {
     return;
   }
 
+  // ImageMagick is optional; only used to shrink inline glyphs (config.inlineScale).
+  for (const bin of ["magick", "convert"]) {
+    try {
+      execSync(`${bin} --version`, { stdio: "ignore", timeout: 3000 });
+      magickBin = bin;
+      break;
+    } catch { /* not installed */ }
+  }
+
   ctx.define("latex:render-equation", (equation: string): Buffer | null => renderEquationCached(equation));
 
   if (ctx.shell) {
@@ -172,14 +297,34 @@ export default function activate(ctx: ExtensionContext) {
       ctx.call("render:image", png);
     });
   } else {
+    // Cache the id per equation so each image is registered (and transmitted) once.
+    const inlineIds = new Map<string, number>();
+    const registerInline = (eq: string): number | null => {
+      const cached = inlineIds.get(eq);
+      if (cached !== undefined) return cached;
+      const png = renderInlineCached(eq);
+      if (!png) return null;
+      const id = ctx.call("ashi:inline-image:register", png) as number | null;
+      if (typeof id === "number") inlineIds.set(eq, id);
+      return typeof id === "number" ? id : null;
+    };
+
     (bus.onPipe as unknown as (e: string, fn: (p: ContentPipe) => ContentPipe) => void)(
       "render:assistant-content",
       (payload) => {
         // Can't show images reliably → leave $$…$$ as text.
         if (!payload.images) return payload;
+        const canInline = ctx.list().includes("ashi:inline-image:register");
         return {
           ...payload,
-          blocks: payload.blocks.flatMap((b) => (b.type === "text" ? splitEquations(b.text) : [b])),
+          blocks: payload.blocks.flatMap((b) => {
+            if (b.type !== "text") return [b];
+            return splitEquations(b.text).map((blk) =>
+              blk.type === "text" && canInline
+                ? { type: "text" as const, text: replaceInline(blk.text, registerInline) }
+                : blk,
+            );
+          }),
         };
       },
     );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-sh",
-  "version": "0.15.7",
+  "version": "0.15.8",
   "description": "A composable agent runtime — pair any frontend with any agent backend over one shared extension layer",
   "type": "module",
   "workspaces": [

package/src/agent/agent-loop.ts

@@ -462,6 +462,17 @@ export class AgentLoop implements AgentBackend {
   }
 
 
+  /** Resume-stable conversation id from the frontend (e.g. ashi); undefined
+   *  when the frontend tracks no session. */
+  private currentSessionId(): string | undefined {
+    try {
+      const id = this.handlers.call("session:current-id");
+      return typeof id === "string" && id ? id : undefined;
+    } catch {
+      return undefined;
+    }
+  }
+
   private resolveEndpoint(m: Model): ModelEndpoint | undefined {
     try {
       return this.handlers.call("agent:resolve-endpoint", { provider: m.provider, id: m.id }) as ModelEndpoint | undefined;
@@ -1439,7 +1450,12 @@ export class AgentLoop implements AgentBackend {
     };
     this.bus.emit("llm:request", requestParams);
 
-    const stream = await this.llmClient.stream({ ...requestParams, signal });
+    const headers = this.activeEndpoint?.buildRequestHeaders?.({ sessionId: this.currentSessionId() });
+    const stream = await this.llmClient.stream({
+      ...requestParams,
+      signal,
+      ...(headers && Object.keys(headers).length ? { headers } : {}),
+    });
 
     try {
     for await (const chunk of stream) {

package/src/agent/events.ts

@@ -22,6 +22,7 @@ declare module "../core/event-bus.js" {
       id: string;
       reasoningParams?: (level: string, model?: string) => Record<string, unknown>;
       cacheTokens?: (usage: Record<string, unknown>) => number | undefined;
+      requestHeaders?: (info: { sessionId?: string }) => Record<string, string>;
     };
 
     "agent:models-changed": Record<string, never>;

package/src/agent/host-types.ts

@@ -93,6 +93,7 @@ export interface ModelEndpoint {
   baseURL?: string;
   buildReasoningParams?: (level: string) => Record<string, unknown>;
   extractCachedTokens?: (usage: Record<string, unknown>) => number | undefined;
+  buildRequestHeaders?: (info: { sessionId?: string }) => Record<string, string>;
 }
 
 // ── Agent-host extension surface ─────────────────────────────────
@@ -111,6 +112,7 @@ export interface AgentSurface {
     configure: (id: string, opts: {
       reasoningParams?: (level: string, model?: string) => Record<string, unknown>;
       cacheTokens?: (usage: Record<string, unknown>) => number | undefined;
+      requestHeaders?: (info: { sessionId?: string }) => Record<string, string>;
     }) => void;
   };
 

package/src/agent/index.ts

@@ -128,6 +128,7 @@ export default function agentBackend(ctx: ExtensionContext): void {
   const providerHooks = new Map<string, {
     reasoningParams?: (level: string, model?: string) => Record<string, unknown>;
     cacheTokens?: (usage: Record<string, unknown>) => number | undefined;
+    requestHeaders?: (info: { sessionId?: string }) => Record<string, string>;
   }>();
 
   // Bakes model id so ModelEndpoint.buildReasoningParams keeps its (level) signature.
@@ -139,6 +140,9 @@ export default function agentBackend(ctx: ExtensionContext): void {
   const bindCacheTokens = (shapeId: string) =>
     providerHooks.get(shapeId)?.cacheTokens ?? defaultCacheTokens;
 
+  const bindRequestHeaders = (shapeId: string) =>
+    providerHooks.get(shapeId)?.requestHeaders;
+
   const agentSurface: AgentSurface = {
     llm: createLlmFacade({ list: ctx.list, call: ctx.call }),
     providers: {
@@ -345,6 +349,7 @@ export default function agentBackend(ctx: ExtensionContext): void {
       baseURL: p.baseURL,
       buildReasoningParams: bindReasoning(shapeId, modelId),
       extractCachedTokens: bindCacheTokens(shapeId),
+      buildRequestHeaders: bindRequestHeaders(shapeId),
     };
   };
 
@@ -388,10 +393,11 @@ export default function agentBackend(ctx: ExtensionContext): void {
     }
   });
 
-  bus.on("provider:configure", ({ id, reasoningParams, cacheTokens }) => {
+  bus.on("provider:configure", ({ id, reasoningParams, cacheTokens, requestHeaders }) => {
     const prev = providerHooks.get(id) ?? {};
     if (reasoningParams !== undefined) prev.reasoningParams = reasoningParams;
     if (cacheTokens !== undefined) prev.cacheTokens = cacheTokens;
+    if (requestHeaders !== undefined) prev.requestHeaders = requestHeaders;
     providerHooks.set(id, prev);
   });
 

package/src/agent/llm-client.ts

@@ -68,7 +68,7 @@ export class LlmClient {
   }
 
   stream(opts: StreamOpts) {
-    const { signal, messages, tools, model, max_tokens, ...rest } = opts;
+    const { signal, headers, messages, tools, model, max_tokens, ...rest } = opts;
     const body = {
       ...rest,
       model: model ?? this.model,
@@ -78,7 +78,7 @@ export class LlmClient {
       stream: true as const,
       stream_options: { include_usage: true },
     };
-    return this.client.chat.completions.create(body as ChatCompletionCreateParamsStreaming, { signal });
+    return this.client.chat.completions.create(body as ChatCompletionCreateParamsStreaming, { signal, headers });
   }
 
   async complete(opts: CompleteOpts): Promise<string> {
@@ -102,6 +102,8 @@ export type StreamOpts = {
   model?: string;
   max_tokens?: number;
   signal?: AbortSignal;
+  /** Per-request transport headers, forwarded to the SDK (not request body). */
+  headers?: Record<string, string>;
 } & Record<string, unknown>;
 
 export type CompleteOpts = {

package/src/agent/providers/openrouter.ts

@@ -42,7 +42,16 @@ function toModalities(input?: string[]): ("text" | "image")[] | undefined {
 
 export default function activate(ctx: AgentContext): void {
   const apiKey = resolveApiKey("openrouter").key;
-  ctx.agent.providers.configure("openrouter", { reasoningParams: buildReasoningParams });
+  ctx.agent.providers.configure("openrouter", {
+    reasoningParams: buildReasoningParams,
+    // x-session-id pins sticky provider routing across turns so prompt caches
+    // stay warm even when compaction rewrites the opening messages.
+    requestHeaders: ({ sessionId }) => {
+      const headers: Record<string, string> = {};
+      if (sessionId) headers["x-session-id"] = sessionId;
+      return headers;
+    },
+  });
   ctx.agent.providers.register({
     id: "openrouter",
     apiKey: apiKey ?? undefined,

package/src/shell/strategies/bash.ts

@@ -47,8 +47,16 @@ export const bashStrategy: ShellStrategy = {
       '  [[ $__agent_sh_preexec_ran == 1 ]] && return',
       '  [[ -n $COMP_LINE ]] && return',
       "  __agent_sh_preexec_ran=1",
-      "  local this_cmd",
-      `  this_cmd=$(HISTTIMEFORMAT='' builtin history 1 | command sed 's/^ *[0-9]* *//')`,
+      "  local this_cmd hist_cmd",
+      `  hist_cmd=$(HISTTIMEFORMAT='' builtin history 1 | command sed 's/^ *[0-9]* *//')`,
+      "  # history 1 carries the full typed line but goes stale when the user's",
+      "  # PROMPT_COMMAND reloads history (history -c/-r). Trust it only when it",
+      "  # matches the command bash is about to run; else use $BASH_COMMAND.",
+      '  if [[ -n $hist_cmd && $hist_cmd == "$BASH_COMMAND"* ]]; then',
+      "    this_cmd=$hist_cmd",
+      "  else",
+      "    this_cmd=$BASH_COMMAND",
+      "  fi",
       `  printf '\\e]9997;${instanceTag};%s\\a' "$this_cmd"`,
       "}",
       "trap '__agent_sh_emit_preexec' DEBUG",