heartcode 0.1.8 → 0.1.12

package/src/agent.js

@@ -104,7 +104,7 @@ export class Session {
     const body = native ? chat.messages.slice(head.length) : []
     const conversation = native ? transcript(body) : chat.history.map((h) => `User: ${h.task}\nAssistant: ${h.answer}`).join('\n\n')
     if (!conversation.trim()) return null
-    let room = Math.floor((strat.context * 0.6 * 3.5) / (strat.ratio ?? 1)) // characters of conversation the summary request can carry
+    const room = Math.floor((strat.context * 0.6 * 3.5) / (strat.ratio ?? 1)) // characters of conversation the summary request can carry
     const cut = () => (conversation.length > room ? `[… the earliest part is cut]\n${conversation.slice(-room)}` : conversation)
     const before = native ? size(body) : est(conversation)
     ui.spinner(midTask ? 'context almost full: compacting the conversation' : 'compacting the conversation')
@@ -114,17 +114,7 @@ export class Session {
     const request = (extra) => prompt('compact/summarize', { conversation: cut(), focus }) + extra
     const send = (extra) =>
       client.chat({ messages: strat.mergeSystem ? [{ role: 'user', content: `${prompt('compact/summarizer')}\n\n${request(extra)}` }] : [{ role: 'system', content: prompt('compact/summarizer') }, { role: 'user', content: request(extra) }] }, { signal })
-    // too large even for the summary request: send less of it (the newest part) until it fits
-    const ask = async (extra = '') => {
-      for (;;) {
-        try {
-          return await send(extra)
-        } catch (e) {
-          if (!e.inputLimit || room < 2000) throw e
-          room = Math.floor(Math.min(room, (e.inputLimit * 3.5) / (strat.ratio ?? 1)) * 0.7)
-        }
-      }
-    }
+    const ask = (extra = '') => send(extra)
     let summary = notSummary((await ask()).content)
     if (!summary) {
       log('compact', 'the reply was not a summary; asking again')
@@ -603,18 +593,12 @@ async function runNative(s, task, images, signal) {
     s.messages.push({ role: 'user', content: s.chat.branchNote }, { role: 'assistant', content: prompt('compact/acknowledged') })
     delete s.chat.branchNote
   }
-  let shrink = 1 // drops when the server says a request is too large
   s.compactedAt = -1
-  // What may be sent: the window less a tenth (estimates are estimates) and less room for the
-  // reply (the longest the model gives, from models.dev, at most a quarter of the window; 8k when
-  // unknown) and the tools; trimming keeps to it. Auto-compact starts at 90% of it, so it comes
-  // before any trimming.
-  // s.sizeCap: "too large" without the server saying its limit: a guess for this conversation only
-  const windowSize = () => Math.min(strat.context, s.sizeCap ?? Infinity)
-  const reply = () => Math.min(strat.reply || 8192, Math.floor(windowSize() * 0.25))
-  const budget = () => Math.floor(((windowSize() * 0.9 - reply()) * shrink) / (strat.ratio ?? 1)) - 800 // in estimated tokens
-  const nearlyFull = () => s.autoCompact && s.messages.length > 3 && size(s.messages) > budget() * 0.9
-  // Already near full from earlier messages: compact first, so the new message stays word for word.
+  // Auto-compact: every 100 messages, the conversation is summarized (what fits each model is
+  // models.dev's business and the model list's: one that fails, the next takes over)
+  const COMPACT_AT = 100
+  const nearlyFull = () => s.autoCompact && s.messages.length >= COMPACT_AT + (s.compactFailedAt ?? 0)
+  // Already that long from earlier messages: compact first, so the new message stays word for word.
   if (nearlyFull()) {
     await s.compact({ signal }).catch((e) => (e.name === 'AbortError' ? Promise.reject(e) : ui.warn(`could not compact: ${e.message}`)))
   }
@@ -657,17 +641,17 @@ async function runNative(s, task, images, signal) {
       ui.warn(`stopped after ${s.maxTurns} steps (--max-turns); say "continue" to go on`)
       throw Object.assign(new Error(`stopped after ${s.maxTurns} steps (--max-turns)`), { maxTurns: true })
     }
-    // after a failed compaction, the next try waits until the conversation grew by a fifth
-    if (nearlyFull() && s.messages.length > 4 && step !== s.compactedAt && size(s.messages) > (s.compactFailedAt ?? 0) * 1.2) {
+    // after a failed compaction, the next try waits for 20 more messages
+    if (nearlyFull() && step !== s.compactedAt) {
       s.compactedAt = step
-      await s.compact({ signal, midTask: true, task }).catch((e) => {
-        if (e.name === 'AbortError') throw e
-        // no summary: free the space anyway, by shortening older tool output and dropping the oldest turns
-        fitMessages(s.messages, Math.floor(budget() * 0.5))
-        s.compactFailedAt = size(s.messages)
-        ui.warn(`could not compact (${e.message}); shortened older tool output and messages instead`)
-        log('compact', `failed (${e.message}); trimmed to ~${s.compactFailedAt} tokens`)
-      })
+      await s.compact({ signal, midTask: true, task }).then(
+        () => (s.compactFailedAt = 0),
+        (e) => {
+          if (e.name === 'AbortError') throw e
+          s.compactFailedAt = (s.compactFailedAt ?? 0) + 20
+          log('compact', `failed (${e.message}); trying again 20 messages later`)
+        },
+      )
     }
     // what the user typed while it worked goes in before the next step (steering)
     const added = step && !s.isSub ? (ui.takeAhead?.() ?? []) : []
@@ -679,28 +663,13 @@ async function runNative(s, task, images, signal) {
     // the model answering can change mid-message (your model list): the system prompt follows it
     const now = SYSTEM(s)
     if (s.messages[0]?.content !== now && (s.messages[0]?.role === 'system' || strat.mergeSystem)) s.messages[0] = { ...s.messages[0], content: now }
-    fitMessages(s.messages, budget())
     pairTools(s.messages)
     ui.spinner('thinking')
     const out = ui.response(client.model) // named: helpers think too (theirs are named in helperUI)
     const stream = strat.toolsStream
-    let res
-    try {
-      // A long tool call (a whole file) streams in silently: say what's being written.
-      const onToolDelta = (name, args) => ui.spinner(`${name === 'run_command' ? 'preparing a command' : `writing ${/"path"\s*:\s*"([^"]+)"/.exec(args)?.[1] ?? name}`} · ${args.length >= 1000 ? `${(args.length / 1000).toFixed(1)}k` : args.length} chars`)
-      res = await client.chat({ messages: s.messages, tools, stream }, { signal, onToken: out.text, onReasoning: out.think, onToolDelta })
-    } catch (e) {
-      if (!e.inputLimit || shrink < 0.3) throw e
-      // what every request carries (the system prompt and the tools) is over the limit already: no
-      // 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
-      step--
-      continue
-    }
+    // A long tool call (a whole file) streams in silently: say what's being written.
+    const onToolDelta = (name, args) => ui.spinner(`${name === 'run_command' ? 'preparing a command' : `writing ${/"path"\s*:\s*"([^"]+)"/.exec(args)?.[1] ?? name}`} · ${args.length >= 1000 ? `${(args.length / 1000).toFixed(1)}k` : args.length} chars`)
+    const res = await client.chat({ messages: s.messages, tools, stream }, { signal, onToken: out.text, onReasoning: out.think, onToolDelta })
     ui.stopSpin()
     if (!stream) {
       out.think(res.reasoning)

package/src/client.js

@@ -164,7 +164,8 @@ export class Client {
   // 'stay' on the one that worked). onSwitch(target): a different model answered than before.
   setRotation(list, { on = 'failure', retries = 2, next = 'first' } = {}) {
     if (!list || list.length < 2) {
-      if (this.rotation) this.#use(this.rotation.list[0])
+      const t = list?.[0] ?? this.rotation?.list[0] // one model: that one (a new #1 from the settings page too)
+      if (t && (t.model !== this.model || normalizeBaseUrl(t.baseUrl) !== this.baseUrl || t.apiKey !== this.apiKey)) this.#use(t)
       this.rotation = null
       return
     }
@@ -184,12 +185,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 +226,12 @@ 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
+    // at any failure; "after retries": a failure waiting can fix (a rate limit, an outage) is tried again first
+    if (r.on === 'retries' && outage(e) && tries < r.retries) return false
+    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 +308,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))
   }
 
@@ -376,29 +402,15 @@ export class Client {
   // 60s, or the server's Retry-After) until it works or the signal aborts. onRetry(error, ms,
   // attempt) reports each wait; onRetry(null) reports the recovery.
   async chat(body, opts = {}) {
-    // "too large": never retried as is; the limit is learned and the caller sends less
-    const tooLarge = (e) => {
-      const limit = inputLimit(e, Math.round(estMessages(body.messages) * this.tokenRatio), this.knownGood)
-      if (!limit) return false
-      e.inputLimit = limit // this request is sent smaller
-      // remembered only when the server said the number (a guess isn't); a per-minute cap apart
-      const said = limitSaid(e)
-      log('limit', `request too large; ${said ? `the server says ${said.tokens}${said.rate ? ' per minute' : ''}` : `no limit given, trying ~${limit}`}`)
-      if (said) this.onInputLimit?.(said.tokens, { rate: said.rate })
-      return true
-    }
     if (!this.onRetry) {
-      try {
-        return await this.#timed(body, opts)
-      } catch (e) {
-        tooLarge(e)
-        throw e
-      }
+      return await this.#timed(body, opts)
     }
     let tries = 0 // of the model being tried now
     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
+    let rounds = 0 // whole rounds of the list that failed
+    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
     for (let attempt = 0; ; attempt++) {
       try {
         const r = await this.#timed(body, { ...opts, once: true })
@@ -408,30 +420,20 @@ export class Client {
         return r
       } catch (e) {
         if (e.name === 'AbortError' || opts.signal?.aborted) throw e
-        if (tooLarge(e)) throw e // the caller shrinks the conversation and sends again
         this.onFail?.(e, { provider: this.provider, model: this.model }) // counted for orchestration
-        if (this.retryIf && !this.retryIf(e, attempt)) throw e
-        // A bad request (400…) with a list of models: the next one may take it (it's often what the
-        // 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.onRetry(e, 0, attempt + 1, this.target)
-          continue
-        }
-        // A bad request (400…): the same request fails the same way every time, so it isn't sent
-        // again. It stops here, unless the model list moves on at any error (the settings page). A
-        // model that can't be used (a wrong key or name: 401, 403, 404) makes way for the next one
-        // in the list; a whole round of those stops too, rather than going round.
-        if (!outage(e) && !(unusable(e) && this.rotation) && this.rotation?.on !== 'any') throw e
+        // With a list of models, any failure makes way for the next one (another provider's first).
+        // Without one, only what waiting can fix is tried again.
+        if (!(this.rotation?.list.length > 1) && !outage(e)) throw e
+        if (this.retryIf && !this.retryIf(e, tries)) throw e // headless: --max-retries for one model
         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"
           if (++round >= this.rotation.list.length) {
             if (hard) throw e // every model refused it outright: going round again won't change that
+            if (this.retryIf && !this.retryIf(e, ++rounds)) throw e // headless: --max-retries whole rounds
             hard = true
             round = 0
             this.onRetry(e, 1000, attempt + 1, this.target)

package/src/config.js

@@ -72,9 +72,22 @@ function fromFile() {
 // cfg: { providers: {name: {baseUrl, apiKey}}, provider, model, context, adhoc }
 // flags > env > ~/.heart/config.json. A URL from flags or env becomes a provider for this run
 // only (cfg.adhoc), unless saved.
-// The model name that means your list: #1, then the fallbacks when one fails (also: no model given).
-// 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'
+// The model name that means your list: #1, then the next when one fails (also: no model given;
+// "default" is its old name). Any other model given for a run (-m, HEART_MODEL, a URL of its own)
+// is that model alone: fixed (--fallback-model adds others after it).
+export const AUTO_MODEL = 'auto'
+export const isAuto = (m) => m === AUTO_MODEL || m === 'default'
+
+// A model as given (-m, --fallback-model, /model): "provider/model" (as opencode writes it; split at
+// the first "/", provider names have none), the older "provider model", or a model of `current`.
+export function parseModel(v, providers, current) {
+  v = String(v).trim()
+  const spaced = /^(\S+)\s+(.+)$/.exec(v)
+  if (spaced && providers[spaced[1]]) return { provider: spaced[1], model: spaced[2] }
+  const i = v.indexOf('/')
+  if (i > 0 && providers[v.slice(0, i)]) return { provider: v.slice(0, i), model: v.slice(i + 1) }
+  return { provider: current, model: v }
+}
 
 // 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' })))
@@ -98,7 +111,7 @@ export function loadConfig(flags = {}) {
     cfg.providers[cfg.provider].apiKey = apiKey
   }
   const model = flags.model || process.env.HEART_MODEL
-  if (model && model !== DEFAULT_MODEL) Object.assign(cfg, { model, fixed: true })
+  if (model && !isAuto(model)) Object.assign(cfg, parseModel(model, cfg.providers, cfg.provider), { fixed: true })
   return cfg
 }
 

package/src/guided.js

@@ -225,14 +225,8 @@ class Guided {
 
   // `answer: true` streams the reply to the user as the answer; otherwise only thinking is shown.
   // room: tokens of context to keep free for the reply (only for fitting the context; never sent).
-  async query(question, opts = {}, tries = 0) {
-    try {
-      return await this.ask1(question, opts, tries)
-    } catch (e) {
-      // too large for the model: strat.context has dropped to its limit, so the context shrinks
-      if (!e.inputLimit || tries >= 3) throw e
-      return this.query(question, opts, tries + 1)
-    }
+  query(question, opts = {}) {
+    return this.ask1(question, opts)
   }
 
   async ask1(question, { room = 32, schema, oneLine, onToken, answer, skipKey } = {}, tries = 0) {

package/src/headless.js

@@ -150,6 +150,7 @@ export async function runHeadless(app, opts) {
     said = false
     current = { ctl: new AbortController() }
     app.signal = current.ctl.signal
+    app.working = true // settings changed meanwhile: MCP servers and skills wait for the end of it
     let answer = ''
     let error = null
     try {
@@ -162,6 +163,8 @@ export async function runHeadless(app, opts) {
       log('error', error, e.stack)
     } finally {
       app.save()
+      app.working = false
+      app.afterLine?.()
     }
     const subtype = current.maxTurns ? 'error_max_turns' : error ? 'error_during_execution' : 'success' // as Claude Code names them
     current = null