humanish 0.116.0 → 0.117.0

package/dist/browser-control/protocol.d.ts

@@ -26,7 +26,7 @@ export interface BrowserControlIdentity {
     challenge: string;
     runtimeRevision: string;
 }
-export declare const browserOnlyControlActionSchema: z.ZodDiscriminatedUnion<readonly [z.ZodObject<{
+export declare const participantActionSchema: z.ZodPipe<z.ZodDiscriminatedUnion<readonly [z.ZodObject<{
     x: z.ZodNumber;
     y: z.ZodNumber;
     kind: z.ZodLiteral<"click">;
@@ -66,8 +66,88 @@ export declare const browserOnlyControlActionSchema: z.ZodDiscriminatedUnion<rea
     ms: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"screenshot">;
-}, z.core.$strict>], "kind">;
-export declare const browserControlActionSchema: z.ZodPipe<z.ZodDiscriminatedUnion<[z.ZodObject<{
+}, z.core.$strict>], "kind">, z.ZodTransform<{
+    kind: "click";
+    x: number;
+    y: number;
+    button?: "left" | "right" | "middle";
+    heldKeys?: string[];
+} | {
+    kind: "double_click";
+    x: number;
+    y: number;
+    heldKeys?: string[];
+} | {
+    kind: "move";
+    x: number;
+    y: number;
+    heldKeys?: string[];
+} | {
+    kind: "scroll";
+    x: number;
+    y: number;
+    dx: number;
+    dy: number;
+    heldKeys?: string[];
+} | {
+    kind: "type";
+    text: string;
+} | {
+    kind: "keypress";
+    keys: string[];
+} | {
+    kind: "drag";
+    path: Array<{
+        x: number;
+        y: number;
+    }>;
+    heldKeys?: string[];
+} | {
+    kind: "wait";
+    ms?: number;
+} | {
+    kind: "speak";
+    text: string;
+} | {
+    kind: "screenshot";
+}, {
+    kind: "type";
+    text: string;
+} | {
+    kind: "keypress";
+    keys: string[];
+} | {
+    kind: "screenshot";
+} | {
+    x: number;
+    y: number;
+    kind: "click";
+    button?: "left" | "middle" | "right" | undefined;
+} | {
+    x: number;
+    y: number;
+    kind: "double_click";
+} | {
+    x: number;
+    y: number;
+    kind: "move";
+} | {
+    x: number;
+    y: number;
+    kind: "scroll";
+    dx: number;
+    dy: number;
+} | {
+    kind: "drag";
+    path: {
+        x: number;
+        y: number;
+    }[];
+} | {
+    kind: "wait";
+    ms?: number | undefined;
+}>>;
+export declare const participantSpeechActionSchema: z.ZodPipe<z.ZodDiscriminatedUnion<[z.ZodObject<{
     x: z.ZodNumber;
     y: z.ZodNumber;
     kind: z.ZodLiteral<"click">;
@@ -160,9 +240,6 @@ export declare const browserControlActionSchema: z.ZodPipe<z.ZodDiscriminatedUni
 } | {
     kind: "keypress";
     keys: string[];
-} | {
-    kind: "wait";
-    ms?: number | undefined;
 } | {
     kind: "screenshot";
 } | {
@@ -193,6 +270,9 @@ export declare const browserControlActionSchema: z.ZodPipe<z.ZodDiscriminatedUni
         x: number;
         y: number;
     }[];
+} | {
+    kind: "wait";
+    ms?: number | undefined;
 }>>;
 declare const observationSchema: z.ZodObject<{
     png: z.ZodString;

package/dist/browser-control/protocol.js

@@ -64,13 +64,18 @@ const dragAction = z.strictObject({
 });
 const typeAction = z.strictObject({ kind: z.literal("type"), text });
 const keypressAction = z.strictObject({ kind: z.literal("keypress"), keys: chord });
+const waitMs = z.number().finite().min(0);
+// One request carries one wait, so the wire bounds it by the request deadline.
 const waitAction = z.strictObject({
     kind: z.literal("wait"),
-    ms: z.number().finite().min(0).max(BROWSER_CONTROL_LIMITS.waitMs).optional(),
+    ms: waitMs.max(BROWSER_CONTROL_LIMITS.waitMs).optional(),
 });
+// A participant may ask for any wait: the loop shortens it to the study's longest and sends it in
+// steps the wire accepts.
+const participantWaitAction = z.strictObject({ kind: z.literal("wait"), ms: waitMs.optional() });
 const screenshotAction = z.strictObject({ kind: z.literal("screenshot") });
 const speakAction = z.strictObject({ kind: z.literal("speak"), text: speechText });
-const browserActionSchemas = [
+const participantActionSchemas = [
     clickAction,
     doubleClickAction,
     moveAction,
@@ -78,13 +83,15 @@ const browserActionSchemas = [
     typeAction,
     keypressAction,
     dragAction,
-    waitAction,
+    participantWaitAction,
     screenshotAction,
 ];
 // The Codex participant's tool schema: no held keys, so its tool surface stays as published.
-export const browserOnlyControlActionSchema = z.discriminatedUnion("kind", browserActionSchemas);
-export const browserControlActionSchema = z
-    .discriminatedUnion("kind", [...browserActionSchemas, speakAction])
+export const participantActionSchema = z
+    .discriminatedUnion("kind", participantActionSchemas)
+    .transform(toCuaAction);
+export const participantSpeechActionSchema = z
+    .discriminatedUnion("kind", [...participantActionSchemas, speakAction])
     .transform(toCuaAction);
 // What crosses the host-guest wire: the participant actions plus held keys on pointer actions,
 // which the OpenAI provider maps from its computer tool.

package/dist/guest/desktop-executor.js

@@ -1,5 +1,6 @@
 import { perceptualSignature } from "../evidence/frame-signature.js";
 import { setTimeout as delay } from "node:timers/promises";
+import { CUA_WAIT_LIMITS } from "../actors/computer-use/wait.js";
 import { BROWSER_CONTROL_LIMITS, validateBrowserControlAction, validateBrowserControlPng, } from "../browser-control/protocol.js";
 import { ComputerUseExecutorError, isComputerUseExecutorError, } from "../actors/computer-use/executor-error.js";
 import { xdotoolChord, xdotoolHeldModifiers } from "./desktop-keys.js";
@@ -104,8 +105,9 @@ async function executeAction(context, state, value, callerSignal) {
                 throw error;
             }
         }
+        // The loop sends every wait with its length; planWait owns the lengths.
         if (action.kind === "wait")
-            await delay(action.ms ?? 250, undefined, { signal });
+            await delay(action.ms ?? CUA_WAIT_LIMITS.settleMs, undefined, { signal });
         for (const command of commands) {
             assertOpen(state, signal, progress.dispatched);
             // No await between authority check and the native port invocation.