ravensight-playtest 0.7.0 → 0.7.5

package/src/run/budgetReserve.js

@@ -0,0 +1,102 @@
+import { OUTPUT_WEIGHT } from './usage.js';
+
+/**
+ * Keeping enough of a run's model budget back to write its report.
+ *
+ * The proxy reserves each call's pessimistic projection before sending it:
+ * the whole request body at the full input rate (characters / 3.5) plus the
+ * output ceiling at the output rate. A call whose projection does not fit
+ * what is left of the run's budget is refused with 402 before anything is
+ * sent. The server's own warning comes at 80 percent of the budget, counting
+ * the call being made, and in the October 26 runs it never came: one act
+ * turn's projection jumped the run from under 80 percent to a refusal, and the
+ * report that followed did not fit either.
+ *
+ * So before every act turn the loop asks this module whether, after that
+ * turn, the report call would still be admitted. Both projections are sized
+ * from the requests themselves (the act turn about to be sent and the report
+ * prompt as it would be built now), in input-token units, and priced at what
+ * one unit has actually cost this run (the server's spend over the ledger's
+ * weighted tokens, ./usage.js). No price is held here.
+ */
+
+/** Characters per input token, the proxy's own projection rule. */
+export const CHARS_PER_INPUT_TOKEN = 3.5;
+
+/**
+ * Headroom on the report's projection: the prompt grows by the notes and
+ * observations of the turn still to be played, and a persona that escalates
+ * may write it on a dearer tier than the one the unit price was learned on.
+ */
+export const REPORT_RESERVE_MARGIN = 1.3;
+
+/** Headroom on what the next act turn will really cost, over the dearest recent one. */
+export const ACT_COST_MARGIN = 1.5;
+
+/** A flat share of the run's budget never planned against. */
+export const FLAT_MARGIN_RATIO = 0.03;
+
+/**
+ * The proxy's projection of a request, in input-token units.
+ *
+ * @param {number} bodyChars the request's JSON length
+ * @param {number} maxTokens its output ceiling
+ * @returns {number}
+ */
+export function projectionUnits(bodyChars, maxTokens) {
+  return Math.max(0, Number(bodyChars) || 0) / CHARS_PER_INPUT_TOKEN + Math.max(0, Number(maxTokens) || 0) * OUTPUT_WEIGHT;
+}
+
+/**
+ * Whether play has to stop now so the report still fits.
+ *
+ * @param {Object} args
+ * @param {number|null} args.usdMax the run's model budget, from register
+ * @param {{usd: number, usdPerUnit: number}|null} args.spend the ledger's estimate
+ * @param {number} args.actChars the next act request's JSON length
+ * @param {number} args.actMaxTokens
+ * @param {number} args.actCostUnits what an act turn has really cost, at most, lately
+ * @param {number} args.reportChars the report request's JSON length if it were sent now
+ * @param {number} args.reportMaxTokens
+ * @returns {{stop: boolean, known: boolean, figures: Object}}
+ */
+export function reserveDecision({ usdMax, spend, actChars, actMaxTokens, actCostUnits, reportChars, reportMaxTokens }) {
+  const max = Number(usdMax);
+  if (!Number.isFinite(max) || max <= 0 || !spend || !Number.isFinite(spend.usdPerUnit) || spend.usdPerUnit <= 0) {
+    return { stop: false, known: false, figures: {} };
+  }
+  const price = spend.usdPerUnit;
+  const actProjected = price * projectionUnits(actChars, actMaxTokens);
+  const actCost = price * Math.max(0, Number(actCostUnits) || 0) * ACT_COST_MARGIN;
+  const reportProjected = price * projectionUnits(reportChars, reportMaxTokens) * REPORT_RESERVE_MARGIN;
+  const flat = max * FLAT_MARGIN_RATIO;
+  // The act turn itself has to be admitted, and after it the report has to be.
+  const actFits = spend.usd + actProjected <= max;
+  const reportFitsAfter = spend.usd + actCost + reportProjected + flat <= max;
+  const round = value => Math.round(value * 1e6) / 1e6;
+  return {
+    stop: !actFits || !reportFitsAfter,
+    known: true,
+    figures: {
+      usd_max: round(max),
+      usd_spent: round(spend.usd),
+      act_projected_usd: round(actProjected),
+      act_cost_usd: round(actCost),
+      report_reserve_usd: round(reportProjected),
+      margin_usd: round(flat)
+    }
+  };
+}
+
+/**
+ * A registered run's model budget in USD: `limits.model_usd`, or the older
+ * `budget_usd` beside it. Null when the server sent neither, which leaves the
+ * reserve off and the server's own warning in charge.
+ *
+ * @param {Object} entry a run from the register answer
+ * @returns {number|null}
+ */
+export function runModelBudgetUsd(entry) {
+  const value = Number(entry && ((entry.limits && entry.limits.model_usd) ?? entry.budget_usd));
+  return Number.isFinite(value) && value > 0 ? value : null;
+}

package/src/run/context.js

@@ -165,17 +165,136 @@ export function pruneObservations(messages, keep = KEEP_OBSERVATIONS) {
   return out;
 }
 
+/** What a tool_result with nothing in it is sent as. */
+export const EMPTY_TOOL_RESULT_TEXT = '(no output)';
+
+/** The tool_result for a tool_use the runner never answered. */
+export const MISSING_TOOL_RESULT_TEXT = 'Not run: the runner did not play this call.';
+
+/**
+ * Make every tool_result in the conversation one the Messages API accepts.
+ *
+ * The rules the API enforces, and what each repair is:
+ *
+ * - **An `is_error` result is text only.** A result flagged `is_error` that
+ *   also carries an image block is refused with a 400. That is the 0.7.2
+ *   failure: a refused off-site `navigate` on a canvas build came back as
+ *   "That did not work: ..." plus the screenshot, flagged as an error, and
+ *   every persona of the job died on its next turn. The screenshot is the
+ *   persona's only view of a canvas game, so the image stays and the flag
+ *   goes: the text already says the action did not work.
+ * - **Content is never empty.** An empty string, an empty array or a text
+ *   block with no text becomes {@link EMPTY_TOOL_RESULT_TEXT}; a non-string,
+ *   non-array content becomes its string form.
+ * - **Exactly one result per tool_use, in the very next user message.** A
+ *   missing result is added ({@link MISSING_TOOL_RESULT_TEXT}); a second
+ *   result for one id, and a result whose id the assistant turn before it
+ *   never used, are dropped. A user message left with nothing gets the empty
+ *   text, because an empty message is refused too.
+ *
+ * A new array; the input is not mutated.
+ *
+ * @param {Array} messages
+ * @returns {Array}
+ */
+export function validToolResults(messages) {
+  const out = messages.map(message => message);
+  for (let i = 0; i < out.length; i += 1) {
+    const message = out[i];
+    if (!message || message.role !== 'user' || !Array.isArray(message.content)) continue;
+    const previous = i > 0 ? out[i - 1] : null;
+    const expected = previous && previous.role === 'assistant' && Array.isArray(previous.content)
+      ? previous.content.filter(block => block && block.type === 'tool_use').map(block => block.id)
+      : [];
+    const seen = new Set();
+    const content = [];
+    for (const block of message.content) {
+      if (!block || block.type !== 'tool_result') {
+        content.push(block);
+        continue;
+      }
+      if (!expected.includes(block.tool_use_id) || seen.has(block.tool_use_id)) continue;
+      seen.add(block.tool_use_id);
+      content.push(validToolResult(block));
+    }
+    const missing = expected.filter(id => !seen.has(id))
+      .map(id => ({ type: 'tool_result', tool_use_id: id, content: [{ type: 'text', text: MISSING_TOOL_RESULT_TEXT }] }));
+    // Results go first in the message: the API wants them before any text.
+    const results = [...content.filter(block => block && block.type === 'tool_result'), ...missing];
+    const rest = content.filter(block => !(block && block.type === 'tool_result'));
+    const next = [...results, ...rest];
+    out[i] = { ...message, content: next.length > 0 ? next : [{ type: 'text', text: EMPTY_TOOL_RESULT_TEXT }] };
+  }
+  return out;
+}
+
+/**
+ * One tool_result made valid. See {@link validToolResults}.
+ *
+ * @param {Object} block
+ * @returns {Object}
+ */
+export function validToolResult(block) {
+  let content = block.content;
+  if (typeof content === 'string') {
+    content = content.trim() ? content : EMPTY_TOOL_RESULT_TEXT;
+  } else if (Array.isArray(content)) {
+    content = content
+      .filter(child => child && (child.type !== 'text' || (typeof child.text === 'string' && child.text.trim())))
+      .map(child => child);
+    if (content.length === 0) content = [{ type: 'text', text: EMPTY_TOOL_RESULT_TEXT }];
+  } else {
+    content = content === undefined || content === null || String(content).trim() === '' ? EMPTY_TOOL_RESULT_TEXT : String(content);
+  }
+  const result = { ...block, content };
+  if (result.is_error && Array.isArray(content) && content.some(child => child.type !== 'text')) delete result.is_error;
+  return result;
+}
+
+/**
+ * Every tool_result in the newest user message rewritten as plain text with
+ * no `is_error` flag and no image: the one repair the persona loop makes
+ * when the provider refuses a turn it cannot otherwise explain, before it
+ * gives up on the conversation. The text keeps what the persona was told.
+ *
+ * @param {Array} messages
+ * @returns {Array} a new array; the input is not mutated
+ */
+export function repairLastTurn(messages) {
+  const out = validToolResults(messages);
+  for (let i = out.length - 1; i >= 0; i -= 1) {
+    const message = out[i];
+    if (!message || message.role !== 'user' || !Array.isArray(message.content)) continue;
+    out[i] = {
+      ...message,
+      content: message.content.map(block => {
+        if (!block || block.type !== 'tool_result') return block;
+        const texts = Array.isArray(block.content)
+          ? block.content.filter(child => child.type === 'text').map(child => child.text)
+          : [String(block.content)];
+        const text = texts.join('\n').trim() || EMPTY_TOOL_RESULT_TEXT;
+        const { is_error: _flag, ...rest } = block;
+        return { ...rest, content: [{ type: 'text', text }] };
+      })
+    };
+    break;
+  }
+  return out;
+}
+
 /**
  * Both ceilings, in the order that matters: drop stale observations first
  * (which removes their images too), then enforce the image budget on what
- * is left.
+ * is left, then make every tool_result one the API accepts (which has to
+ * come last: whether an `is_error` result still carries an image is only
+ * known once the image budget is applied).
  *
  * @param {Array} messages
  * @param {{maxImages?: number, keepObservations?: number}} [opts]
  * @returns {Array}
  */
 export function prepareMessages(messages, { maxImages = MAX_IMAGES_IN_CONTEXT, keepObservations = KEEP_OBSERVATIONS } = {}) {
-  return pruneImages(pruneObservations(messages, keepObservations), maxImages);
+  return validToolResults(pruneImages(pruneObservations(messages, keepObservations), maxImages));
 }
 
 /**
@@ -189,4 +308,4 @@ export function shrinkImages(current) {
   return Math.max(0, Math.floor(current / 2));
 }
 
-export default { prepareMessages, pruneImages, pruneObservations, countImages, shrinkImages, MAX_IMAGES_IN_CONTEXT, KEEP_OBSERVATIONS };
+export default { prepareMessages, validToolResults, validToolResult, repairLastTurn, pruneImages, pruneObservations, countImages, shrinkImages, MAX_IMAGES_IN_CONTEXT, KEEP_OBSERVATIONS };