little-coder 1.8.1 → 1.8.3

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/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,
@@ -36,10 +37,13 @@ describe("resolveOverridePath", () => {
     expect(resolveOverridePath({ LITTLE_CODER_MODELS_FILE: "/explicit.json", HOME: "/h" })).toBe("/explicit.json");
   });
   it("falls back to XDG_CONFIG_HOME", () => {
-    expect(resolveOverridePath({ XDG_CONFIG_HOME: "/xdg", HOME: "/h" })).toBe("/xdg/little-coder/models.json");
+    expect(resolveOverridePath({ XDG_CONFIG_HOME: "/xdg", HOME: "/h" })).toBe(join("/xdg", "little-coder", "models.json"),);
   });
   it("falls back to HOME/.config", () => {
-    expect(resolveOverridePath({ HOME: "/h" })).toBe("/h/.config/little-coder/models.json");
+    expect(resolveOverridePath({ HOME: "/h" })).toBe(join("/h", ".config", "little-coder", "models.json"),);
+  });
+  it("falls back to USERPROFILE/.config when HOME is absent", () => {
+    expect(resolveOverridePath({ USERPROFILE: "/profile" })).toBe(join("/profile", ".config", "little-coder", "models.json"),);
   });
   it("returns undefined when neither is set", () => {
     expect(resolveOverridePath({})).toBeUndefined();
@@ -195,6 +199,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

@@ -58,7 +58,8 @@ export function resolveOverridePath(env: NodeJS.ProcessEnv = process.env): strin
   if (env.LITTLE_CODER_MODELS_FILE) return env.LITTLE_CODER_MODELS_FILE;
   const xdg = env.XDG_CONFIG_HOME;
   if (xdg) return join(xdg, "little-coder", "models.json");
-  if (env.HOME) return join(env.HOME, ".config", "little-coder", "models.json");
+  const home = env.HOME || env.USERPROFILE;
+  if (home) return join(home, ".config", "little-coder", "models.json");
   return undefined;
 }
 
@@ -67,9 +68,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.3] — 2026-06-08
+
+### Fixed
+- **User `models.json` is now found on Windows when `HOME` is unset** ([#43](https://github.com/itayinbarr/little-coder/pull/43), thanks [@A-M-D-R-3-W](https://github.com/A-M-D-R-3-W)). Windows doesn't guarantee `HOME`, but it does set `USERPROFILE`. The documented fallback `~/.config/little-coder/models.json` was therefore skipped on Windows and user-defined models never registered. `resolveOverridePath()` now falls back to `USERPROFILE` when `HOME` is absent (resolution order is unchanged where `HOME` exists: `$LITTLE_CODER_MODELS_FILE` → `$XDG_CONFIG_HOME` → `$HOME`/`$USERPROFILE` `/.config`). Path-resolution tests are now platform-neutral via `path.join`.
+
+### Documentation
+- **Added an "Any OpenAI-compatible server (e.g. MLX / omlx)" section** to the model-configuration docs ([#40](https://github.com/itayinbarr/little-coder/issues/40)). little-coder registers providers from `models.json` rather than from pi's standalone picker extensions, so an omlx/MLX server is added by declaring a provider entry (any OpenAI-compatible `/v1` endpoint works the same way), not by installing its pi picker. The README now shows the exact `~/.config/little-coder/models.json` block.
+
+---
+
+## [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

package/README.md

@@ -188,6 +188,35 @@ Then verify with `little-coder --list-models` — you should see your overridden
 
 `LLAMACPP_BASE_URL`, `OLLAMA_BASE_URL`, and `LMSTUDIO_BASE_URL` env vars still beat both files for those three providers.
 
+### Any OpenAI-compatible server (e.g. MLX / omlx)
+
+little-coder registers providers from `models.json` — it doesn't pick up pi's standalone "picker" extensions. So a server isn't added by installing its pi picker; you add it by declaring a provider. Any OpenAI-compatible endpoint works this way, including Apple's MLX server (`mlx_lm.server`, often surfaced as **omlx**). Drop this into `~/.config/little-coder/models.json` and pick it with `little-coder --model omlx/<id>`:
+
+```json
+{
+  "providers": {
+    "omlx": {
+      "api": "openai-completions",
+      "baseUrl": "http://127.0.0.1:8000/v1",
+      "apiKey": "IGNORED",
+      "models": [
+        {
+          "id": "Qwen3-32B-4bit",
+          "name": "Qwen3.6-35B-A3B (local omlx, 150K)",
+          "reasoning": true,
+          "input": ["text"],
+          "contextWindow": 150000,
+          "maxTokens": 4096,
+          "cost": { "input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0 }
+        }
+      ]
+    }
+  }
+}
+```
+
+Set `id` to whatever model your server reports, and `baseUrl` to its `/v1` endpoint. Verify with `little-coder --list-models`.
+
 `.pi/settings.json` is a separate concern: it controls per-model **profiles** (context_limit, thinking_budget, temperature, benchmark_overrides) referenced by the `<provider>/<id>` key. Profiles don't register or describe models — they only tune how little-coder runs against models that are already registered.
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "little-coder",
-  "version": "1.8.1",
+  "version": "1.8.3",
   "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": {