@shardflux/sdk 0.13.1 → 0.15.0

package/dist/codex-proof.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Codex identity proof (0.14.0+, Node): the OpenAI ID token of the Codex CLI signed in on this machine, for
+ * `ShardfluxAccount.signup({ codexIdToken })` and `auth.stepUp({ codexIdToken })`.
+ *
+ * Codex keeps the token in `$CODEX_HOME/auth.json` (default `~/.codex/auth.json`) and refreshes it only every few
+ * days, while the API accepts one issued in the last 15 minutes. So this first asks Codex to refresh its own login
+ * (`codex app-server`, JSON-RPC `account/read {"refreshToken": true}`: Codex runs its normal refresh flow and writes
+ * its own file), then reads the token. Only the ID token is returned: Codex's access and refresh tokens are never read
+ * into memory beyond parsing the file, and never leave the machine. The ID token proves the ChatGPT account's verified
+ * email; it is not a credential to OpenAI.
+ *
+ *   const proof = await codexIdentityProof();
+ *   if (proof.ok) {
+ *     const { account, result } = await ShardfluxAccount.signup({ codexIdToken: proof.idToken });
+ *   }
+ */
+export type CodexProofUnavailable = 
+/** No `codex` executable on PATH (or CODEX_BIN), and no usable auth.json. */
+'codex_not_found'
+/** Codex is not signed in (no auth.json, or no ID token in it: signed in with an API key, or credentials in the OS keyring). */
+ | 'not_signed_in'
+/** Codex is signed in with an OpenAI API key, which carries no identity. */
+ | 'api_key_login'
+/** The token on disk is too old and Codex could not refresh it. */
+ | 'stale';
+export type CodexIdentityProof = {
+    ok: true;
+    idToken: string;
+    email: string | null;
+    refreshed: boolean;
+} | {
+    ok: false;
+    reason: CodexProofUnavailable;
+    message: string;
+};
+export interface CodexProofOptions {
+    /** Environment to read CODEX_HOME, CODEX_BIN and HOME from. Default `process.env`. */
+    env?: Record<string, string | undefined>;
+    /** Longest wait for `codex app-server` (ms). Default 15 000. */
+    timeoutMs?: number;
+    /** Skip the refresh and only read the file (tests, or when Codex must not be started). */
+    refresh?: boolean;
+    /** Accept a token issued at most this long ago (s), e.g. when Codex cannot refresh. Default 600 (the API allows 900). */
+    maxAgeSeconds?: number;
+    /** clientInfo sent to the app server. */
+    clientName?: string;
+    clientVersion?: string;
+}
+/**
+ * The ID token of this machine's Codex login, refreshed by Codex when needed. Never throws: `{ ok: false, reason }`
+ * says why there is none (sign up with an email address instead).
+ */
+export declare function codexIdentityProof(opts?: CodexProofOptions): Promise<CodexIdentityProof>;

package/dist/codex-proof.js

@@ -0,0 +1,200 @@
+/**
+ * Codex identity proof (0.14.0+, Node): the OpenAI ID token of the Codex CLI signed in on this machine, for
+ * `ShardfluxAccount.signup({ codexIdToken })` and `auth.stepUp({ codexIdToken })`.
+ *
+ * Codex keeps the token in `$CODEX_HOME/auth.json` (default `~/.codex/auth.json`) and refreshes it only every few
+ * days, while the API accepts one issued in the last 15 minutes. So this first asks Codex to refresh its own login
+ * (`codex app-server`, JSON-RPC `account/read {"refreshToken": true}`: Codex runs its normal refresh flow and writes
+ * its own file), then reads the token. Only the ID token is returned: Codex's access and refresh tokens are never read
+ * into memory beyond parsing the file, and never leave the machine. The ID token proves the ChatGPT account's verified
+ * email; it is not a credential to OpenAI.
+ *
+ *   const proof = await codexIdentityProof();
+ *   if (proof.ok) {
+ *     const { account, result } = await ShardfluxAccount.signup({ codexIdToken: proof.idToken });
+ *   }
+ */
+function claimsOf(token) {
+    const part = token.split('.')[1];
+    if (!part)
+        return null;
+    try {
+        return JSON.parse(Buffer.from(part, 'base64url').toString('utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function fresh(token, maxAgeSeconds) {
+    const c = claimsOf(token);
+    const now = Date.now() / 1000;
+    return c !== null && typeof c.iat === 'number' && typeof c.exp === 'number' && now - c.iat <= maxAgeSeconds && c.exp - now > 60;
+}
+async function codexHome(env) {
+    const path = await import('node:path');
+    const os = await import('node:os');
+    const set = env.CODEX_HOME?.trim();
+    return set ? path.resolve(set) : path.join(env.HOME?.trim() || os.homedir(), '.codex');
+}
+/** `tokens.id_token` of auth.json, or null (missing file, other shape, API-key login). */
+async function readIdToken(home) {
+    const fs = await import('node:fs/promises');
+    const path = await import('node:path');
+    let raw;
+    try {
+        raw = await fs.readFile(path.join(home, 'auth.json'), 'utf8');
+    }
+    catch {
+        return { token: null, apiKeyOnly: false, exists: false };
+    }
+    try {
+        const doc = JSON.parse(raw);
+        const token = typeof doc.tokens?.id_token === 'string' && doc.tokens.id_token.length > 0 ? doc.tokens.id_token : null;
+        const apiKeyOnly = token === null && (doc.auth_mode === 'apikey' || (typeof doc.OPENAI_API_KEY === 'string' && doc.OPENAI_API_KEY.length > 0));
+        return { token, apiKeyOnly, exists: true };
+    }
+    catch {
+        return { token: null, apiKeyOnly: false, exists: true };
+    }
+}
+/**
+ * The `codex` executables to try, in PATH order (CODEX_BIN alone when set). Every match is kept, not only the first:
+ * npx puts ancestor node_modules/.bin directories first on PATH, where an unrelated npm package named `codex` can
+ * shadow the Codex CLI. Distinct by real path.
+ */
+async function codexCandidates(env) {
+    const set = env.CODEX_BIN?.trim();
+    if (set)
+        return [set];
+    const fs = await import('node:fs/promises');
+    const path = await import('node:path');
+    const names = process.platform === 'win32' ? ['codex.exe', 'codex.cmd', 'codex'] : ['codex'];
+    const out = [];
+    const seen = new Set();
+    for (const dir of (env.PATH ?? '').split(path.delimiter)) {
+        if (!dir)
+            continue;
+        for (const name of names) {
+            const file = path.join(dir, name);
+            try {
+                await fs.access(file, fs.constants.X_OK);
+                const real = await fs.realpath(file);
+                if (seen.has(real))
+                    continue;
+                seen.add(real);
+                out.push(file);
+            }
+            catch {
+                // not there, or not executable
+            }
+        }
+    }
+    return out;
+}
+/** Asks Codex to refresh its own login through the app server of the first candidate that speaks its protocol. */
+async function refreshViaAppServer(env, opts) {
+    const candidates = await codexCandidates(env);
+    if (candidates.length === 0)
+        return 'not_found';
+    let outcome = 'not_found';
+    for (const bin of candidates.slice(0, 4)) {
+        outcome = await appServerRefresh(bin, env, opts);
+        if (outcome !== 'failed' && outcome !== 'not_found')
+            return outcome;
+    }
+    return outcome;
+}
+async function appServerRefresh(bin, env, opts) {
+    const { spawn } = await import('node:child_process');
+    return new Promise((resolve) => {
+        let settled = false;
+        let buffer = '';
+        const child = spawn(bin, ['app-server'], { stdio: ['pipe', 'pipe', 'ignore'], env, windowsHide: true });
+        const done = (o) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            child.stdin.end();
+            child.kill();
+            resolve(o);
+        };
+        const timer = setTimeout(() => done('failed'), opts.timeoutMs);
+        const send = (msg) => child.stdin.write(`${JSON.stringify(msg)}\n`);
+        child.on('error', (err) => done(err.code === 'ENOENT' ? 'not_found' : 'failed'));
+        child.on('exit', () => done('failed'));
+        child.stdin.on('error', () => done('failed'));
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => {
+            buffer += chunk;
+            let nl;
+            while ((nl = buffer.indexOf('\n')) >= 0) {
+                const line = buffer.slice(0, nl).trim();
+                buffer = buffer.slice(nl + 1);
+                if (line.length === 0)
+                    continue;
+                let msg;
+                try {
+                    msg = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (msg.id === 1) {
+                    if (msg.error !== undefined)
+                        return done('failed');
+                    send({ jsonrpc: '2.0', method: 'initialized' });
+                    send({ jsonrpc: '2.0', id: 2, method: 'account/read', params: { refreshToken: true } });
+                }
+                else if (msg.id === 2) {
+                    if (msg.error !== undefined)
+                        return done('failed');
+                    const type = msg.result?.account?.type;
+                    return done(type === 'chatgpt' ? 'refreshed' : type === 'apiKey' ? 'api_key_login' : type === undefined || type === null ? 'not_signed_in' : 'failed');
+                }
+            }
+        });
+        send({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { clientInfo: { name: opts.clientName, version: opts.clientVersion } } });
+    });
+}
+/**
+ * The ID token of this machine's Codex login, refreshed by Codex when needed. Never throws: `{ ok: false, reason }`
+ * says why there is none (sign up with an email address instead).
+ */
+export async function codexIdentityProof(opts = {}) {
+    const env = opts.env ?? process.env;
+    const maxAge = opts.maxAgeSeconds ?? 600;
+    const home = await codexHome(env);
+    let outcome = 'skipped';
+    // Always refresh first: each refresh mints a token with a new jti, and the API accepts each jti once, so a token
+    // still fresh on disk may already have been used. The file alone is the fallback when Codex cannot refresh.
+    let file = await readIdToken(home);
+    let renewed = false;
+    if (opts.refresh !== false) {
+        const appServer = { timeoutMs: opts.timeoutMs ?? 15_000, clientName: opts.clientName ?? 'shardflux', clientVersion: opts.clientVersion ?? '0' };
+        const before = file.token;
+        // A refresh counts only when the token on disk changed. One retry: a refresh can fail on a transient network
+        // error, answer without renewing, or race another Codex process refreshing the same login.
+        for (let attempt = 0; attempt < 2 && !renewed; attempt++) {
+            if (attempt > 0)
+                await new Promise((r) => setTimeout(r, 500));
+            outcome = await refreshViaAppServer(env, appServer);
+            file = await readIdToken(home);
+            renewed = file.token !== null && file.token !== before && fresh(file.token, maxAge);
+            if (outcome === 'api_key_login' || outcome === 'not_signed_in' || outcome === 'not_found')
+                break;
+        }
+    }
+    if (file.token !== null && fresh(file.token, maxAge)) {
+        const email = claimsOf(file.token)?.email;
+        return { ok: true, idToken: file.token, email: typeof email === 'string' ? email : null, refreshed: renewed };
+    }
+    if (outcome === 'api_key_login' || file.apiKeyOnly)
+        return { ok: false, reason: 'api_key_login', message: 'Codex is signed in with an API key, which carries no identity. Sign in with ChatGPT (codex login), or sign up with an email address.' };
+    if (outcome === 'not_signed_in' || (file.token === null && outcome !== 'not_found')) {
+        return { ok: false, reason: 'not_signed_in', message: 'Codex is not signed in with ChatGPT on this machine (codex login), or keeps its login in the OS keyring. Sign up with an email address instead.' };
+    }
+    if (outcome === 'not_found' && !file.exists)
+        return { ok: false, reason: 'codex_not_found', message: 'The Codex CLI is not installed (or not on PATH). Sign up with an email address instead.' };
+    return { ok: false, reason: 'stale', message: 'The Codex login on this machine could not be refreshed. Run any codex command (or codex login), then try again.' };
+}

package/dist/computer.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Computer use (0.15.0+, contracts §45): the workspace desktop, which the platform starts on the first call that needs
+ * it. `workspace.computer` drives it; `computerToolset(workspace)` answers Claude's computer toolset
+ * (`computer_toolset_20260801`) with one batch per model turn.
+ *
+ *   await workspace.setComputerUse(true);                  // or open({ ..., computerUse: true })
+ *   const shot = await workspace.computer.screenshot();     // { format: 'png', width: 1280, height: 800, data }
+ *   await workspace.computer.act([{ action: 'left_click', coordinate: [640, 400] }, { action: 'type', text: 'hello' }]);
+ *   const { url } = await workspace.computer.stream();      // a private link to watch the screen
+ */
+import type { CellClient, ComputerAction, ComputerActionsResult, ComputerImage, ComputerStatus } from './cell.js';
+import type { ComputerUse } from './client.js';
+import type { WorkspacePorts } from './ports.js';
+/** A decoded screen image. */
+export interface ComputerScreenshot {
+    format: 'png' | 'jpeg';
+    width: number;
+    height: number;
+    data: Uint8Array;
+}
+export interface ComputerActOptions {
+    /** Append a screenshot after the last action that ran (also after a failure). */
+    screenshot?: boolean;
+    /** Wait this long before that screenshot when an action changed the screen (default 250). */
+    settleMs?: number;
+    format?: 'png' | 'jpeg';
+    /** JPEG quality 1..100 (default 80). */
+    quality?: number;
+    signal?: AbortSignal;
+}
+export interface ComputerStreamOptions {
+    /** Let the viewer use the mouse and keyboard (default false: view only, enforced in the workspace). */
+    interactive?: boolean;
+    /** How long the link works (60..604800 s; default 86400). */
+    ttlSeconds?: number;
+}
+/** A private link to the desktop's viewer: open it in a browser or an iframe. */
+export interface ComputerStream {
+    url: string;
+    expiresAt: string;
+    port: number;
+    interactive: boolean;
+}
+/** Decodes a result image (base64 in the API) to bytes. */
+export declare function decodeComputerImage(img: ComputerImage): ComputerScreenshot;
+interface ComputerDeps {
+    cell: () => CellClient;
+    ports: () => WorkspacePorts;
+    setEnabled: (enabled: boolean | null) => Promise<ComputerUse>;
+}
+/** The workspace desktop (workspace.computer). */
+export declare class WorkspaceComputer {
+    #private;
+    constructor(deps: ComputerDeps);
+    /**
+     * Runs actions in order (the first failure stops the batch; later actions come back `skipped`), optionally ending
+     * with a screenshot. The actions are Claude's computer toolset members with their parameter names.
+     */
+    act(actions: ComputerAction[], opts?: ComputerActOptions): Promise<ComputerActionsResult>;
+    /** The screen now (the pointer drawn in). */
+    screenshot(opts?: Pick<ComputerActOptions, 'format' | 'quality' | 'signal'>): Promise<ComputerScreenshot>;
+    /** Whether the desktop runs, its size and its viewers. Never starts it. */
+    status(): Promise<ComputerStatus>;
+    /** Starts the desktop (a no-op while it runs; the size applies to a start only: 640x480..2560x1600, default 1280x800). */
+    start(size?: {
+        width?: number;
+        height?: number;
+    }): Promise<ComputerStatus>;
+    /** Stops the desktop; its windows close. The next call that needs it starts a fresh one. */
+    stop(): Promise<void>;
+    /**
+     * A private link to watch the desktop (or use it, with `interactive`): starts the viewer in the workspace, exposes
+     * its port and signs a link to the viewer page (inbound ports, contracts §39). Anyone with the link can open it until
+     * it expires; `stopStream()` ends every view.
+     */
+    stream(opts?: ComputerStreamOptions): Promise<ComputerStream>;
+    /** Ends every view and closes the viewer ports (their links stop working). */
+    stopStream(): Promise<void>;
+    /** Switches computer use on or off for this workspace (null follows the template). */
+    setEnabled(enabled: boolean | null): Promise<ComputerUse>;
+}
+/** The `tools` entry of Claude's computer toolset (no name, no display size). */
+export declare const COMPUTER_TOOLSET: {
+    readonly type: "computer_toolset_20260801";
+};
+/** A `tool_use` content block (structurally the Anthropic SDK's, so its blocks pass as they are). */
+export interface ToolUseBlockLike {
+    type: string;
+    id: string;
+    name: string;
+    input: unknown;
+    toolset_name?: string | null;
+}
+type ResultContent = Array<{
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    source: {
+        type: 'base64';
+        media_type: 'image/png' | 'image/jpeg';
+        data: string;
+    };
+}>;
+/** A `tool_result` block answering a toolset call (each echoes `toolset_name: "computer"`, as the API requires). */
+export interface ComputerToolResult {
+    type: 'tool_result';
+    tool_use_id: string;
+    toolset_name: 'computer';
+    content: ResultContent;
+    is_error?: true;
+}
+export interface ComputerToolsetOptions {
+    /** Screenshot format (default png). */
+    format?: 'png' | 'jpeg';
+    quality?: number;
+    settleMs?: number;
+    signal?: AbortSignal;
+}
+/**
+ * Answers Claude's computer toolset (`tools: [COMPUTER_TOOLSET]`, Claude Opus 5.5 / Sonnet 5.5 and later on the
+ * Claude API) from this workspace's desktop:
+ *
+ *   const computer = computerToolset(workspace);
+ *   const msg = await anthropic.messages.create({ model, max_tokens, tools: [computer.definition], messages });
+ *   messages.push({ role: 'assistant', content: msg.content });
+ *   messages.push({ role: 'user', content: await computer.run(msg.content) });
+ *
+ * `run` takes the response content, runs every `toolset_name: "computer"` call of the turn as one batch (in order;
+ * the first failure stops it and the rest are answered "Not executed"), and returns one `tool_result` per call:
+ * images for screenshot and zoom, the position for cursor_position, `OK` otherwise. When the batch does not end with a
+ * look, a screenshot is attached to the last result, so the model sees the outcome without another round trip. A
+ * batch the desktop refuses as invalid (a coordinate outside the screen) is answered with the reason on every call.
+ */
+export declare function computerToolset(workspace: {
+    computer: WorkspaceComputer;
+}): {
+    definition: {
+        readonly type: "computer_toolset_20260801";
+    };
+    run(content: readonly unknown[], opts?: ComputerToolsetOptions): Promise<ComputerToolResult[]>;
+};
+export {};

package/dist/computer.js

@@ -0,0 +1,146 @@
+import { ShardfluxApiError, ShardfluxProtocolError } from "./errors.js";
+/** Decodes a result image (base64 in the API) to bytes. */
+export function decodeComputerImage(img) {
+    return { format: img.format, width: img.width, height: img.height, data: new Uint8Array(Buffer.from(img.data, 'base64')) };
+}
+/** The workspace desktop (workspace.computer). */
+export class WorkspaceComputer {
+    #deps;
+    constructor(deps) {
+        this.#deps = deps;
+    }
+    /**
+     * Runs actions in order (the first failure stops the batch; later actions come back `skipped`), optionally ending
+     * with a screenshot. The actions are Claude's computer toolset members with their parameter names.
+     */
+    act(actions, opts = {}) {
+        return this.#deps.cell().computer.act({
+            actions,
+            ...(opts.screenshot !== undefined ? { screenshot: opts.screenshot } : {}),
+            ...(opts.settleMs !== undefined ? { settle_ms: opts.settleMs } : {}),
+            ...(opts.format !== undefined ? { format: opts.format } : {}),
+            ...(opts.quality !== undefined ? { quality: opts.quality } : {}),
+        }, opts.signal);
+    }
+    /** The screen now (the pointer drawn in). */
+    async screenshot(opts = {}) {
+        const r = await this.act([], { ...opts, screenshot: true });
+        if (!r.screenshot)
+            throw new ShardfluxProtocolError('POST /computer/actions: the desktop returned no screenshot', 200, 'cell');
+        return decodeComputerImage(r.screenshot);
+    }
+    /** Whether the desktop runs, its size and its viewers. Never starts it. */
+    status() {
+        return this.#deps.cell().computer.status();
+    }
+    /** Starts the desktop (a no-op while it runs; the size applies to a start only: 640x480..2560x1600, default 1280x800). */
+    start(size = {}) {
+        return this.#deps.cell().computer.start(size);
+    }
+    /** Stops the desktop; its windows close. The next call that needs it starts a fresh one. */
+    stop() {
+        return this.#deps.cell().computer.stop();
+    }
+    /**
+     * A private link to watch the desktop (or use it, with `interactive`): starts the viewer in the workspace, exposes
+     * its port and signs a link to the viewer page (inbound ports, contracts §39). Anyone with the link can open it until
+     * it expires; `stopStream()` ends every view.
+     */
+    async stream(opts = {}) {
+        const info = await this.#deps.cell().computer.streamStart({ interactive: opts.interactive ?? false });
+        const ports = this.#deps.ports();
+        await ports.expose(info.port);
+        const link = await ports.link(info.port, { path: info.path, ...(opts.ttlSeconds !== undefined ? { ttlSeconds: opts.ttlSeconds } : {}) });
+        return { url: link.url, expiresAt: link.expiresAt, port: info.port, interactive: info.interactive };
+    }
+    /** Ends every view and closes the viewer ports (their links stop working). */
+    async stopStream() {
+        const ports = this.#deps.ports();
+        await Promise.all([ports.close(61002), ports.close(61003)]);
+        await this.#deps.cell().computer.streamStop();
+    }
+    /** Switches computer use on or off for this workspace (null follows the template). */
+    setEnabled(enabled) {
+        return this.#deps.setEnabled(enabled);
+    }
+}
+// ---- Claude's computer toolset ------------------------------------------------------------------------------------------
+/** The `tools` entry of Claude's computer toolset (no name, no display size). */
+export const COMPUTER_TOOLSET = { type: 'computer_toolset_20260801' };
+/** Parameters the toolset members take; anything else a model sends is not forwarded. */
+const PARAMS = ['coordinate', 'start_coordinate', 'region', 'text', 'scroll_direction', 'scroll_amount', 'duration', 'repeat'];
+const LOOKS = new Set(['screenshot', 'zoom']);
+function imageContent(img) {
+    return { type: 'image', source: { type: 'base64', media_type: img.format === 'jpeg' ? 'image/jpeg' : 'image/png', data: img.data } };
+}
+function actionOf(block) {
+    const input = (block.input !== null && typeof block.input === 'object' ? block.input : {});
+    const a = { action: block.name };
+    for (const k of PARAMS)
+        if (input[k] !== undefined && input[k] !== null)
+            a[k] = input[k];
+    return a;
+}
+/**
+ * Answers Claude's computer toolset (`tools: [COMPUTER_TOOLSET]`, Claude Opus 5.5 / Sonnet 5.5 and later on the
+ * Claude API) from this workspace's desktop:
+ *
+ *   const computer = computerToolset(workspace);
+ *   const msg = await anthropic.messages.create({ model, max_tokens, tools: [computer.definition], messages });
+ *   messages.push({ role: 'assistant', content: msg.content });
+ *   messages.push({ role: 'user', content: await computer.run(msg.content) });
+ *
+ * `run` takes the response content, runs every `toolset_name: "computer"` call of the turn as one batch (in order;
+ * the first failure stops it and the rest are answered "Not executed"), and returns one `tool_result` per call:
+ * images for screenshot and zoom, the position for cursor_position, `OK` otherwise. When the batch does not end with a
+ * look, a screenshot is attached to the last result, so the model sees the outcome without another round trip. A
+ * batch the desktop refuses as invalid (a coordinate outside the screen) is answered with the reason on every call.
+ */
+export function computerToolset(workspace) {
+    return {
+        definition: COMPUTER_TOOLSET,
+        async run(content, opts = {}) {
+            const calls = content.filter((b) => b !== null && typeof b === 'object' && b.type === 'tool_use' && b.toolset_name === 'computer');
+            if (calls.length === 0)
+                return [];
+            const lastLooks = LOOKS.has(calls[calls.length - 1].name);
+            let r;
+            try {
+                r = await workspace.computer.act(calls.map(actionOf), {
+                    screenshot: !lastLooks,
+                    ...(opts.format !== undefined ? { format: opts.format } : {}),
+                    ...(opts.quality !== undefined ? { quality: opts.quality } : {}),
+                    ...(opts.settleMs !== undefined ? { settleMs: opts.settleMs } : {}),
+                    ...(opts.signal !== undefined ? { signal: opts.signal } : {}),
+                });
+            }
+            catch (err) {
+                if (err instanceof ShardfluxApiError && err.code === 'validation_failed') {
+                    const at = typeof err.details?.index === 'number' ? err.details.index : -1;
+                    return calls.map((c, i) => ({
+                        type: 'tool_result',
+                        tool_use_id: c.id,
+                        toolset_name: 'computer',
+                        is_error: true,
+                        content: [{ type: 'text', text: i === at || at < 0 ? err.message : 'Not executed: another computer action in this turn was invalid.' }],
+                    }));
+                }
+                throw err;
+            }
+            const out = calls.map((c, i) => {
+                const res = r.results[i];
+                if (!res || res.skipped) {
+                    return { type: 'tool_result', tool_use_id: c.id, toolset_name: 'computer', is_error: true, content: [{ type: 'text', text: 'Not executed: an earlier computer action in this turn failed.' }] };
+                }
+                if (!res.ok) {
+                    return { type: 'tool_result', tool_use_id: c.id, toolset_name: 'computer', is_error: true, content: [{ type: 'text', text: res.error?.message ?? 'The action failed.' }] };
+                }
+                const body = res.image ? [imageContent(res.image)] : [{ type: 'text', text: res.output ?? 'OK' }];
+                return { type: 'tool_result', tool_use_id: c.id, toolset_name: 'computer', content: body };
+            });
+            if (r.screenshot)
+                out[out.length - 1].content.push(imageContent(r.screenshot));
+            return out;
+        },
+    };
+}

package/dist/errors.d.ts

@@ -82,7 +82,7 @@ export type ErrorCode = AppErrorCode | CellErrorCode;
  * `retained_state` (details.limit_value and details.current in GiB) when opening a new key or forking with the plan's
  * Retained state used up. `details.limit` is not a reason: these are not in this union.
  */
-export type KnownErrorReason = 'invalid_recipe' | 'base_not_layered' | 'language_unavailable' | 'language_conflict' | 'invalid_package' | 'too_many_files' | 'platform_owned_path' | 'upload_required' | 'upload_missing' | 'upload_digest_mismatch' | 'upload_too_large' | 'extra_hosts_without_auto' | 'invalid_settings' | 'services_unsupported' | 'input_required' | 'input_unknown' | 'input_invalid' | 'egress_widening' | 'reserved_session_id' | 'env_collision' | 'reserved_template_slug' | 'package_index_unavailable' | 'package_not_found' | 'startup_failed' | 'service_not_ready' | 'secrets_unavailable' | 'workspace_not_running' | 'operation_in_progress' | 'workspace_deleted' | 'secret_not_available' | 'legacy_disk_layout' | 'not_session' | 'session_lifetime' | 'lifetime_mismatch' | 'not_resettable' | 'template_not_layered' | 'draft_exists' | 'draft_stale' | 'build_in_progress' | 'file_list_unavailable' | 'file_list_indexing' | 'guest_feature_unavailable' | 'confirm_destructive_required' | 'reserved_key_prefix' | 'invalid_defaults' | 'invalid_path' | 'too_many_acknowledged_findings' | 'template_dev_mode_role' | 'draft_not_found' | 'version_not_found' | 'path_not_found' | 'revision_mismatch' | 'edit_not_found' | 'edit_ambiguous' | 'edit_not_text' | 'patch_invalid' | 'host_capacity' | 'wake_failed' | 'workspace_fenced' | 'offline_unavailable' | 'offline_budget' | 'offline_changed' | 'host_feature_unavailable' | 'not_supported_for_mode' | 'mode_mismatch' | 'mode_not_available' | 'layout_unsupported' | 'tree_revision_mismatch' | 'outside_tree_root' | 'execution_in_progress' | 'execution_id_reused' | 'operation_id_reused' | 'no_execution_host' | 'lease_expired' | 'host_unreachable' | 'host_restarted' | 'tree_moved' | 'blob_missing' | 'blob_corrupt' | 'exec_failed_to_start' | 'invalid_cwd' | 'allowance_used' | 'overage_paused' | 'spend_cap_reached' | 'overage_unavailable' | 'spend_cap_required' | 'spend_cap_below_minimum' | 'spend_cap_above_plan_price' | 'spend_cap_below_charges' | 'version_mismatch' | 'allocation_mode_not_available' | 'requires_elastic' | 'exceeds_memory_mib' | 'burst_mode_not_supported' | 'burst_not_supported' | 'burst_size_exceeds_plan' | 'not_available' | 'shared_volumes' | 'fence_not_drained' | 'apply_pending' | 'park_failed' | 'workspace_resumed' | 'interrupted' | 'burst_lost' | 'disk_full' | 'apply_failed' | 'reverted' | 'revert_failed' | 'immutable_path_removed' | 'immutable_paths_unsupported_base' | 'read_only_path' | 'host_lost';
+export type KnownErrorReason = 'invalid_recipe' | 'base_not_layered' | 'language_unavailable' | 'language_conflict' | 'invalid_package' | 'too_many_files' | 'platform_owned_path' | 'upload_required' | 'upload_missing' | 'upload_digest_mismatch' | 'upload_too_large' | 'extra_hosts_without_auto' | 'invalid_settings' | 'services_unsupported' | 'input_required' | 'input_unknown' | 'input_invalid' | 'egress_widening' | 'reserved_session_id' | 'env_collision' | 'reserved_template_slug' | 'package_index_unavailable' | 'package_not_found' | 'startup_failed' | 'service_not_ready' | 'secrets_unavailable' | 'workspace_not_running' | 'operation_in_progress' | 'workspace_deleted' | 'secret_not_available' | 'legacy_disk_layout' | 'not_session' | 'session_lifetime' | 'lifetime_mismatch' | 'not_resettable' | 'template_not_layered' | 'draft_exists' | 'draft_stale' | 'build_in_progress' | 'file_list_unavailable' | 'file_list_indexing' | 'guest_feature_unavailable' | 'confirm_destructive_required' | 'reserved_key_prefix' | 'invalid_defaults' | 'invalid_path' | 'too_many_acknowledged_findings' | 'template_dev_mode_role' | 'draft_not_found' | 'version_not_found' | 'path_not_found' | 'revision_mismatch' | 'edit_not_found' | 'edit_ambiguous' | 'edit_not_text' | 'patch_invalid' | 'host_capacity' | 'wake_failed' | 'workspace_fenced' | 'offline_unavailable' | 'offline_budget' | 'offline_changed' | 'host_feature_unavailable' | 'not_supported_for_mode' | 'mode_mismatch' | 'mode_not_available' | 'layout_unsupported' | 'tree_revision_mismatch' | 'outside_tree_root' | 'execution_in_progress' | 'execution_id_reused' | 'operation_id_reused' | 'no_execution_host' | 'lease_expired' | 'host_unreachable' | 'host_restarted' | 'tree_moved' | 'blob_missing' | 'blob_corrupt' | 'exec_failed_to_start' | 'invalid_cwd' | 'allowance_used' | 'overage_paused' | 'spend_cap_reached' | 'overage_unavailable' | 'spend_cap_required' | 'spend_cap_below_minimum' | 'spend_cap_above_plan_price' | 'spend_cap_below_charges' | 'version_mismatch' | 'allocation_mode_not_available' | 'requires_elastic' | 'exceeds_memory_mib' | 'burst_mode_not_supported' | 'burst_not_supported' | 'burst_size_exceeds_plan' | 'not_available' | 'shared_volumes' | 'fence_not_drained' | 'apply_pending' | 'park_failed' | 'workspace_resumed' | 'interrupted' | 'burst_lost' | 'disk_full' | 'apply_failed' | 'reverted' | 'revert_failed' | 'immutable_path_removed' | 'immutable_paths_unsupported_base' | 'read_only_path' | 'resize_not_available' | 'shrink_not_supported' | 'resize_failed' | 'host_lost' | 'inbound_ports_not_available' | 'port_not_exposed' | 'port_limit';
 /** A known reason, or any other string the server sends (reasons are open-ended). */
 export type ErrorReason = KnownErrorReason | (string & {});
 export interface ErrorBodyLike {