VAF v0.1.0a26

Added

• The usage log says how much of each request was served from cache. Every line in
  logs/usage_*.log now carries cache_hit as a percentage beside the raw token counts,
  so a session's behaviour can be read without adding anything up by hand. A provider
  that reports nothing about its cache leaves the field out entirely rather than printing
  a zero, so a lane that cannot measure does not look like a lane that is not working.

Changed

• The Soul questionnaire's first step asks a plainer question. "What are the
  undeniable truths it lives by?" read like a mission statement and gave you
  little to actually write down. The step now asks for the principles your agent
  follows when it decides something: what it is there for, how it works, and how
  it carries itself. The German wizard also drops the loftier step names:
  "Kernwahrheiten" is now "Grundsätze", and "Vibe" is now "Tonfall". Only the
  labels on screen change. The Soul file keeps its English section headings, so
  an existing soul.md and everything that reads it are untouched. The footnote
  about that file being English now gives the actual reason: language models
  cover English most broadly, so the same instructions land the same way on
  whichever model you run.

Fixed

• Two things happening at once can no longer make a call vanish from the spend
  record. The daily record is read, updated and written back as a whole, and several
  parts of VAF write into the same one: the web workers, the tray, background runs and
  every coding sub-process. Two of them starting at the same moment each wrote their own
  total, and whichever finished last overwrote the other, so a call was simply never
  counted. A half-written file read back as an empty record, which reset the day and
  left the daily spend limit with nothing to measure until the next write. Writers now
  take turns, per account, so two accounts never wait on each other.
• What the agent did during a turn is no longer rewritten the moment the turn ends.
  Every finished turn used to have its intermediate steps replaced by a short summary.
  That kept the conversation small, but it changed the middle of what gets sent, and a
  provider only charges the reduced rate for the part at the beginning that is unchanged
  since last time. So the first message of every new turn was paid for in full. The
  steps now stay as they are and are only condensed once the conversation genuinely
  approaches its limit, using the same threshold that already governed that. Measured
  against a live account, the first request of a new turn went from nothing reused to
  more than eighty per cent. This helps on every provider, including a local model,
  where it shows up as a faster first word rather than a smaller bill.
• The agent keeps a steady set of tools instead of a new one every message. It used
  to be handed only the handful of tools it seemed to need right then, which sounds
  frugal but meant every message looked new to the provider and nothing at all could be
  reused, not the tools and not the instructions or the conversation behind them. It now
  carries a fixed set of the tools it always needs, memory, delegation and the ability to
  look for others, and simply restricts which of them it may reach for on a given turn.
  Anything outside that set is still found and added the moment it is needed, and stays
  for the rest of the conversation. Measured against a live account: seven in ten tokens
  of a chat request are now reused, and the same conversation costs a third less. On
  providers that cannot express this, nothing changes.
• The agent's instructions stopped being rewritten on every message. Alongside the
  clock, two more parts of the instructions changed from turn to turn: the guidance the
  agent loads for the current kind of task, and the list naming which tools it may reach
  for. Both sat near the front, so both threw away the discount on everything behind
  them. They now travel at the end of the conversation, and the instructions themselves
  are byte-for-byte identical from one message to the next. Nothing was dropped and
  nothing was frozen: the guidance still adapts to what you asked for, it just no longer
  costs the whole request to do so.
• A conversation with the agent got dramatically cheaper after the first message.
  Providers charge about a tenth for the part of a request they have already seen, but
  only for the stretch at the very beginning that has not changed since. The current
  time sat near the front of the agent's instructions, so every turn looked new and the
  whole request was billed at full price, every time. The clock now travels in a short
  block at the end of the conversation, where it costs only itself. Measured against a
  live account with the same three questions: the chat request went from nothing served
  from cache to 97 per cent. The agent still knows the time, and its instructions say
  where to look for it.
• A block that came and went no longer sits at the very front of the agent's
  instructions. Providers charge far less for the part of a request they have seen
  before, but only for the stretch at the beginning that is unchanged. One status
  block was inserted ahead of everything else whenever the agent switched into
  planning mode, and switched off again two turns later, which made the whole
  request look new every time. Measured on a live account, the chat request was
  paying full price on every single turn while a neighbouring lane on the same
  account paid a tenth. The block is unchanged and still shown, it now sits at the
  end of the instructions instead of the start.
• The usage view counted every call's tokens against the wrong call. Providers
  report what a request cost in a final piece of the response that carries no text,
  so VAF recorded the figures but read them one step too early: each call was booked
  with the previous call's token counts, and the very first call of a session was
  booked with a rough guess instead. Totals over a long session came out close
  enough that nothing looked wrong, while any single line was somebody else's. The
  figures are now read after the response ends, including when a reply is cut short.
  Records written before this are not corrected; they were never far off in total.
• An account without admin rights no longer receives cost amounts in the usage
  view. The page has always been meant to show you your own consumption and to
  keep what the instance's API keys cost to the operator, and the filter that did
  that named the fields to remove rather than the fields to send. Anything the
  records learned afterwards therefore went out by default: the per-currency
  amount has been included since it was added, and the new figure for what
  caching saved would have followed it. The filter now names what may be sent, so
  a field added later is withheld until somebody decides otherwise. Your own token
  and call counts are unchanged, including how much of your prompt was served from
  a cache.
• The cost figure now counts what a cached prompt actually costs, and the daily
  spend limit counts with it. Every provider serves the repeated part of a long
  conversation from a cache and bills it at a fraction of the normal price, and none
  of that reached the estimate. On Anthropic the cached part was not counted at all,
  so the figure was far too low and a daily limit did not stop where you set it. On
  OpenAI and the providers shaped like it the whole prompt was charged at full price,
  so the figure was too high. Both are corrected, per provider, at the cached rate
  each one publishes. Where a provider publishes no cached rate the full price is
  still assumed, which keeps the figure an upper bound rather than a guess. The Usage
  view can also show how much of what you send is being served from a cache, and a
  provider that does not report it is shown as not reporting rather than as zero.
• Four provider settings can no longer be changed by everyone on the network.
  Whether Anthropic caches the prompt, whether Anthropic and Google show their
  reasoning, and which endpoint the browser agent, local vision and the failover
  lane send their prompts to were all writable by any non-admin account on the
  machine's network. The first three decide what every request on the instance
  sends and therefore what everyone's tokens cost; the last decides where prompts
  leave the machine. All four are now admin-only, like the other backend settings
  around them. If you changed one of them from a non-admin account, ask an admin
  to set it instead.
• Provider errors reach the log again. When a model provider refused a request,
  VAF showed the error in the chat but wrote nothing to logs/backend_*.log, even though
  the debugging guide has always said that is where provider errors go. The line meant to
  write it named a module that does not exist, and because the write is wrapped in a
  catch-all the failure was silent, for every provider, since the line was written. It
  writes now. A check was added alongside it: an import naming a module that was never
  there now fails the test suite instead of quietly removing a feature.
• The first-run setup no longer looks like a login, and its step bar fits on one
  line. The header above every setup step announced "User Login" on a page where
  nobody has an account yet; during setup it now says so, in your language. The bar
  underneath it has five steps but was laid out on a grid built for four, so the
  last step dropped underneath the fourth instead of standing next to it, and the
  "Veyllo API" label broke over two lines. Both are fixed, and two German lines on
  the agent-name step got their umlauts back.
• The interactive browser works on Apple Silicon. Its window stayed empty and
  the server answered a 502, and it could not be repaired either, because the
  browser image refused to build on an arm64 machine at all: the build fetched the
  display server package for the wrong processor and the install broke off. The
  processor is now taken from the builder instead of defaulting to Intel, and a
  build that cannot tell which processor it is for stops and says how to tell it,
  rather than guessing. On an Intel machine the guess happened to be right, which
  is why this never showed up anywhere else.
• A browser that shows you nothing is no longer called healthy. The browser
  container has two halves: the part the agent steers and the part you actually
  see. Only the first was checked, so a container whose picture never came up was
  handed out as working and greeted you with an error the moment you opened it.
  Both halves are checked now, in the container itself and before a browser is
  handed to you, and the log names which half failed and what to do about it.
• The containers VAF builds itself are rebuilt when you start it. The browser
  and the speech container are built from the source on your machine rather than
  downloaded, and starting VAF reused whatever had been built before, however old.
  One machine ran an image sixteen days behind its own code, missing a whole
  feature, with everything reporting healthy the entire time. Updating could not
  have fixed it either, because updating never rebuilds these. They are rebuilt on
  start now, which costs seconds when nothing changed. A build that fails also
  reports what the builder said instead of blaming the clock.
• The chat follows the answer again, and stays put while you read. Sending a
  message did not bring the view back down to the newest content, so your own
  message and the whole reply could appear out of sight below. Reading something
  further up while an answer was still arriving pulled you back down. In the
  desktop window it was worse: with an image in the conversation, every single
  keystroke jumped the view onto that image. Four separate causes, from a
  detection that was never switched on to a scroll instruction that this window
  ignores entirely. Sending now returns the view to the newest message, and
  scrolling up holds where you left it.
• Local image recognition works. Asking about an attached image answered that
  vision was unavailable, even with everything configured. The second file a local
  model needs to see pictures was being fetched under a name only one model family
  uses, so for the other the download failed, and the failure went to the screen
  for a moment instead of into the log. The name is now read from where the file
  actually lives, and a failure is written down.
• Stopping VAF stops VAF. The stop command reported success while everything
  kept running, or claimed nothing was running while it was. Afterwards an update
  could install fine and you would still be served the old version, with nothing
  to indicate it. On macOS the same command also left the web interface holding its
  port, because two of the commands it used exist only on Linux.
• You get the browser back when the agent is done with it. If you had opened
  the interactive browser yourself, the agent only borrows it and is supposed to
  hand it back at the end, on the page it left behind. Instead the window stayed
  in the agent view for good, with neither control nor that page. The browser can
  run as your own instance or as the shared one, and which of the two you get is
  decided separately when you open it and again when an agent starts. If that
  answer changed in between, the agent handed the browser back to a different one
  than you were holding, so the message that you may take over was never sent at
  all and your window waited for it forever. The hand-back now follows your
  session wherever it is.
• A release cannot be published unless the frontend builds first. The release
  check ran the Python tests only, so a version could be published, and offered to
  everyone as an update, without the web interface having been built on any
  machine. That is exactly how the previous release shipped an app that stopped at
  the splash screen. The frontend is now built on Linux, macOS and Windows before
  a release is created.