heartcode 0.1.7 → 0.1.9

package/SKILL.md

@@ -55,7 +55,11 @@ reached has an `error` and is skipped; the command still exits `0`.
 a lost connection, or an error page from a proxy in front of the provider is waited out and tried
 again (or handed to the next model in the list), up to `--max-retries` (10). With the default
 list, a model that can't be used (a wrong key, no access to it, a name the server doesn't know:
-401, 403, 404) also makes way for the next one, and so does one that keeps replying with nothing.
+401, 403, 404) also makes way for the next one, and so does one that keeps replying with nothing. When a
+provider answers with an error (status 400 or above), the next model tried is from another
+provider; that provider's other models are tried only after every provider has had a go.
+A model that takes over with a smaller context window gets the conversation summarized first, if it
+wouldn't fit.
 The run stops with that error and exit code `1` when every model in the list fails that way, or
 when a single model (`-m <model>`) does. A request a server refuses (400) is sent as it is to two
 more models of the list at most, then the run stops (unless the user set the fallback rule to "at

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heartcode",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "A coding CLI for any local or OpenAI-compatible model, including small models without tool calling.",
   "keywords": [
     "ai",

package/prompts/agent.md

@@ -14,6 +14,7 @@ what the task needs. {{files}} and {{more}} are still filled in, empty, for olde
 come at the end: then this says less, so it doesn't contradict them. -->
 {{#if caller}}You are running in HeartCode, an agent in a terminal. Your role and your instructions are at the end of this prompt.{{else}}You are HeartCode, a coding assistant working in a terminal on the user's project.{{/if}}
 Use the tools to look at files, change them and run commands. Find what the task needs with list_files and search rather than guessing paths; read a file before editing it, and prefer small edits with edit_file.
+Check your work by what it produced, not by the absence of an error: read back the file you changed, run the test, look at the output. When something is wrong, find out why before trying again; don't repeat the same attempt. A task that repeats over many items: do one first, check it, then the rest. Before you finish, compare the result with what was asked.
 {{#if caller}}Commands run in the folder {{root}}, and relative paths are relative to it.{{else}}Paths are relative to the project folder, and commands already run in it. The project folder is {{root}} (for file:// URLs in the browser); stay inside it: don't search the rest of the disk.
 When you are done, reply with a short summary of what you did (or the answer to the question) and stop calling tools.{{/if}}
 
@@ -170,13 +171,13 @@ Which of your models does the job (from "Your other models" in the system prompt
 Besides you (tool calls, {{you}}), the user set up these models:
 {{models}}
 
-Work with them through the agent tool: "model" picks one (as "provider model"; left out, a helper on your own model), "images" gives it images to look at (image files, saved screenshots, image URLs). Several agent calls in one reply run at the same time.
+Work with them through the agent tool: "model" picks one, "images" gives it images to look at.
 
 - Never decline, guess or work around something because you can't do it (see an image, think it through, read more than fits your context): ask a model that can. Choose by what the job needs: the ability first; a faster one for a simple job, the strongest for a hard one; not one that keeps failing.
 - Ask for what you need in order to act, not for a description. Not "describe this screenshot" but "Which of these 9 tiles (numbered 1-9, left to right, top to bottom) show a chair? Reply with the numbers only." or "Where is the Submit button? Reply with its exact text and its position (top/middle/bottom, left/center/right)." Say what to answer and in what form, and nothing more.
 - Many images, or a job in independent parts: one agent call per image or part, all in the same reply (the same model several times, or different ones). Then put the answers together and decide the next step yourself.
 - A loop that needs the ability at every step (look, act, look again, until done) goes whole to a model that has it: the goal, how to tell it's done, what to report. Better than asking about each step.
-- A helper starts fresh: it knows only your prompt and images. Give it all it needs: the goal, what's known (paths, URLs, the page the browser is on, what was tried), what to reply. It has your tools, the same browser and MCP servers too: helpers that need the same MCP server (a browser) take turns (HeartCode makes the next one wait), so jobs that use it don't gain from running together; and never give two helpers the same files at once.
+- Give a helper all it needs: the goal, what's known (paths, URLs, the page the browser is on, what was tried), what to reply. It has your tools, the same browser and MCP servers too: helpers that need the same MCP server (a browser) take turns (HeartCode makes the next one wait), so jobs that use it don't gain from running together; and never give two helpers the same files at once.
 - A helper that fails or replies with nothing is handed on to your next model that can do the job, on its own. An answer that doesn't settle it (wrong, unsure, part of it): ask again, a sharper question or another capable model, until it's done.
 - Trust a helper's answer to what you asked; question it only when it looks doubtful (it contradicts what you know, or it's vague) or acting on it can't be undone. Don't redo its work yourself.
 
@@ -188,7 +189,7 @@ You can see images: those in the user's messages, those tools return (a browser
 ## tool-agent-images
 
 <!-- The agent tool's "images", there when the user has other models. -->
-Images for the helper to look at: image file paths (in the project, saved screenshots, ones the user gave) or image URLs. The model must see images (leave "model" out to get one that can).
+Images for the helper to look at: image file paths (in the project, saved screenshots, ones the user gave) or image URLs. The model must see images.
 
 ## images-unseen
 
@@ -324,7 +325,7 @@ Update a note rather than adding a duplicate, and link related notes with [[name
 ## tool-memory
 
 <!-- The memory tool's description. -->
-Memory notes. action "write": name, description (one line), type (user, project, feedback or reference), tags (1-3), scope ("project", the default, or "global" for the user's preferences in every project), content (markdown; link notes with [[name]]). "read": name. "search": query (words, or tag:name). "delete": name (and scope if the name is in both).
+Memory notes. action "write": name, description (one line), type (user, project, feedback or reference), tags (1-3), scope ("project", the default, or "global"), content (markdown; link notes with [[name]]). "read": name. "search": query (words, or tag:name). "delete": name (and scope if the name is in both).
 
 ## memory-extract
 

package/src/agent.js

@@ -695,9 +695,12 @@ async function runNative(s, task, images, signal) {
       // shorter conversation fits (a per-minute cap smaller than that), so not tried again
       const fixed = Math.round((est(JSON.stringify(tools)) + sizeOf(s.messages[0])) * (strat.ratio ?? 1))
       if (fixed >= e.inputLimit) throw Object.assign(e, { message: `${e.message} (the system prompt and tools alone are ~${fixed} tokens: this can't fit)` })
-      s.sizeCap = Math.min(s.sizeCap ?? Infinity, e.inputLimit)
       out.end()
-      shrink *= 0.8 // strat.context already dropped to the limit; leave more headroom each time
+      // e.fitted: the next model's window is smaller (strat already follows it): compacted at once
+      if (!e.fitted) {
+        s.sizeCap = Math.min(s.sizeCap ?? Infinity, e.inputLimit)
+        shrink *= 0.8 // strat.context already dropped to the limit; leave more headroom each time
+      }
       step--
       continue
     }

package/src/client.js

@@ -184,12 +184,34 @@ export class Client {
     this.#next(why)
     return true
   }
-  #next(why) {
+  #next(why, pick) {
     const r = this.rotation
-    r.at = (r.at + 1) % r.list.length
+    r.at = pick ? pick() : (r.at + 1) % r.list.length
     log('rotate', `${why} → ${r.list[r.at].provider} · ${r.list[r.at].model}`)
     this.#use(r.list[r.at])
   }
+  // Which model of the list to go on to after this one failed, for one request (tried: the places
+  // tried, down: the providers that answered with an error, 400 or above). A provider that answered
+  // with an error isn't asked again through its next model: the next one is from another provider.
+  // When every provider has failed, the models not tried yet, in order; when all have been tried,
+  // simply the next one (round again).
+  #pick(e, tried, down) {
+    const r = this.rotation
+    tried.add(r.at)
+    if (e?.status >= 400) down.add(r.list[r.at].provider)
+    const n = r.list.length
+    const after = (ok) => {
+      for (let k = 1; k <= n; k++) if (ok((r.at + k) % n)) return (r.at + k) % n
+      return -1
+    }
+    let i = after((i) => !tried.has(i) && !down.has(r.list[i].provider))
+    if (i < 0) i = after((i) => !tried.has(i))
+    if (i < 0) {
+      tried.clear() // all tried: round again
+      i = (r.at + 1) % n
+    }
+    return i
+  }
   // A new message: back to #1 (unless it stays on the one that worked)
   newMessage() {
     const r = this.rotation
@@ -203,11 +225,11 @@ export class Client {
     if (changed) this.onUse?.(t)
   }
   // After a failure: go on to the next model? (then it's tried at once)
-  #rotate(e, tries) {
+  #rotate(e, tries, pick) {
     const r = this.rotation
     if (!r) return false
     if (!(r.on === 'any' || (r.on === 'failure' && (outage(e) || unusable(e))) || (r.on === 'retries' && (tries >= r.retries || unusable(e))))) return false
-    r.at = (r.at + 1) % r.list.length
+    r.at = pick ? pick() : (r.at + 1) % r.list.length
     log('rotate', `${e.message.slice(0, 200)} → ${r.list[r.at].provider} · ${r.list[r.at].model}`)
     this.#use(r.list[r.at])
     return true
@@ -284,6 +306,8 @@ export class Client {
   // The server's own entries for its models ({ id, owned_by, context_length, pricing… }, as it sends them).
   async modelEntries(timeout = 10_000) {
     const data = await this.#json(this.baseUrl + '/models', undefined, timeout)
+    // { result: [...] } (Cloudflare's shape): there the id is an internal one and the name is the model's
+    if (Array.isArray(data.result)) return data.result.filter((m) => m?.name).map((m) => ({ ...m, id: m.name }))
     return (data.data ?? data.models ?? []).filter((m) => m && (m.id ?? m.name))
   }
 
@@ -399,7 +423,17 @@ export class Client {
     let round = 0 // models tried since the last wait (a whole round of them failing: a short pause)
     let hard = true // every failure in this round was one that waiting can't fix (see outage)
     let refusedBy = 0 // models that refused this request (a bad request), tried in turn
+    const tried = new Set() // places in the model list tried for this request
+    const down = new Set() // providers that answered it with an error (400 or above): their other models are skipped
+    const first = this.target
     for (let attempt = 0; ; attempt++) {
+      // moved on to a model with a smaller window than the conversation was fitted to: handed back
+      // (as "too large", at that window) so the caller summarizes it first, instead of a refusal
+      const sent = this.target !== first && body.messages && this.can?.context && Math.round(estMessages(body.messages) * this.tokenRatio)
+      if (sent > this.can.context * 0.9) {
+        log('limit', `${this.model}: ~${sent} tokens don't fit its window (${this.can.context}); handed back to be made smaller`)
+        throw Object.assign(new Error(`the conversation (~${sent} tokens) is too large for ${this.model} (${this.can.context})`), { inputLimit: this.can.context, fitted: true })
+      }
       try {
         const r = await this.#timed(body, { ...opts, once: true })
         if (attempt) this.onRetry(null)
@@ -415,7 +449,7 @@ export class Client {
         // conversation holds from another model). Two more at most, then it stops.
         if (!outage(e) && !unusable(e) && this.rotation && this.rotation.on !== 'any' && refusedBy < Math.min(2, this.rotation.list.length - 1)) {
           refusedBy++
-          this.#next(`refused (${e.status})`)
+          this.#next(`refused (${e.status})`, () => this.#pick(e, tried, down))
           this.onRetry(e, 0, attempt + 1, this.target)
           continue
         }
@@ -426,7 +460,7 @@ export class Client {
         if (!outage(e) && !(unusable(e) && this.rotation) && this.rotation?.on !== 'any') throw e
         hard &&= !outage(e)
         tries++
-        if (this.#rotate(e, tries)) {
+        if (this.#rotate(e, tries, () => this.#pick(e, tried, down))) {
           tries = 0
           // ponytail: a 1s pause after a whole round fails (no connection at all: not thousands of
           // requests a minute); the user chose "round again at once"

package/src/config.js

@@ -76,9 +76,12 @@ function fromFile() {
 // Any other model given for a run (-m, HEART_MODEL, a URL of its own) is that model alone: fixed.
 export const DEFAULT_MODEL = 'default'
 
+// providers by name, A to Z: every list of them (settings page, `heart providers`, pickers) follows
+export const byName = (providers) => Object.fromEntries(Object.entries(providers ?? {}).sort(([a], [b]) => a.localeCompare(b, undefined, { sensitivity: 'base' })))
+
 export function loadConfig(flags = {}) {
   const file = fromFile()
-  const cfg = { providers: file.providers, provider: file.provider, model: file.model, adhoc: null }
+  const cfg = { providers: byName(file.providers), provider: file.provider, model: file.model, adhoc: null }
   for (const k of SETTINGS) cfg[k] = flags[k] ?? file[k]
   if (cfg.context) cfg.context = Number(cfg.context)
 
@@ -100,7 +103,7 @@ export function loadConfig(flags = {}) {
 }
 
 export function saveConfig(cfg) {
-  const providers = { ...cfg.providers }
+  const providers = byName(cfg.providers)
   if (cfg.adhoc) delete providers[cfg.adhoc]
   const keep = cfg.adhoc && cfg.provider === cfg.adhoc ? fromFile() : null // the run-only provider isn't saved as current
   const out = { providers, provider: keep ? keep.provider : cfg.provider, model: keep ? keep.model : cfg.model }