little-coder 1.8.0 → 1.8.2

package/.pi/extensions/benchmark-profiles/index.ts

@@ -163,10 +163,29 @@ function toLittleCoderOptions(p: ModelProfile): Record<string, unknown> {
   return out;
 }
 
+// Providers whose servers accept a `temperature` field on chat-completions.
+// little-coder's temperature defaults are tuned for the local-server case;
+// hosted reasoning models (Copilot's gpt-5.x, OpenAI o-series) hard-reject
+// the parameter with a 400 (issue #33). The list is intentionally minimal:
+// llama.cpp-style local servers. Override at runtime via
+// LITTLE_CODER_TEMPERATURE_PROVIDERS=foo,bar to add your own local provider.
+const DEFAULT_TEMPERATURE_PROVIDERS = ["llamacpp", "ollama", "lmstudio"] as const;
+
+export function providerAcceptsTemperature(provider: string, env: NodeJS.ProcessEnv = process.env): boolean {
+  const override = env.LITTLE_CODER_TEMPERATURE_PROVIDERS;
+  const list = override
+    ? override.split(",").map((s) => s.trim()).filter(Boolean)
+    : (DEFAULT_TEMPERATURE_PROVIDERS as readonly string[]);
+  return list.includes(provider);
+}
+
 export default function (pi: ExtensionAPI) {
   // Shared across handlers so before_provider_request can re-read the most
   // recently resolved temperature without re-parsing settings every turn.
   let resolvedTemperature: number | undefined;
+  // Provider-level guard: hosted reasoning models reject `temperature` (see
+  // DEFAULT_TEMPERATURE_PROVIDERS above).
+  let temperatureAccepted = false;
 
   pi.on("before_agent_start", async (event, ctx) => {
     const model = ctx.model;
@@ -193,6 +212,7 @@ export default function (pi: ExtensionAPI) {
     opts.littleCoder.contextLimit = resolveContextLimit(profile.context_limit, modelWindow);
 
     resolvedTemperature = opts.littleCoder.temperature;
+    temperatureAccepted = providerAcceptsTemperature(model.provider);
   });
 
   // Inject the profile's temperature onto the outgoing provider payload.
@@ -200,10 +220,14 @@ export default function (pi: ExtensionAPI) {
   // llama.cpp), which adds measurable stochastic variance on hard
   // algorithmic exercises. Matches local-coder's profiles[].temperature=0.3.
   //
+  // Skipped for providers whose servers reject `temperature` (Copilot's
+  // gpt-5.x, OpenAI's o-series) — see providerAcceptsTemperature.
+  //
   // IMPORTANT: pi's runner passes payload by reference but only adopts
   // *returned* values. Mutating in place is discarded between handlers, so
   // we build a new payload object and return it explicitly.
   pi.on("before_provider_request", async (event) => {
+    if (!temperatureAccepted) return;
     if (resolvedTemperature === undefined) return;
     const payload: any = (event as any).payload;
     if (!payload || typeof payload !== "object") return;

package/.pi/extensions/benchmark-profiles/profiles.test.ts

@@ -7,6 +7,7 @@ import benchmarkProfiles, {
   normKey,
   resolveContextLimit,
   CONTEXT_FALLBACK,
+  providerAcceptsTemperature,
 } from "./index.ts";
 
 const here = dirname(fileURLToPath(import.meta.url));
@@ -148,3 +149,55 @@ describe("before_agent_start publishes a model-window contextLimit", () => {
     expect(lc.contextLimit).toBe(65536);
   });
 });
+
+describe("providerAcceptsTemperature (issue #33)", () => {
+  it("accepts the shipped local providers by default", () => {
+    expect(providerAcceptsTemperature("llamacpp", {})).toBe(true);
+    expect(providerAcceptsTemperature("ollama", {})).toBe(true);
+    expect(providerAcceptsTemperature("lmstudio", {})).toBe(true);
+  });
+  it("rejects hosted reasoning providers that 400 on temperature", () => {
+    expect(providerAcceptsTemperature("copilot", {})).toBe(false);
+    expect(providerAcceptsTemperature("openai", {})).toBe(false);
+    expect(providerAcceptsTemperature("anthropic", {})).toBe(false);
+  });
+  it("LITTLE_CODER_TEMPERATURE_PROVIDERS env replaces the default list", () => {
+    const env = { LITTLE_CODER_TEMPERATURE_PROVIDERS: "vllm, my-local" };
+    expect(providerAcceptsTemperature("vllm", env)).toBe(true);
+    expect(providerAcceptsTemperature("my-local", env)).toBe(true);
+    expect(providerAcceptsTemperature("llamacpp", env)).toBe(false);
+  });
+});
+
+describe("before_provider_request only injects temperature for accepting providers", () => {
+  async function runHandlers(model: any, payload: any) {
+    const handlers: Record<string, ((e: any, c: any) => any)[]> = {};
+    const pi = { on: (n: string, h: any) => ((handlers[n] ??= []).push(h)) };
+    benchmarkProfiles(pi as any);
+    const startEvent: any = { systemPromptOptions: {} };
+    const ctx: any = { model };
+    for (const h of handlers["before_agent_start"] ?? []) await h(startEvent, ctx);
+    const reqEvent: any = { payload };
+    let lastResult: any;
+    for (const h of handlers["before_provider_request"] ?? []) {
+      lastResult = await h(reqEvent, ctx);
+    }
+    return lastResult;
+  }
+
+  it("injects temperature for a local llamacpp model", async () => {
+    const out = await runHandlers(
+      { provider: "llamacpp", id: "qwen3.6-27b", contextWindow: 131072 },
+      { messages: [] },
+    );
+    expect(out).toMatchObject({ temperature: 0.3 });
+  });
+
+  it("does NOT inject temperature for copilot/gpt-5.x (issue #33)", async () => {
+    const out = await runHandlers(
+      { provider: "copilot", id: "gpt-5.4", contextWindow: 131072 },
+      { messages: [] },
+    );
+    expect(out).toBeUndefined();
+  });
+});

package/.pi/extensions/extra-tools/glob.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { globFiles, renderGlobOutcome, DEFAULT_HEAVY_DIRS } from "./glob.ts";
+
+let dir: string;
+
+beforeAll(() => {
+  dir = mkdtempSync(join(tmpdir(), "glob-test-"));
+  // real source we want to find
+  mkdirSync(join(dir, "src", "sub"), { recursive: true });
+  writeFileSync(join(dir, "src", "a.py"), "");
+  writeFileSync(join(dir, "src", "sub", "b.py"), "");
+  writeFileSync(join(dir, "README.md"), "");
+  // heavy dirs that must be pruned (with files matching the pattern inside)
+  mkdirSync(join(dir, "node_modules", "pkg", "deep"), { recursive: true });
+  writeFileSync(join(dir, "node_modules", "pkg", "deep", "x.py"), "");
+  mkdirSync(join(dir, ".git", "objects"), { recursive: true });
+  writeFileSync(join(dir, ".git", "objects", "y.py"), "");
+  mkdirSync(join(dir, "dist"), { recursive: true });
+  writeFileSync(join(dir, "dist", "z.py"), "");
+});
+
+afterAll(() => rmSync(dir, { recursive: true, force: true }));
+
+describe("globFiles", () => {
+  it("matches real files and prunes heavy dirs (node_modules/.git/dist)", async () => {
+    const { matches, scanTruncated, matchTruncated } = await globFiles("**/*.py", { base: dir });
+    const rel = matches.map((m) => m.slice(dir.length + 1)).sort();
+    expect(rel).toEqual(["src/a.py", "src/sub/b.py"]);
+    expect(matches.some((m) => m.includes("node_modules"))).toBe(false);
+    expect(matches.some((m) => m.includes(".git"))).toBe(false);
+    expect(matches.some((m) => m.includes("/dist/"))).toBe(false);
+    expect(scanTruncated).toBe(false);
+    expect(matchTruncated).toBe(false);
+  });
+
+  it("caps matches at maxMatches and flags matchTruncated", async () => {
+    const many = mkdtempSync(join(tmpdir(), "glob-many-"));
+    for (let i = 0; i < 50; i++) writeFileSync(join(many, `f${i}.txt`), "");
+    try {
+      const { matches, matchTruncated } = await globFiles("*.txt", { base: many, maxMatches: 10 });
+      expect(matches.length).toBe(10);
+      expect(matchTruncated).toBe(true);
+    } finally {
+      rmSync(many, { recursive: true, force: true });
+    }
+  });
+
+  it("stops the walk at maxScan and flags scanTruncated (memory bound)", async () => {
+    // A low budget must halt the walk regardless of how many entries exist.
+    const { scanned, scanTruncated } = await globFiles("**/*", { base: dir, maxScan: 3 });
+    expect(scanTruncated).toBe(true);
+    expect(scanned).toBeLessThanOrEqual(5); // a couple over the budget, not unbounded
+  });
+
+  it("the heavy-dir set covers the usual offenders", () => {
+    for (const d of ["node_modules", ".git", "dist", ".cache", "Library", "venv", "target"]) {
+      expect(DEFAULT_HEAVY_DIRS.has(d)).toBe(true);
+    }
+  });
+});
+
+describe("renderGlobOutcome", () => {
+  it("reports no matches plainly", () => {
+    expect(renderGlobOutcome({ matches: [], scanned: 5, scanTruncated: false, matchTruncated: false }))
+      .toBe("No files matched");
+  });
+  it("notes scan truncation when nothing matched", () => {
+    expect(renderGlobOutcome({ matches: [], scanned: 9, scanTruncated: true, matchTruncated: false }, 200000))
+      .toMatch(/stopped after scanning 200000 entries/);
+  });
+  it("appends a match-cap note", () => {
+    const text = renderGlobOutcome(
+      { matches: ["/a", "/b"], scanned: 2, scanTruncated: false, matchTruncated: true },
+      200000,
+      500,
+    );
+    expect(text).toMatch(/stopped at 500 matches/);
+  });
+  it("appends a scan-cap note when there were partial matches", () => {
+    const text = renderGlobOutcome(
+      { matches: ["/a"], scanned: 9, scanTruncated: true, matchTruncated: false },
+      200000,
+    );
+    expect(text).toMatch(/results may be incomplete/);
+  });
+});

package/.pi/extensions/extra-tools/glob.ts

@@ -0,0 +1,102 @@
+import { glob as fsGlob } from "node:fs/promises";
+
+// Bounded file globbing. The naive `for await (…glob…) { if (len>=500) break }`
+// only caps MATCHES — it does nothing about the WALK. Run from a huge root
+// (e.g. a home directory with macOS Library / caches / node_modules), fs.glob
+// recursively descends everything, and its internal traversal state grows until
+// the Node process OOMs (heap, not the model's context) — long before 500
+// matches are found if matches are sparse. fs.glob exposes no signal/abort and
+// no depth/scan cap, so we bound it through the one hook it does call for every
+// entry: `exclude`. We use it to (a) prune heavy/irrelevant directories so they
+// are never descended, and (b) meter total entries scanned — once the budget is
+// hit, exclude everything, which winds the walk down.
+
+/** Directories never worth descending for a file search — pruned at the dir
+ *  level (returning true from `exclude` on a directory stops descent), which is
+ *  what keeps a home-directory glob from exhausting memory. */
+export const DEFAULT_HEAVY_DIRS: ReadonlySet<string> = new Set([
+  // version control
+  ".git", ".hg", ".svn",
+  // dependencies / language caches
+  "node_modules", ".venv", "venv", "__pycache__", ".tox", ".mypy_cache",
+  ".pytest_cache", ".gradle", ".cargo", "vendor", "Pods",
+  // build output
+  "dist", "build", "out", "target", ".next", ".nuxt", ".output", ".svelte-kit",
+  // tool caches
+  ".cache", ".npm", ".pnpm-store", ".yarn", ".turbo",
+  // macOS / system heavies that blow up a home-dir walk
+  "Library", "Applications", ".Trash", "Photos Library.photoslibrary",
+]);
+
+export interface GlobOptions {
+  base: string;
+  maxScan?: number;
+  maxMatches?: number;
+  heavyDirs?: ReadonlySet<string>;
+}
+
+export interface GlobOutcome {
+  matches: string[];
+  scanned: number;
+  /** the walk was cut short at maxScan entries (results may be incomplete) */
+  scanTruncated: boolean;
+  /** matches were capped at maxMatches */
+  matchTruncated: boolean;
+}
+
+export const DEFAULT_MAX_SCAN = 200_000;
+export const DEFAULT_MAX_MATCHES = 500;
+
+export async function globFiles(pattern: string, opts: GlobOptions): Promise<GlobOutcome> {
+  const maxScan = opts.maxScan ?? DEFAULT_MAX_SCAN;
+  const maxMatches = opts.maxMatches ?? DEFAULT_MAX_MATCHES;
+  const heavy = opts.heavyDirs ?? DEFAULT_HEAVY_DIRS;
+
+  const matches: string[] = [];
+  let scanned = 0;
+  let scanTruncated = false;
+  let matchTruncated = false;
+
+  // Called for every entry the walk visits (files AND directories). Pruning a
+  // directory here stops descent into it. Also our scan meter: once the budget
+  // is spent, exclude everything so fs.glob stops adding work and ends.
+  const exclude = (entry: unknown): boolean => {
+    scanned++;
+    if (scanned > maxScan) {
+      scanTruncated = true;
+      return true;
+    }
+    const name = typeof entry === "string" ? entry : String((entry as { name?: string })?.name ?? entry);
+    return name.split(/[\\/]/).some((seg) => heavy.has(seg));
+  };
+
+  // `exclude` as a predicate isn't in every @types/node version's fs.glob
+  // signature, but it's supported at runtime (Node 22+); cast to pass it through.
+  for await (const m of fsGlob(pattern, { cwd: opts.base, exclude } as Parameters<typeof fsGlob>[1])) {
+    matches.push(`${opts.base}/${m}`);
+    if (matches.length >= maxMatches) {
+      matchTruncated = true;
+      break;
+    }
+  }
+
+  matches.sort();
+  return { matches, scanned, scanTruncated, matchTruncated };
+}
+
+/** Render a globFiles outcome as the tool's text output, with a one-line note
+ *  when results were cut short so the model knows to narrow its search. */
+export function renderGlobOutcome(o: GlobOutcome, maxScan = DEFAULT_MAX_SCAN, maxMatches = DEFAULT_MAX_MATCHES): string {
+  if (o.matches.length === 0) {
+    return o.scanTruncated
+      ? `No files matched (search stopped after scanning ${maxScan} entries — narrow the base path; build/dependency/cache dirs are skipped automatically).`
+      : "No files matched";
+  }
+  let text = o.matches.join("\n");
+  if (o.matchTruncated) {
+    text += `\n… (stopped at ${maxMatches} matches — narrow the pattern for the rest)`;
+  } else if (o.scanTruncated) {
+    text += `\n… (search stopped after scanning ${maxScan} entries — results may be incomplete; narrow the base path)`;
+  }
+  return text;
+}

package/.pi/extensions/extra-tools/index.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
-import { glob as globSync } from "node:fs/promises";
+import { globFiles, renderGlobOutcome } from "./glob.ts";
 
 // Ports of tools.py::_glob, _webfetch, _websearch. Pi ships its own grep/find,
 // so those are not re-registered here.
@@ -10,7 +10,9 @@ export default function (pi: ExtensionAPI) {
     name: "glob",
     label: "Glob",
     description:
-      "Find files matching a glob pattern. Returns a sorted list of matching paths (up to 500).",
+      "Find files matching a glob pattern. Returns a sorted list of matching paths (up to 500). " +
+      "Common dependency/build/cache dirs (node_modules, .git, dist, …) are skipped, and the walk " +
+      "is bounded — for a focused search, pass a `path` rather than globbing a whole home directory.",
     parameters: Type.Object({
       pattern: Type.String({ description: "Glob pattern e.g. **/*.py" }),
       path: Type.Optional(Type.String({ description: "Base directory (default: cwd)" })),
@@ -18,16 +20,11 @@ export default function (pi: ExtensionAPI) {
     async execute(_id, { pattern, path }) {
       try {
         const base = path || process.cwd();
-        const matches: string[] = [];
-        // Node 22's fs/promises.glob — returns an async iterator
-        for await (const m of globSync(pattern, { cwd: base })) {
-          matches.push(`${base}/${m}`);
-          if (matches.length >= 500) break;
-        }
-        matches.sort();
-        const text = matches.length === 0 ? "No files matched" : matches.join("\n");
+        // Bounded walk: prunes heavy dirs and caps total entries scanned so a
+        // recursive glob from a huge root can't exhaust the process heap.
+        const outcome = await globFiles(pattern, { base });
         return {
-          content: [{ type: "text", text }],
+          content: [{ type: "text", text: renderGlobOutcome(outcome) }],
           details: {},
         };
       } catch (e) {

package/.pi/extensions/llama-cpp-provider/config.test.ts

@@ -5,6 +5,7 @@ import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import {
   applyEnvOverrides,
+  fillModelDefaults,
   loadProviders,
   mergeProviders,
   resolveOverridePath,
@@ -195,6 +196,121 @@ describe("shipped models.json", () => {
   });
 });
 
+describe("fillModelDefaults (issue #36)", () => {
+  // The crash was: a user models.json entry that omitted name/maxTokens/cost
+  // reached pi's registry as `model.cost === undefined`, which then exploded
+  // with "Cannot read properties of undefined (reading 'input')" deep in
+  // applyModelOverride. Filling the same defaults pi uses internally lets a
+  // minimal entry round-trip safely.
+  it("fills name/maxTokens/cost/input/contextWindow/reasoning when missing", () => {
+    const out = fillModelDefaults({ id: "foo.gguf" }, "llamacpp", 0);
+    expect(out).toMatchObject({
+      id: "foo.gguf",
+      name: "foo.gguf",
+      reasoning: false,
+      input: ["text"],
+      contextWindow: 32768,
+      maxTokens: 4096,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    });
+  });
+
+  it("preserves user-supplied values over defaults", () => {
+    const out = fillModelDefaults(
+      {
+        id: "Qwen3.6-27B-Q4_K_M.gguf",
+        reasoning: true,
+        input: ["text", "image"],
+        contextWindow: 262144,
+      },
+      "llamacpp",
+      0,
+    );
+    expect(out.reasoning).toBe(true);
+    expect(out.input).toEqual(["text", "image"]);
+    expect(out.contextWindow).toBe(262144);
+    // Still defaulted:
+    expect(out.maxTokens).toBe(4096);
+    expect(out.cost).toEqual({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
+  });
+
+  it("preserves unknown extra fields (e.g. _launch)", () => {
+    const out: any = fillModelDefaults({ id: "x", _launch: true }, "llamacpp", 0);
+    expect(out._launch).toBe(true);
+  });
+
+  it("throws with a precise pointer when id is missing", () => {
+    expect(() => fillModelDefaults({}, "llamacpp", 2)).toThrow(/provider 'llamacpp' model at index 2/);
+    expect(() => fillModelDefaults({ id: "" }, "llamacpp", 0)).toThrow(/missing or invalid "id"/);
+  });
+});
+
+describe("loadProviders with an under-specified user override (issue #36)", () => {
+  let dir: string;
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), "lc-providers36-"));
+  });
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("a minimal user model entry no longer leaves cost undefined", () => {
+    writeFileSync(join(dir, "models.json"), JSON.stringify({ providers: {} }));
+    const userPath = join(dir, "user.json");
+    writeFileSync(
+      userPath,
+      JSON.stringify({
+        providers: {
+          llamacpp: {
+            api: "openai-completions",
+            apiKey: "llama",
+            baseUrl: "http://127.0.0.1:8020/v1",
+            models: [
+              {
+                _launch: true,
+                contextWindow: 262144,
+                id: "Qwen3.6-27B-Q4_K_M.gguf",
+                input: ["text", "image"],
+                reasoning: true,
+              },
+            ],
+          },
+        },
+      }),
+    );
+    const result = loadProviders(dir, { LITTLE_CODER_MODELS_FILE: userPath });
+    const m = result.providers.llamacpp.models[0];
+    expect(m.cost).toEqual({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
+    expect(m.maxTokens).toBe(4096);
+    expect(m.name).toBe("Qwen3.6-27B-Q4_K_M.gguf");
+    // User-supplied values must win:
+    expect(m.contextWindow).toBe(262144);
+    expect(m.input).toEqual(["text", "image"]);
+  });
+
+  it("a model entry without an id is reported as invalid, not silently passed through", () => {
+    writeFileSync(join(dir, "models.json"), JSON.stringify({ providers: {} }));
+    const userPath = join(dir, "user.json");
+    writeFileSync(
+      userPath,
+      JSON.stringify({
+        providers: {
+          llamacpp: {
+            api: "openai-completions",
+            apiKey: "k",
+            baseUrl: "http://x/v1",
+            models: [{ reasoning: true }],
+          },
+        },
+      }),
+    );
+    const result = loadProviders(dir, { LITTLE_CODER_MODELS_FILE: userPath });
+    const userSrc = result.sources.find((s) => s.path === userPath);
+    expect(userSrc?.status).toBe("invalid");
+    expect(userSrc?.error).toMatch(/missing or invalid "id"/);
+  });
+});
+
 describe("propsUrlFor", () => {
   it("strips a trailing /v1 and points at the server root /props", () => {
     expect(propsUrlFor("http://127.0.0.1:8888/v1")).toBe("http://127.0.0.1:8888/props");

package/.pi/extensions/llama-cpp-provider/config.ts

@@ -67,9 +67,42 @@ function parseModelsFile(raw: string): ModelsFile {
   if (!parsed || typeof parsed !== "object" || !parsed.providers || typeof parsed.providers !== "object") {
     throw new Error("expected top-level { providers: { ... } }");
   }
+  const providers = parsed.providers as Record<string, ProviderEntry>;
+  for (const [name, entry] of Object.entries(providers)) {
+    if (!entry || typeof entry !== "object" || !Array.isArray(entry.models)) continue;
+    entry.models = entry.models.map((m, i) => fillModelDefaults(m, name, i));
+  }
   return parsed as ModelsFile;
 }
 
+/**
+ * Fill in defaults for optional model fields that pi requires downstream.
+ * pi's `registerProvider` path stores model entries verbatim, so a user
+ * override that omits e.g. `cost` ends up with `model.cost === undefined`,
+ * and the model registry's per-model override path crashes with
+ * "Cannot read properties of undefined (reading 'input')" (issue #36) when
+ * it tries to read `model.cost.input`. Filling the same defaults pi uses
+ * for built-in models means a minimal user entry — just an id — works.
+ *
+ * The `id` field is the only true requirement. We throw with a precise
+ * pointer when it's missing so the caller can route this to the source-list
+ * diagnostics rather than crashing pi.
+ */
+export function fillModelDefaults(m: any, providerName: string, index: number): ProviderModelEntry {
+  if (!m || typeof m !== "object" || typeof m.id !== "string" || m.id.length === 0) {
+    throw new Error(`provider '${providerName}' model at index ${index}: missing or invalid "id"`);
+  }
+  const defaults = {
+    name: m.id,
+    reasoning: false,
+    input: ["text"] as ("text" | "image")[],
+    contextWindow: 32768,
+    maxTokens: 4096,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+  };
+  return { ...defaults, ...m };
+}
+
 function readIfPresent(path: string): { kind: "ok"; data: ModelsFile } | { kind: "missing" } | { kind: "invalid"; error: string } {
   if (!existsSync(path)) return { kind: "missing" };
   try {

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 All notable changes to little-coder are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and little-coder's public interface (CLI, providers, tools, skills) follows semver starting at `v0.0.1` post-rename.
 
+## [v1.8.2] — 2026-05-25
+
+### Fixed
+- **Minimal user `models.json` entries no longer crash startup with `Cannot read properties of undefined (reading 'input')`** ([#36](https://github.com/itayinbarr/little-coder/issues/36)). The shipped `models.json` declares every field — `id`, `name`, `reasoning`, `input`, `contextWindow`, `maxTokens`, `cost` — but a user override that omitted e.g. `name`/`maxTokens`/`cost` was passed through unchanged to pi's registry, which then exploded deep in `applyModelOverride` when it tried to read `model.cost.input`. `llama-cpp-provider` now fills in the same defaults pi uses for built-in models (`name = id`, `reasoning = false`, `input = ["text"]`, `contextWindow = 32768`, `maxTokens = 4096`, zero-cost) so a minimal entry — just `id` plus the provider's `baseUrl`/`apiKey` — works. User-supplied values still win over defaults; unknown extra fields (e.g. `_launch`) are preserved. A model entry that omits `id` is now flagged with a precise error in the source diagnostics instead of crashing pi. New `fillModelDefaults` helper, plus regression tests using the exact entry shape from the issue report.
+- **`temperature' is not supported with this model` against Copilot GPT-5.x / OpenAI o-series** ([#33](https://github.com/itayinbarr/little-coder/issues/33)). `benchmark-profiles` was injecting `temperature: 0.3` from `default_model_profile` into every outgoing chat-completions payload, but hosted reasoning models hard-reject the parameter with a 400. The temperature injection is now gated on the provider: it ships on for `llamacpp`, `ollama`, and `lmstudio` (the providers it was tuned for) and is skipped for everything else. New env var `LITTLE_CODER_TEMPERATURE_PROVIDERS=foo,bar` replaces the default list when you bring your own local provider (e.g. `vllm`). New exported, tested `providerAcceptsTemperature()`; end-to-end test fires `before_agent_start` + `before_provider_request` and asserts the copilot path returns no payload mutation.
+
+### Notes for upgraders
+- No CLI-flag or public-API changes. If you previously relied on temperature 0.3 reaching a non-local provider via the default profile (uncommon — most hosted providers reject it), add that provider name to `LITTLE_CODER_TEMPERATURE_PROVIDERS`.
+
+---
+
+## [v1.8.1] — 2026-05-23
+
+### Fixed
+- **`glob` no longer exhausts memory on a recursive search from a huge root.** The tool capped *matches* at 500 but never bounded the *walk*: run from a home directory (or any tree with macOS `Library`, caches, or `node_modules`), `fs.glob` recursively descended everything and its internal traversal state grew until the Node **process** ran out of heap — a host-memory crash (`Ineffective mark-compacts near heap limit`), entirely distinct from the model's *context window* (the read-guard / window machinery operates on tool *results* in tokens; this died mid-walk, before any result existed). The walk is now bounded two ways: heavy/irrelevant directories (`node_modules`, `.git`, `dist`, `.cache`, `Library`, `venv`, `target`, …) are **pruned** — never descended — and a hard scan budget (200 000 entries) halts the walk through the one hook `fs.glob` calls per entry (`exclude`), since it exposes no signal/abort. When results are cut short the output says so, so the model narrows its search. New unit-tested `globFiles` / `renderGlobOutcome` helpers (`.pi/extensions/extra-tools/glob.ts`), verified to prune `node_modules` (0 descent) and to halt at the scan budget.
+
+### Notes for upgraders
+- For a focused search, pass a `path` (a project subdirectory) instead of globbing from a home directory. Hidden directories continue to be skipped by `fs.glob` as before.
+
+---
+
 ## [v1.8.0] — 2026-05-23
 
 little-coder now **auto-detects the llama.cpp server's live context window** at startup and registers the model with it, so a `llama-server -c 131072` shows 128k instead of the declared default — no config edit. This completes [v1.7.0](#v170--2026-05-23): the budget already *followed* the registered window; now the registered window itself comes from the running server.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "little-coder",
-  "version": "1.8.0",
+  "version": "1.8.2",
   "description": "A pi-based coding agent optimized for small local language models. Reproduces the whitepaper's scaffold-model-fit adaptations as pi extensions.",
   "homepage": "https://github.com/itayinbarr/little-coder",
   "repository": {