humanish 0.132.0 → 0.133.1

package/CHANGELOG.md

@@ -8,6 +8,30 @@ The Unreleased section holds the full notes for the next version until it is tag
 
 ## Unreleased
 
+## 0.133.1: Hosted runs keep writing run.json past 512 MiB of traces (2026-10-14)
+
+humanish 0.133.1 keeps a hosted run writing run.json once its finished participants' traces
+together pass V8's longest string, 536,870,888 characters. The sandbox id scrub serialized the whole
+bundle into one string on every write, so past that size every write threw and run.json, the trace
+files, review.json and events.ndjson stopped updating. It now scrubs the bundle and each participant
+apart and writes the same bytes. On synthetic runs at a recorded hosted run's density, a snapshot
+write of 10 participants of 10 MiB took 3.8 seconds where it took 4.7, at half the peak memory.
+
+[Release notes](https://github.com/danielgwilson/humanish/releases/tag/v0.133.1)
+
+## 0.133.0: An OpenAI participant names how long it waits (2026-10-14)
+
+humanish 0.133.0 lets an OpenAI computer-use participant name how long it waits, with a
+`wait_minutes` tool, and cuts what a participant costs while nothing on its screen changes. A turn of
+only waits is watched, and each further quiet wait in a row lasts twice as long, starting from the
+length the participant named, up to 10 minutes. In live 60-minute runs against 0.132.0, median model
+spend per participant-hour fell 13% on a resident portal, 52% on a support queue, 46% on an issue
+list that shows new issues only on reload, and 78% on a dispatch board, and all 6 participants on
+the issue list reloaded and reported every new issue. verify and analysis also no longer fail on a
+run whose traces together pass 512 MiB.
+
+[Release notes](https://github.com/danielgwilson/humanish/releases/tag/v0.133.0)
+
 ## 0.132.0: An OpenAI participant's closing report reads the prompt cache (2026-10-13)
 
 humanish 0.132.0 cuts the cost of an OpenAI computer-use participant's closing report. The closing

package/dist/actors/codex/restricted-participant.d.ts

@@ -22,6 +22,8 @@ export interface RestrictedParticipantOptions {
      * defaults the loop applies without it (resolveWaitSettings).
      */
     maxWaitMs?: number;
+    /** The participant's idleWaitMs, the shortest a call of only waits lasts, stated the same way. */
+    idleWaitMs?: number;
 }
 /** What doctor's hosted-participant check found, before any turn. */
 export interface ParticipantReadiness {

package/dist/actors/codex/restricted-participant.js

@@ -41,7 +41,7 @@ function deferred() {
     return { promise, resolve, reject };
 }
 // prose-check: model prompt (Codex reads this tool description, not a person)
-const toolDescription = (speechEnabled, { maxWaitMs, watchMaxMs }) => `Act on the participant's browser through humanish. Submit one to four UI actions${speechEnabled ? ", including speak when you need to reply aloud," : ""} and a short public comment; never private reasoning. humanish returns a JSON STRING with execution acknowledgments${speechEnabled ? ", speech heard from the actual participant speaker sink," : ""} and a fresh screenshot. In Code Mode use: const r = JSON.parse(await tools.humanish_ui({narration: "...", actions: [...]})); text({acknowledgments: r.acknowledgments${speechEnabled ? ", heardSpeech: r.heardSpeech" : ""}, contextHint: r.contextHint, closing: r.closing}); image(r.imageUrl). Call serially and inspect each returned screenshot${speechEnabled ? " and heardSpeech array" : ""} before deciding what to do next. A call whose actions are only waits returns when the screen changes and holds still${speechEnabled ? ", when speech is heard" : ""}, or after its waits' ms, together at most ${watchMaxMs} ms. While no change on the screen holds still, each further such call in a row waits twice as long as the one before, up to ${watchMaxMs} ms, and contextHint says how long it waited and why it returned. A wait among other actions lasts its ms, at most ${maxWaitMs} ms.${speechEnabled ? " Use speak only after the visible UI shows that you joined the call and your microphone is unmuted; it sends audio into that call." : ""} Acknowledged input does not prove an application outcome. If closing is true, stop calling tools and give your final account.`;
+const toolDescription = (speechEnabled, { maxWaitMs, watchMaxMs, idleWaitMs, }) => `Act on the participant's browser through humanish. Submit one to four UI actions${speechEnabled ? ", including speak when you need to reply aloud," : ""} and a short public comment; never private reasoning. humanish returns a JSON STRING with execution acknowledgments${speechEnabled ? ", speech heard from the actual participant speaker sink," : ""} and a fresh screenshot. In Code Mode use: const r = JSON.parse(await tools.humanish_ui({narration: "...", actions: [...]})); text({acknowledgments: r.acknowledgments${speechEnabled ? ", heardSpeech: r.heardSpeech" : ""}, contextHint: r.contextHint, closing: r.closing}); image(r.imageUrl). Call serially and inspect each returned screenshot${speechEnabled ? " and heardSpeech array" : ""} before deciding what to do next. A call whose actions are only waits and that asks for some wait time asks to wait its waits' ms together; an ask under ${idleWaitMs} ms counts as ${idleWaitMs} ms, and named ms count up to ${watchMaxMs} ms${speechEnabled ? ". It returns when speech is heard" : ""}. contextHint says how long it waited and why it returned. A wait among other actions lasts its ms, at most ${maxWaitMs} ms.${speechEnabled ? " Use speak only after the visible UI shows that you joined the call and your microphone is unmuted; it sends audio into that call." : ""} Acknowledged input does not prove an application outcome. If closing is true, stop calling tools and give your final account.`;
 const participantInstructions = (prompt, speechEnabled) => `${prompt}\n\nYou are the study participant throughout this conversation, including its closing account. Use only the supplied screenshots and humanish_ui tool to interact. The tool returns a JSON string: parse it, inspect acknowledgments${speechEnabled ? " and heardSpeech captured from the actual participant speaker sink" : ""}, and display imageUrl with Code Mode image(). Do not print the image data URL as text. Keep your persona and earlier observations throughout the session.${speechEnabled ? " A speak action plays into the participant microphone; use it only after the visible UI shows that you joined the call and the microphone is unmuted." : ""} Speak publicly about your experience, never reveal private reasoning. Completed inputs do not prove application outcomes; verify on the next screenshot. When the task ends, return only the required final JSON with outcome, summary, frictionReports and impressions. Report observed confusion and recovered mistakes as well as blockers. ${IMPRESSIONS_ASK} Do not invent observations.`;
 /** Turns and failures from the native run, handed in order to the next provider request. */
 class ParticipantEvents {
@@ -192,7 +192,11 @@ function participantSession(options, speechEnabled, effort, call) {
             reasoningEffort: effort,
             tool: {
                 name: "humanish_ui",
-                description: toolDescription(speechEnabled, resolveWaitSettings({ maxWaitMs: options.maxWaitMs, speechEnabled })),
+                description: toolDescription(speechEnabled, resolveWaitSettings({
+                    maxWaitMs: options.maxWaitMs,
+                    idleWaitMs: options.idleWaitMs,
+                    speechEnabled,
+                })),
                 inputSchema: participantToolSchema(speechEnabled),
                 call,
             },

package/dist/actors/computer-use/loop/actions.js

@@ -209,6 +209,7 @@ export async function runActionBatch(session, actions, watched) {
                 ? { coord: { x: action.x, y: action.y } }
                 : {}),
             ...(watched !== undefined && waitIndex === watched.endedOn ? { watch: watched.watch } : {}),
+            ...(requested.kind === "wait" && requested.ms !== undefined ? { namedMs: requested.ms } : {}),
         }));
     }
     return { execution, hint: hint() };

package/dist/actors/computer-use/loop/types.d.ts

@@ -328,12 +328,12 @@ export interface CuaLoopOptions {
     maxWaitMs?: number;
     /**
      * How long a `wait` that names no duration lasts, in ms, when its turn only waits or takes
-     * screenshots: the study's actor.idleWaitMs. It is also how often the loop looks at the screen
-     * while such a turn is watched, at most every 30000 ms when the executor is speechEnabled. After
-     * an action in the same turn such a wait lasts 500 ms. A whole number from 1000 to 600000 and no
-     * longer than an explicit maxWaitMs; any other value throws a RangeError before the session
-     * starts. Default 5000. The session never applies more than its maxWaitMs, and the trace records
-     * the applied lengths as `waitSettings`.
+     * screenshots: the study's actor.idleWaitMs. It is also the shortest such a turn is watched for,
+     * and how often the loop looks at the screen while it is watched, at most every 30000 ms when the
+     * executor is speechEnabled. After an action in the same turn such a wait lasts 500 ms. A whole
+     * number from 1000 to 600000 and no longer than an explicit maxWaitMs; any other value throws a
+     * RangeError before the session starts. Default 5000. The session never applies more than its
+     * maxWaitMs, and the trace records the applied lengths as `waitSettings`.
      */
     idleWaitMs?: number;
     /**

package/dist/actors/computer-use/loop/watch.js

@@ -50,10 +50,13 @@ export class IdleWatcher {
         if (plannedMs === 0)
             return undefined;
         const capMs = Math.max(plannedMs, session.waits.watchMaxMs);
-        // Never shorter than the turn's own planned length, so a long named wait is not cut short.
+        // Never shorter than idleWaitMs, so a participant naming a few milliseconds on a static screen
+        // does not send requests back to back, and never shorter than the turn's own planned length, so
+        // a long named wait is not cut short.
+        const shortestMs = Math.max(plannedMs, session.waits.idleWaitMs);
         const limitMs = this.grownFromMs === undefined
-            ? plannedMs
-            : Math.min(capMs, Math.max(plannedMs, 2 * this.grownFromMs));
+            ? shortestMs
+            : Math.min(capMs, Math.max(shortestMs, 2 * this.grownFromMs));
         const ending = await watchScreen(session, this.observer, turnNumber, reference, limitMs);
         // A small change that held still (a status label, or a counter the rule did not hold back)
         // wakes the participant and keeps the doubling, so a repeating small change cannot keep every
@@ -64,7 +67,7 @@ export class IdleWatcher {
             wake: ending.wake,
             ...(ending.observation === undefined ? {} : { observation: ending.observation }),
             ...(ending.stop === undefined ? {} : { stop: ending.stop }),
-            hint: hintFor(ending, grows && limitMs < capMs ? capMs : undefined),
+            hint: hintFor(ending),
             waits: {
                 ...splitWatch(lengths, limitMs, ending.ms),
                 sessionEnded: ending.stop !== undefined,
@@ -215,21 +218,18 @@ function splitWatch(lengths, limitMs, ms) {
     };
 }
 /**
- * The next request's note. A clock ending says nothing: the clock text that follows says it. A
+ * The next request's note. A clock ending says only how long the wait lasted. A
  * small change is named by its place, so a participant is not told the screen changed when what
- * changed was a counter or a timestamp. `growsToMs` adds the growth sentence when the next watch
- * doubles.
+ * changed was a counter or a timestamp. The note says nothing of the next wait's length: a
+ * participant told it names that length and keeps waiting.
  */
-function hintFor(ending, growsToMs) {
+function hintFor(ending) {
     const lasted = `Your wait lasted ${duration(ending.ms)}`;
-    const grows = growsToMs === undefined
-        ? ""
-        : ` A wait right after it can last twice as long, at most ${duration(growsToMs)}.`;
     const { seen } = ending;
     switch (ending.wake) {
         case "changed":
             return seen?.verdict === "settled" && seen.small
-                ? `${lasted} and ended when a small part of the screen changed and then stayed the same for over a minute, ${place(seen.area)}.${grows}`
+                ? `${lasted} and ended when a small part of the screen changed and then stayed the same for over a minute, ${place(seen.area)}.`
                 : `${lasted} and ended when the screen changed.`;
         case "speech":
             return `${lasted} and ended when you heard speech.`;
@@ -239,13 +239,15 @@ function hintFor(ending, growsToMs) {
         // never says the screen stayed the same.
         case "limit":
             if (seen?.verdict === "changing" && seen.lookSoon)
-                return `${lasted}; a large part of the screen was changing at its last check.${grows}`;
+                return `${lasted}; a large part of the screen was changing at its last check.`;
             if (seen?.verdict !== "settled" && seen?.held !== undefined)
-                return `${lasted}; a small part of the screen changed and stayed the same, ${place(seen.held)}. A small change does not end a wait.${grows}`;
-            return `${lasted}; no change on the screen held still long enough to end it.${grows}`;
+                return `${lasted}; a small part of the screen changed and stayed the same, ${place(seen.held)}. A small change does not end a wait.`;
+            return `${lasted}; no change on the screen held still long enough to end it.`;
         case "stalled":
             return `${lasted}; the screen could not be checked during it.`;
+        // The clock text that follows says why the wait ended.
         case "clock":
+            return `${lasted}.`;
         case "stopped":
             return undefined;
     }

package/dist/actors/computer-use/openai-context.js

@@ -4,16 +4,17 @@ import { asArray, asRecord, inputMessage, openAiActionToCua } from "./openai-wir
 // provider still threads on previous_response_id feed it too, so a switch partway through a
 // session keeps everything before the switch.
 //
-// The Responses API pairs items: every computer_call needs its computer_call_output, and a
-// reasoning item travels with the item it preceded. The conversation is therefore cut only at
-// exchange boundaries: one reply's output items together with the items that answered them.
-// When the estimate passes the budget, the conversation is cut down to half the budget in one
-// step: the opening screenshot goes first, then the oldest exchanges become lines of a progress
-// note that keeps their reasoning summaries, messages and actions, and the text that answered
-// them, such as a note that an action was not run. The note is an assistant message, so text the
-// model wrote (which can quote a web page) keeps the trust it had when the model wrote it. The newest MIN_KEPT_EXCHANGES exchanges are never collapsed, so a
-// request passes the budget when they alone exceed it; the trace's per-request estimate shows when
-// that happens.
+// The Responses API pairs items: every computer_call needs its computer_call_output, every
+// function_call (wait_minutes) its function_call_output, and a reasoning item travels with the
+// item it preceded. The conversation is therefore cut only at exchange boundaries: one reply's
+// output items together with the items that answered them. When the estimate passes the budget, the
+// conversation is cut down to half the budget in one step: the opening screenshot goes first, then
+// the oldest exchanges become lines of a progress note that keeps their reasoning summaries,
+// messages, actions and function calls, and the text that answered them, such as a note that an
+// action was not run or how a wait ended. The note is an assistant message, so text the model wrote
+// (which can quote a web page) keeps the trust it had when the model wrote it. The newest
+// MIN_KEPT_EXCHANGES exchanges are never collapsed, so a request passes the budget when they alone
+// exceed it; the trace's per-request estimate shows when that happens.
 //
 // A cut rewrites the start of the prompt, so the provider's prompt cache misses on the request
 // after it. Between cuts nothing already sent changes: each request starts with the whole of the
@@ -156,12 +157,15 @@ function describeExchange(exchange) {
     const said = [];
     const did = [];
     const told = [];
-    // The answers are the call outputs, whose content is a screenshot, and hint messages.
+    // The answers are the computer_call outputs, whose content is a screenshot, the function call
+    // outputs, which say how a wait ended as text beside any screenshot, and hint messages.
     for (const raw of exchange.answers) {
         const item = asRecord(raw);
         if (item.type === "computer_call_output")
             continue;
-        for (const entry of asArray(item.content)) {
+        if (typeof item.output === "string" && item.output.length > 0)
+            told.push(item.output);
+        for (const entry of [...asArray(item.content), ...asArray(item.output)]) {
             const text = asRecord(entry).text;
             if (typeof text === "string" && text.length > 0)
                 told.push(text);
@@ -189,6 +193,11 @@ function describeExchange(exchange) {
                     did.push(describeAction(mapped));
             }
         }
+        // A function call is noted as it was made, such as wait_minutes {"minutes":3}.
+        if (item.type === "function_call" && typeof item.name === "string")
+            did.push(typeof item.arguments === "string"
+                ? `${item.name} ${clip(item.arguments, 120)}`
+                : item.name);
     }
     const lead = `Turn ${exchange.turn}: `;
     const before = [
@@ -224,14 +233,17 @@ function clip(text, limit) {
     const flat = text.replace(/\s+/g, " ").trim();
     return flat.length <= limit ? flat : `${flat.slice(0, limit - 3)}...`;
 }
-/** The data URLs of the images an input item carries. */
+/**
+ * The data URLs of the images an input item carries: a computer_call output's screenshot, and the
+ * image parts of a message's content or a function call output's output.
+ */
 function imagesOf(item) {
     const record = asRecord(item);
     const output = asRecord(record.output);
     const urls = [];
     if (typeof output.image_url === "string")
         urls.push(output.image_url);
-    for (const part of asArray(record.content)) {
+    for (const part of [...asArray(record.content), ...asArray(record.output)]) {
         const url = asRecord(part).image_url;
         if (typeof url === "string")
             urls.push(url);

package/dist/actors/computer-use/openai-conversation.d.ts

@@ -40,6 +40,10 @@ export declare class OpenAiConversation {
     private lastResponseId;
     /** computer_call ids the next request owes an output for. */
     private pendingCallIds;
+    /** The function calls the next request owes an output for. */
+    private pendingFunctionCalls;
+    /** Whether the latest reply acted, so its waits went to the desktop and were not watched. */
+    private pendingActed;
     /** Accepted replies so far; the next request is number `replies + 1`. */
     private replies;
     /** The whole conversation, which explicit-context requests carry within its token budget. */
@@ -53,7 +57,7 @@ export declare class OpenAiConversation {
     constructor(settings: OpenAiConversationSettings);
     /**
      * The next participant turn's request, carrying `req`'s screen: the opening request, or the
-     * outputs the latest reply's computer calls are owed.
+     * outputs the latest reply's computer and function calls are owed.
      */
     request(req: CuaTurnRequest): ConversationRequest;
     /**
@@ -79,9 +83,20 @@ export declare class OpenAiConversation {
     record(): ActorConversation;
     /**
      * The items a request adds to the conversation: the opening message with the first screen, or
-     * an output for each pending computer_call with the latest screenshot and any hint.
+     * an output for each pending call with the latest screenshot, and any hint. Each computer_call
+     * output carries the screenshot. Function call outputs follow in reply order: with no
+     * computer_call the first carries the screenshot, and every other one carries text only, so the
+     * screenshot is sent once. A turn's hint goes into the first function call output, so it reads
+     * as how the wait ended; a closing request's hint asks for the closing account and stays a user
+     * message. A call to a tool that does not exist gets an output that says so (callNote).
      */
     private newItems;
+    /**
+     * What a call's output says when no note does, so every reply says how the wait went: a wait
+     * among actions ran for its length (a shortened or unsent one has a note), and a further call in
+     * a reply of only waits was part of the one watch the first call's output reports.
+     */
+    private waitOutcome;
     private context;
     /**
      * A participant request: the opening request, or a continuation carrying `sent`. A threaded

package/dist/actors/computer-use/openai-conversation.js

@@ -1,6 +1,7 @@
 import { closingReportSchema, impressionsReplySchema, strictOutputSchema, } from "../closing-report.js";
+import { isIdleTurn } from "./loop/actions.js";
 import { CarriedConversation, estimateTokens } from "./openai-context.js";
-import { asArray, asRecord, buildCallOutput, buildContinuationRequest, buildInitialRequest, hintItems, inputMessage, openingMessage, parseOpenAiResponse, } from "./openai-wire.js";
+import { asArray, asRecord, buildCallOutput, buildContinuationRequest, buildFunctionOutput, buildInitialRequest, hintItems, inputMessage, openingMessage, parseOpenAiResponse, WAIT_TOOL_NAME, } from "./openai-wire.js";
 /**
  * The closing request's output limit: its own cap, or the declared limit when that is lower. It
  * counts reasoning too, and leaves room for six impressions after the summary and friction reports.
@@ -25,6 +26,10 @@ export class OpenAiConversation {
     lastResponseId;
     /** computer_call ids the next request owes an output for. */
     pendingCallIds = [];
+    /** The function calls the next request owes an output for. */
+    pendingFunctionCalls = [];
+    /** Whether the latest reply acted, so its waits went to the desktop and were not watched. */
+    pendingActed = false;
     /** Accepted replies so far; the next request is number `replies + 1`. */
     replies = 0;
     /** The whole conversation, which explicit-context requests carry within its token budget. */
@@ -43,7 +48,7 @@ export class OpenAiConversation {
     }
     /**
      * The next participant turn's request, carrying `req`'s screen: the opening request, or the
-     * outputs the latest reply's computer calls are owed.
+     * outputs the latest reply's computer and function calls are owed.
      */
     request(req) {
         const sent = this.newItems(req);
@@ -63,7 +68,7 @@ export class OpenAiConversation {
         const strict = this.openClosing !== undefined;
         // Before any accepted reply the request is the opening one, which carries no hint of its own.
         const ask = this.replies === 0 ? hintItems(req.contextHint) : [];
-        const sent = this.openClosing ?? [...this.newItems(req), ...ask, replyForm(closing)];
+        const sent = this.openClosing ?? [...this.newItems(req, closing), ...ask, replyForm(closing)];
         this.openClosing = undefined;
         const reply = await send(this.closingBody(req, sent, closing, strict));
         // Recorded before the reply is accepted, as a participant turn is.
@@ -108,16 +113,43 @@ export class OpenAiConversation {
     }
     /**
      * The items a request adds to the conversation: the opening message with the first screen, or
-     * an output for each pending computer_call with the latest screenshot and any hint.
+     * an output for each pending call with the latest screenshot, and any hint. Each computer_call
+     * output carries the screenshot. Function call outputs follow in reply order: with no
+     * computer_call the first carries the screenshot, and every other one carries text only, so the
+     * screenshot is sent once. A turn's hint goes into the first function call output, so it reads
+     * as how the wait ended; a closing request's hint asks for the closing account and stays a user
+     * message. A call to a tool that does not exist gets an output that says so (callNote).
      */
-    newItems(req) {
+    newItems(req, closing) {
         if (this.replies === 0)
             return [openingMessage(req.instructions, req.observation.screenshot)];
+        const { screenshot } = req.observation;
+        const calls = this.pendingFunctionCalls;
+        const hintInCall = closing === undefined && calls.length > 0;
         return [
-            ...this.pendingCallIds.map((id) => buildCallOutput(id, req.observation.screenshot, req.acknowledgedSafetyChecks)),
-            ...hintItems(req.contextHint),
+            ...this.pendingCallIds.map((id) => buildCallOutput(id, screenshot, req.acknowledgedSafetyChecks)),
+            ...calls.map((call, index) => {
+                const withScreen = index === 0 && this.pendingCallIds.length === 0;
+                const text = [callNote(call), index === 0 && hintInCall ? req.contextHint : undefined]
+                    .filter((part) => part !== undefined && part !== "")
+                    .join(" ");
+                return withScreen
+                    ? buildFunctionOutput(call.callId, text, screenshot)
+                    : buildFunctionOutput(call.callId, text || this.waitOutcome(), null);
+            }),
+            ...(hintInCall ? [] : hintItems(req.contextHint)),
         ];
     }
+    /**
+     * What a call's output says when no note does, so every reply says how the wait went: a wait
+     * among actions ran for its length (a shortened or unsent one has a note), and a further call in
+     * a reply of only waits was part of the one watch the first call's output reports.
+     */
+    waitOutcome() {
+        return this.pendingActed
+            ? "The wait ran for its length with your other actions."
+            : "This wait was watched together with the first one in the reply.";
+    }
     context(instructions) {
         const { settings } = this;
         return {
@@ -183,10 +215,18 @@ export class OpenAiConversation {
         if (parsed.turn.responseId !== undefined)
             this.lastResponseId = parsed.turn.responseId;
         this.pendingCallIds = parsed.callIds;
+        this.pendingFunctionCalls = parsed.functionCalls;
+        this.pendingActed = !isIdleTurn(parsed.turn.actions);
         this.replies += 1;
         this.carried.accept(this.replies, sent, parsed.outputItems);
     }
 }
+/** What a function call's output says about the call itself: that no such tool exists. */
+function callNote(call) {
+    return call.name === WAIT_TOOL_NAME
+        ? undefined
+        : `There is no tool named ${JSON.stringify(call.name)}.`;
+}
 /**
  * What form a closing reply takes, said in the request itself because text.format would rewrite
  * the cached prefix: the schema the strict retry sets.

package/dist/actors/computer-use/openai-wire.d.ts

@@ -12,8 +12,15 @@ export declare function openAiActionToCua(action: unknown): CuaAction | null;
 export interface ParsedOpenAiResponse {
     turn: CuaTurn;
     callIds: string[];
+    /** The function calls, in reply order, each owed a function_call_output. */
+    functionCalls: FunctionCall[];
     outputItems: unknown[];
 }
+/** A function call a reply made: its id, and its name, which is WAIT_TOOL_NAME unless it erred. */
+export interface FunctionCall {
+    readonly callId: string;
+    readonly name: string;
+}
 /**
  * Parse a Responses API response into a provider-neutral CuaTurn plus the
  * computer_call ids (needed to build the next turn's call outputs) and the raw
@@ -23,6 +30,15 @@ export interface ParsedOpenAiResponse {
  */
 export declare function parseOpenAiResponse(raw: unknown): ParsedOpenAiResponse;
 export type OpenAiReasoningSummary = "auto" | "concise" | "detailed";
+/**
+ * A function the participant names its wait length with; the computer tool's `wait` names none.
+ * The minutes set where the doubling of idle turns in a row starts (loop/watch.ts). Declared on
+ * every request, so adding it changes no request's cached prefix after the first. Its name and
+ * description say nothing of the screen or of later waits: participants told that a wait ends when
+ * the screen changes treated waiting as watching and stopped reloading a page that updates only on
+ * reload, and participants told a schedule copied it. Each watch's note says how long it lasted.
+ */
+export declare const WAIT_TOOL_NAME = "wait_minutes";
 export interface OpenAiCuContext {
     /**
      * The server keeps no conversation (explicit_context): the request asks not to be stored and
@@ -59,6 +75,11 @@ export declare function openingMessage(instructions: string, screenshot?: Buffer
  * the mapper self-validating and isolable.
  */
 export declare function buildCallOutput(callId: string, screenshot: Buffer | undefined, acknowledged?: CuaSafetyCheck[]): Record<string, unknown>;
+/**
+ * The answer to a function call: `text`, followed by the screen. `screenshot` null sends the text
+ * alone; undefined is a missing frame, refused as buildCallOutput refuses it.
+ */
+export declare function buildFunctionOutput(callId: string, text: string, screenshot: Buffer | undefined | null): Record<string, unknown>;
 export interface ContinuationRequestArgs {
     ctx: OpenAiCuContext;
     previousResponseId: string | undefined;

package/dist/actors/computer-use/openai-wire.js

@@ -102,6 +102,25 @@ export function openAiActionToCua(action) {
             return null;
     }
 }
+/**
+ * A wait_minutes call as a wait of the minutes it names, in whole milliseconds and at least 1.
+ * The session's caps then apply as to any named wait, and the trace records the length as named.
+ * Arguments that do not parse, or minutes that are not a finite number above zero, make a wait
+ * that names no length, as the computer tool's `wait` does.
+ */
+function waitMinutesAction(args) {
+    let minutes;
+    try {
+        minutes = asRecord(JSON.parse(asString(args))).minutes;
+    }
+    catch {
+        return { kind: "wait" };
+    }
+    if (typeof minutes !== "number" || !(minutes > 0))
+        return { kind: "wait" };
+    const ms = Math.max(1, Math.round(minutes * 60_000));
+    return Number.isFinite(ms) ? { kind: "wait", ms } : { kind: "wait" };
+}
 // Collect plain strings or { text } entries from a reasoning summary/content array.
 function collectTextEntries(value) {
     const out = [];
@@ -143,6 +162,7 @@ export function parseOpenAiResponse(raw) {
     const output = asArray(root.output);
     const actions = [];
     const callIds = [];
+    const functionCalls = [];
     const reasoningParts = [];
     const messageParts = [];
     const safetyChecks = [];
@@ -194,6 +214,17 @@ export function parseOpenAiResponse(raw) {
                 }
                 break;
             }
+            case "function_call": {
+                const callId = optionalString(item.call_id);
+                if (callId === undefined)
+                    break;
+                const name = asString(item.name);
+                functionCalls.push({ callId, name });
+                // A call to a tool that does not exist is a wait with no length, and its output says there
+                // is no such tool. A reply of only such calls is then an idle turn, so the session goes on.
+                actions.push(name === WAIT_TOOL_NAME ? waitMinutesAction(item.arguments) : { kind: "wait" });
+                break;
+            }
             default:
                 break;
         }
@@ -240,8 +271,34 @@ export function parseOpenAiResponse(raw) {
         ...(message.length > 0 ? { message } : {}),
         ...(usage === undefined ? {} : { usage }),
     };
-    return { turn, callIds, outputItems: output };
+    return { turn, callIds, functionCalls, outputItems: output };
 }
+/**
+ * A function the participant names its wait length with; the computer tool's `wait` names none.
+ * The minutes set where the doubling of idle turns in a row starts (loop/watch.ts). Declared on
+ * every request, so adding it changes no request's cached prefix after the first. Its name and
+ * description say nothing of the screen or of later waits: participants told that a wait ends when
+ * the screen changes treated waiting as watching and stopped reloading a page that updates only on
+ * reload, and participants told a schedule copied it. Each watch's note says how long it lasted.
+ */
+export const WAIT_TOOL_NAME = "wait_minutes";
+const WAIT_TOOL = {
+    type: "function",
+    name: WAIT_TOOL_NAME,
+    description: "Wait, then get a new screenshot. The reply says how long the wait lasted and why it ended.",
+    parameters: {
+        type: "object",
+        properties: {
+            minutes: {
+                type: "number",
+                description: "How long you want to wait, in minutes.",
+            },
+        },
+        required: ["minutes"],
+        additionalProperties: false,
+    },
+    strict: true,
+};
 // The fields shared by the initial and continuation requests: the tool spec,
 // truncation policy, reasoning effort, and (when configured) the safety id.
 function sharedRequestFields(ctx) {
@@ -256,7 +313,7 @@ function sharedRequestFields(ctx) {
         // The Responses API `computer` tool takes no display/environment fields; the model infers
         // resolution from the screenshots it is sent. (Sending display_* returns a 400
         // "Unknown parameter tools[0].display_width", confirmed against the live API 2026-06.)
-        tools: [{ type: "computer" }],
+        tools: [{ type: "computer" }, WAIT_TOOL],
         truncation: "auto",
         // `summary` asks for the provider-sanctioned reasoning summary items; the
         // capture side never scrapes or reconstructs raw chain-of-thought. Parsed by
@@ -318,16 +375,10 @@ export function openingMessage(instructions, screenshot) {
  * the mapper self-validating and isolable.
  */
 export function buildCallOutput(callId, screenshot, acknowledged) {
-    if (screenshot === undefined) {
-        throw new Error("openai-responses-cu requires observation.screenshot (it is a vision provider; pair a state-only executor with a non-vision provider)");
-    }
     return {
         type: "computer_call_output",
         call_id: callId,
-        output: {
-            type: "computer_screenshot",
-            image_url: `data:image/png;base64,${screenshot.toString("base64")}`,
-        },
+        output: { type: "computer_screenshot", image_url: screenshotUrl(screenshot) },
         ...(acknowledged && acknowledged.length > 0
             ? {
                 acknowledged_safety_checks: acknowledged.map(({ id, code, message }) => ({
@@ -339,6 +390,28 @@ export function buildCallOutput(callId, screenshot, acknowledged) {
             : {}),
     };
 }
+/**
+ * The answer to a function call: `text`, followed by the screen. `screenshot` null sends the text
+ * alone; undefined is a missing frame, refused as buildCallOutput refuses it.
+ */
+export function buildFunctionOutput(callId, text, screenshot) {
+    return {
+        type: "function_call_output",
+        call_id: callId,
+        output: screenshot === null
+            ? text
+            : [
+                ...(text ? [{ type: "input_text", text }] : []),
+                { type: "input_image", image_url: screenshotUrl(screenshot) },
+            ],
+    };
+}
+function screenshotUrl(screenshot) {
+    if (screenshot === undefined) {
+        throw new Error("openai-responses-cu requires observation.screenshot (it is a vision provider; pair a state-only executor with a non-vision provider)");
+    }
+    return `data:image/png;base64,${screenshot.toString("base64")}`;
+}
 /** An optional context hint as input items (none when there is no hint). */
 export function hintItems(contextHint) {
     return contextHint ? [inputMessage("user", [{ type: "input_text", text: contextHint }])] : [];

package/dist/actors/computer-use/wait.d.ts

@@ -21,16 +21,18 @@ export declare const CUA_WAIT_LIMITS: Readonly<{
     defaultWatchMaxMs: 600000;
     /**
      * How long a wait that names no duration lasts in a turn that only waits or takes screenshots,
-     * when a study does not set actor.idleWaitMs. OpenAI's computer-use `wait` names no duration. A
-     * participant told to wait about a minute sent ten in one turn, which lasts 50 s at this length;
-     * one wait a turn makes a one-minute wait about six turns. It is also how often a watch looks.
+     * when a study does not set actor.idleWaitMs. OpenAI's computer tool `wait` names no duration;
+     * its wait_minutes function names one in minutes. A participant told to wait about a minute
+     * sent ten computer tool waits in one turn, which lasts 50 s at this length; one wait a turn
+     * makes a one-minute wait about six turns. It is also the shortest a watch lasts and how often
+     * it looks.
      */
     defaultIdleMs: 5000;
     /**
      * How long a wait that names no duration lasts after the participant acts in the same turn, so
-     * the screen can settle before the next screenshot. Nearly every OpenAI computer-use wait follows
-     * a click or keypress this way, so a longer one would slow every run. A watch looks again this
-     * soon after a large part of the screen moved.
+     * the screen can settle before the next screenshot. Nearly every OpenAI computer tool wait
+     * follows a click or keypress this way, so a longer one would slow every run. A watch looks again
+     * this soon after a large part of the screen moved.
      */
     settleMs: 500;
     /**