@bounded-sh/client 0.0.100-performance.1 → 0.0.100

package/dist/index.d.ts

@@ -48,3 +48,7 @@ export type { InjectedWalletProvider } from "./auth/providers/injected-wallet-pr
 export { defaultInjectedEvmProvider, requestEip6963Providers, } from "./auth/providers/injected-evm-wallet-types";
 export type { InjectedEvmWalletConfig, InjectedEvmProvider, Eip6963ProviderDetail, Eip6963ProviderInfo, } from "./auth/providers/injected-evm-wallet-types";
 export type { InjectedEvmWalletProvider } from "./auth/providers/injected-evm-wallet-provider";
+export { connectBroadcast } from "./services/broadcast";
+export type { BroadcastTicket, BroadcastConnection } from "./services/broadcast";
+export { connectServiceSession } from "./services/session";
+export type { ServiceSessionTicket, ServiceSession, ServiceSessionReceipt } from "./services/session";

package/dist/index.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-DUVRmF9-.js');
+var index = require('./index-Pyb2SLgv.js');
 var core = require('@bounded-sh/core');
 require('react');
 
@@ -22,6 +22,8 @@ exports.apps = index.apps;
 exports.builds = index.builds;
 exports.completeLoginFromRedirect = index.completeLoginFromRedirect;
 exports.completeLoginInPopup = index.completeLoginInPopup;
+exports.connectBroadcast = index.connectBroadcast;
+exports.connectServiceSession = index.connectServiceSession;
 exports.defaultInjectedEvmProvider = index.defaultInjectedEvmProvider;
 exports.defaultInjectedProvider = index.defaultInjectedProvider;
 exports.ensureSharedWalletLoginReady = index.ensureSharedWalletLoginReady;
@@ -42,6 +44,7 @@ exports.loginWithPrivy = index.loginWithPrivy;
 exports.loginWithRedirect = index.loginWithRedirect;
 exports.loginWithWallet = index.loginWithWallet;
 exports.logout = index.logout;
+exports.mediaAgentTools = index.mediaAgentTools;
 exports.onAuthLoadingChanged = index.onAuthLoadingChanged;
 exports.onAuthStateChanged = index.onAuthStateChanged;
 exports.onramp = index.onramp;

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.mjs

@@ -1,4 +1,4 @@
-export { ad as BUILD_DELEGATED_REVIEW_CAPABILITY_SCHEMA, ac as BUILD_REVIEW_CAPABILITY_REFRESH_SCHEMA, ab as BUILD_REVIEW_CAPABILITY_SCHEMA, a5 as BuildsApiError, aa as FAILURE_REASONS, a6 as NON_TERMINAL_STATES, a1 as OffchainAuthProvider, a9 as PARK_REASONS, a2 as PrivyExpoProvider, a8 as RUN_STATES, a7 as TERMINAL_STATES, W as WalletConfigError, Q as apps, a4 as builds, I as completeLoginFromRedirect, K as completeLoginInPopup, o as defaultInjectedEvmProvider, f as defaultInjectedProvider, F as ensureSharedWalletLoginReady, M as ensureSignedIn, E as ensureWalletLoginReady, w as getAuthLoading, A as getAuthProvider, q as getCurrentUser, Y as getIdToken, S as getOrCreateTurnkeyWallet, g as getPlatform, V as getTurnkeyWalletRecoveryUrl, U as getTurnkeyWalletSessionState, p as init, y as login, J as loginWithPopup, C as loginWithPrivy, H as loginWithRedirect, D as loginWithWallet, z as logout, v as onAuthLoadingChanged, u as onAuthStateChanged, Z as onramp, _ as onrampQuote, $ as onrampStatus, L as openBoundedWidget, T as openTurnkeyKeyExport, G as preloadWalletLogin, a3 as requestEip6963Providers, a0 as setPlatform, B as signInAnonymously, R as signSolanaMessageViaTurnkey, X as startTurnkeyEmailLogin, N as useAuth, P as useBuildRun, O as useQuery, x as waitForAuthReady } from './index-DmAXYXDi.mjs';
+export { ag as BUILD_DELEGATED_REVIEW_CAPABILITY_SCHEMA, af as BUILD_REVIEW_CAPABILITY_REFRESH_SCHEMA, ae as BUILD_REVIEW_CAPABILITY_SCHEMA, a7 as BuildsApiError, ad as FAILURE_REASONS, a9 as NON_TERMINAL_STATES, a1 as OffchainAuthProvider, ac as PARK_REASONS, a2 as PrivyExpoProvider, ab as RUN_STATES, aa as TERMINAL_STATES, W as WalletConfigError, Q as apps, a6 as builds, I as completeLoginFromRedirect, K as completeLoginInPopup, a4 as connectBroadcast, a5 as connectServiceSession, o as defaultInjectedEvmProvider, f as defaultInjectedProvider, F as ensureSharedWalletLoginReady, M as ensureSignedIn, E as ensureWalletLoginReady, w as getAuthLoading, A as getAuthProvider, q as getCurrentUser, Y as getIdToken, S as getOrCreateTurnkeyWallet, g as getPlatform, V as getTurnkeyWalletRecoveryUrl, U as getTurnkeyWalletSessionState, p as init, y as login, J as loginWithPopup, C as loginWithPrivy, H as loginWithRedirect, D as loginWithWallet, z as logout, a8 as mediaAgentTools, v as onAuthLoadingChanged, u as onAuthStateChanged, Z as onramp, _ as onrampQuote, $ as onrampStatus, L as openBoundedWidget, T as openTurnkeyKeyExport, G as preloadWalletLogin, a3 as requestEip6963Providers, a0 as setPlatform, B as signInAnonymously, R as signSolanaMessageViaTurnkey, X as startTurnkeyEmailLogin, N as useAuth, P as useBuildRun, O as useQuery, x as waitForAuthReady } from './index-CaZx7sd8.mjs';
 export * from '@bounded-sh/core';
 export { BoundedDeclineError, DECLINE_EVENT_NAME, RATE_LIMIT_EVENT_NAME, ScopedClientReadOnlyError, aggregate, count, createClient, deriveDecline, dispatchDeclineEvent, dispatchRateLimitEvent, docId, get, getConfig, getFiles, getMany, queryAggregate, reconcileSetResult, runExpression, runExpressionMany, runQuery, runQueryMany, search, set, setFile, setMany, signAndSubmitTransaction, signMessage, signTransaction, subscribe, waitForSetResult } from '@bounded-sh/core';
 import 'react';

package/dist/{index.native-r1I-9E8e.mjs → index.native-3T0IcOed.mjs}

@@ -6044,7 +6044,7 @@ async function getAuthProvider(config) {
             // manager as legacy email sessions. Human login should be started
             // with loginWithRedirect(); this provider is kept as the restore and
             // logout surface for those sessions.
-            currentAuthProvider = new (await import('./email-auth-provider-CIRbOSM3.mjs')).EmailAuthProvider();
+            currentAuthProvider = new (await import('./email-auth-provider-Ct3YA68i.mjs')).EmailAuthProvider();
             break;
         case "phantom": {
             // First-class Solana WALLET LOGIN (the poof/TaroBase-style "connect
@@ -6086,7 +6086,7 @@ async function getAuthProvider(config) {
             // (bounded-login-widget.ts), so registration never counts as
             // evidence the user has a wallet.
             await ensureSolanaMobileWalletRegistered(config, configuredNetwork);
-            const { InjectedWalletProvider } = await import('./injected-wallet-provider-BlSdRbgq.mjs');
+            const { InjectedWalletProvider } = await import('./injected-wallet-provider-BnmYbm79.mjs');
             currentAuthProvider = new InjectedWalletProvider(resolveInjectedWalletConfig(config), rpcUrl, configuredNetwork);
             break;
         }
@@ -6099,7 +6099,7 @@ async function getAuthProvider(config) {
             // Selecting authMethod:'evm-wallet' IS the opt-in — pass evmWalletConfig
             // to point at a specific wallet or set chainId/domain.
             const evmWalletConfig = ((_a = config.evmWalletConfig) !== null && _a !== void 0 ? _a : {});
-            const { InjectedEvmWalletProvider } = await import('./injected-evm-wallet-provider-CkhN5u3d.mjs');
+            const { InjectedEvmWalletProvider } = await import('./injected-evm-wallet-provider-C8rBnyO1.mjs');
             currentAuthProvider = new InjectedEvmWalletProvider(evmWalletConfig);
             break;
         }
@@ -6124,7 +6124,7 @@ async function getAuthProvider(config) {
             break;
         case "guest":
             // Anonymous auth: a device-local ed25519 keypair signs the challenge.
-            currentAuthProvider = new (await import('./guest-auth-provider-C23vWrOT.mjs')).GuestAuthProvider();
+            currentAuthProvider = new (await import('./guest-auth-provider-DMtDTZeA.mjs')).GuestAuthProvider();
             break;
     }
     if (!currentAuthProvider) {
@@ -6186,7 +6186,7 @@ async function signInAnonymously() {
     // Lazy-load the guest provider so its ed25519/web3 dependencies stay out of
     // the main bundle for data-only apps. Specifier is a static string literal
     // so bundle-splitting can see it.
-    const provider = new (await import('./guest-auth-provider-C23vWrOT.mjs')).GuestAuthProvider();
+    const provider = new (await import('./guest-auth-provider-DMtDTZeA.mjs')).GuestAuthProvider();
     setAuthLoading(true); // reflect "signing in…" while the guest keypair session is minted
     // adoptSessionProvider awaits only getConfig() (already resolved here) and then
     // runs every write - provider/method/config/marker/user - in one synchronous
@@ -6357,7 +6357,7 @@ function ensureSharedWalletLoginReady() {
     if (!sharedWalletReady) {
         sharedWalletReady = (async () => {
             await getConfig();
-            await import('./injected-wallet-provider-BlSdRbgq.mjs');
+            await import('./injected-wallet-provider-BnmYbm79.mjs');
         })().catch((error) => {
             sharedWalletReady = null;
             throw error;
@@ -7290,9 +7290,26 @@ async function getReviewCapability(appId, runId, gateId, options) {
         body: { expectedPreviewUrl: options.expectedPreviewUrl },
     });
 }
+/**
+ * Add funds to a run parked for funding. Accounts billed through payer shards refuse it with
+ * `topup_unavailable_payer_shard` (in `details.upstreamCode`): a parked run there holds no money, so the payer adds
+ * credits and submits the build again.
+ */
 async function topup(appId, runId, options) {
     return requestDevApi(`${appPath(appId)}/${encodeURIComponent(runId)}/topup`, { method: 'POST', body: options });
 }
+/** An image build's verified images and its asset's current release. */
+async function media(appId, runId) {
+    return requestDevApi(`${appPath(appId)}/${encodeURIComponent(runId)}/media`);
+}
+/** A short-lived signed URL for one image of an image build (usable directly as an image source). */
+async function mediaDownloadUrl(appId, runId, artifactId) {
+    return requestDevApi(`${appPath(appId)}/${encodeURIComponent(runId)}/media-download-url`, { method: 'POST', body: { artifactId } });
+}
+/** Roll back the release an image build published: its asset returns to the release it replaced. */
+async function rollbackMedia(appId, runId, options = {}) {
+    return requestDevApi(`${appPath(appId)}/${encodeURIComponent(runId)}/media-rollback`, { method: 'POST', body: options.note ? { note: options.note } : {} });
+}
 async function list$1(appId, limit = 20) {
     const requestedLimit = Number.isFinite(limit) ? Math.max(1, Math.floor(limit)) : 20;
     return requestDevApi(`${appPath(appId)}?limit=${requestedLimit}`);
@@ -7324,13 +7341,15 @@ const RUN_STATES = [
     ...NON_TERMINAL_STATES,
     ...TERMINAL_STATES,
 ];
-const PARK_REASONS = ['gate', 'funding'];
+const PARK_REASONS = ['gate', 'funding', 'preview', 'design'];
 const FAILURE_REASONS = [
     'admission_rejected',
     'dispatch_timeout',
     'auth_revoked',
     'owner_changed',
     'policy_changed',
+    'target_retired',
+    'promotion_rejected',
     'quarantine_forced',
     'bind_failed',
     'internal_error',
@@ -7588,6 +7607,345 @@ function useBuildRun(appId, runId, options) {
     return { run, events, loading, error };
 }
 
+const TERMINAL = new Set(['promoted', 'failed', 'canceled', 'rejected', 'expired', 'rebase_required', 'reported']);
+const KEY = { type: 'string', minLength: 1, maxLength: 256, description: 'A key unique to this intent; retrying with the same key never repeats the action.' };
+const RUN_ID = { type: 'string', minLength: 1, maxLength: 128, description: 'The build run id media_create or media_edit returned.' };
+const REGION = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['x', 'y', 'width', 'height'],
+    properties: {
+        x: { type: 'integer', minimum: 0 },
+        y: { type: 'integer', minimum: 0 },
+        width: { type: 'integer', minimum: 1 },
+        height: { type: 'integer', minimum: 1 },
+    },
+    description: 'A rectangle in whole pixels of the image; nothing outside it changes.',
+};
+const SPEC = { type: 'object', description: 'The deliverable spec (image: size, quality, format, background, candidates, model, references, region; video: durationSeconds, resolution, aspectRatio, audio, images, scenes, replaceScenes, captions). See the builds docs.' };
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const text = (value, max) => typeof value === 'string' && value.trim().length > 0 && value.length <= max ? value : undefined;
+const refuse = (code, message, next = ['media_inspect'], retryable = false) => ({ ok: false, code, message, retryable, next });
+function region(value) {
+    if (!isRecord(value))
+        return undefined;
+    const { x, y, width, height } = value;
+    return [x, y, width, height].every(Number.isSafeInteger) && x >= 0 && y >= 0
+        && width >= 1 && height >= 1
+        ? { x: x, y: y, width: width, height: height }
+        : undefined;
+}
+/** A thrown API error, as the tool result the model reads. The developer API answers with a coarse public code and
+ *  relays Build's own reason (base_moved, candidate_unknown, media_storage_quota, ...) as details.upstreamCode. */
+function failure(error) {
+    var _a;
+    const apiError = error;
+    const upstream = (_a = apiError === null || apiError === void 0 ? void 0 : apiError.details) === null || _a === void 0 ? void 0 : _a.upstreamCode;
+    return refuse(typeof upstream === 'string' && /^[a-z][a-z0-9_]{0,79}$/.test(upstream) && upstream !== 'unknown_upstream_error'
+        ? upstream
+        : typeof (apiError === null || apiError === void 0 ? void 0 : apiError.code) === 'string' ? apiError.code : 'request_failed', typeof (apiError === null || apiError === void 0 ? void 0 : apiError.message) === 'string' ? apiError.message : 'The request failed.', ['media_inspect'], (apiError === null || apiError === void 0 ? void 0 : apiError.retryable) === true);
+}
+/** What a run lets an agent do next. */
+function nextFor(run) {
+    var _a;
+    if ((_a = run.design) === null || _a === void 0 ? void 0 : _a.gate)
+        return ['media_select', 'media_revise', 'media_export'];
+    if (run.state === 'promoted')
+        return ['media_export', 'media_edit', 'media_create'];
+    if (run.state === 'parked' && run.parkReason === 'gate')
+        return ['media_propose', 'media_export'];
+    if (TERMINAL.has(run.state))
+        return ['media_create'];
+    return ['media_inspect'];
+}
+function candidateView(candidate) {
+    return Object.assign(Object.assign(Object.assign(Object.assign({ id: candidate.id }, (candidate.url ? { url: candidate.url } : {})), { mimeType: candidate.mimeType, width: candidate.width, height: candidate.height }), (candidate.durationMs !== undefined ? { durationMs: candidate.durationMs } : {})), (candidate.scenes ? { scenes: candidate.scenes } : {}));
+}
+function mediaAgentTools(appId, client = {
+    submit: submit,
+    get: get,
+    decideGate: decideGate,
+    media: media,
+    mediaDownloadUrl: mediaDownloadUrl,
+}) {
+    const run = async (runId) => (await client.get(appId, runId)).run;
+    const submit = async (options) => {
+        try {
+            const submitted = await client.submit(appId, options);
+            return { ok: true, data: { runId: submitted.runId, status: submitted.status }, next: ['media_inspect'] };
+        }
+        catch (error) {
+            return failure(error);
+        }
+    };
+    /** The open design review of a run, or the refusal that explains why there is none. */
+    const openReview = async (input) => {
+        var _a;
+        const runId = text(input.runId, 128);
+        if (!runId)
+            return refuse('input_invalid', 'runId is required.');
+        let current;
+        try {
+            current = await run(runId);
+        }
+        catch (error) {
+            return failure(error);
+        }
+        const gate = (_a = current.design) === null || _a === void 0 ? void 0 : _a.gate;
+        if (!gate) {
+            return refuse('no_open_review', `Run ${runId} is ${current.state}${current.parkReason ? ` (${current.parkReason})` : ''}; no design round is waiting for a decision.`, nextFor(current));
+        }
+        return { run: current, gateId: gate.gateId };
+    };
+    const candidateOf = (current, id) => { var _a, _b, _c, _d; return (_d = (_c = (_b = (_a = current.design) === null || _a === void 0 ? void 0 : _a.rounds) === null || _b === void 0 ? void 0 : _b.find((round) => { var _a; return round.round === ((_a = current.design) === null || _a === void 0 ? void 0 : _a.round); })) === null || _c === void 0 ? void 0 : _c.candidates) === null || _d === void 0 ? void 0 : _d.find((candidate) => candidate.id === id); };
+    return [
+        {
+            name: 'media_create',
+            description: 'Start an image or video build for this app. Pass forkOf to start a new asset from a retained release. Returns the run id; the first round of candidates follows (read it with media_inspect).',
+            inputSchema: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['kind', 'prompt', 'idempotencyKey'],
+                properties: {
+                    kind: { type: 'string', enum: ['image', 'video'] },
+                    prompt: { type: 'string', minLength: 1, maxLength: 4000, description: 'What to make.' },
+                    spec: SPEC,
+                    forkOf: {
+                        type: 'object',
+                        additionalProperties: false,
+                        required: ['assetId', 'releaseId'],
+                        properties: { assetId: { type: 'string' }, releaseId: { type: 'string' } },
+                        description: 'A retained release of this app to start from.',
+                    },
+                    idempotencyKey: KEY,
+                },
+            },
+            async execute(raw) {
+                const input = isRecord(raw) ? raw : {};
+                const prompt = text(input.prompt, 4000);
+                const key = text(input.idempotencyKey, 256);
+                if ((input.kind !== 'image' && input.kind !== 'video') || !prompt || !key) {
+                    return refuse('input_invalid', 'kind (image or video), prompt and idempotencyKey are required.', []);
+                }
+                return submit({
+                    operation: 'create',
+                    prompt,
+                    deliverable: Object.assign(Object.assign({ kind: input.kind }, (isRecord(input.spec) ? { spec: input.spec } : {})), (isRecord(input.forkOf) ? { forkOf: input.forkOf } : {})),
+                    idempotencyKey: key,
+                });
+            },
+        },
+        {
+            name: 'media_edit',
+            description: 'Edit a released image or video. Name the asset and the release you edit (a newer release refuses the edit as base_moved). An image spec may carry region to change only a rectangle; a video spec may carry replaceScenes or captions, and a captions-only edit makes no generation call.',
+            inputSchema: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['kind', 'assetId', 'expectedReleaseId', 'prompt', 'idempotencyKey'],
+                properties: {
+                    kind: { type: 'string', enum: ['image', 'video'] },
+                    assetId: { type: 'string' },
+                    expectedReleaseId: { type: 'string' },
+                    prompt: { type: 'string', minLength: 1, maxLength: 4000, description: 'The change to make.' },
+                    spec: SPEC,
+                    idempotencyKey: KEY,
+                },
+            },
+            async execute(raw) {
+                const input = isRecord(raw) ? raw : {};
+                const prompt = text(input.prompt, 4000);
+                const key = text(input.idempotencyKey, 256);
+                const assetId = text(input.assetId, 128);
+                const expectedReleaseId = text(input.expectedReleaseId, 128);
+                if ((input.kind !== 'image' && input.kind !== 'video') || !prompt || !key || !assetId || !expectedReleaseId) {
+                    return refuse('input_invalid', 'kind, assetId, expectedReleaseId, prompt and idempotencyKey are required.', []);
+                }
+                return submit({
+                    operation: 'edit',
+                    prompt,
+                    deliverable: Object.assign({ kind: input.kind, assetId,
+                        expectedReleaseId }, (isRecord(input.spec) ? { spec: input.spec } : {})),
+                    idempotencyKey: key,
+                });
+            },
+        },
+        {
+            name: 'media_inspect',
+            description: 'Read a media build: its state, the candidates of the round under review (with their scenes), the decision it waits on, and its release once published.',
+            inputSchema: { type: 'object', additionalProperties: false, required: ['runId'], properties: { runId: RUN_ID } },
+            async execute(raw) {
+                var _a, _b, _c, _d, _e;
+                const runId = text(isRecord(raw) ? raw.runId : undefined, 128);
+                if (!runId)
+                    return refuse('input_invalid', 'runId is required.', []);
+                try {
+                    const current = await run(runId);
+                    const round = (_b = (_a = current.design) === null || _a === void 0 ? void 0 : _a.rounds) === null || _b === void 0 ? void 0 : _b.find((entry) => { var _a; return entry.round === ((_a = current.design) === null || _a === void 0 ? void 0 : _a.round); });
+                    const media = current.state === 'promoted' || current.media ? await client.media(appId, runId) : undefined;
+                    return {
+                        ok: true,
+                        data: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ runId, state: current.state }, (current.parkReason ? { parkReason: current.parkReason } : {})), (current.failureReason ? { failureReason: current.failureReason } : {})), (current.failureDetail ? { failureDetail: current.failureDetail } : {})), (round
+                            ? Object.assign({ round: round.round, maxRounds: (_c = current.design) === null || _c === void 0 ? void 0 : _c.maxRounds, candidates: ((_d = round.candidates) !== null && _d !== void 0 ? _d : []).map(candidateView) }, (round.revisionFailed ? { revisionFailed: true } : {})) : {})), (((_e = current.design) === null || _e === void 0 ? void 0 : _e.gate) ? { review: { gateId: current.design.gate.gateId, allowedDecisions: current.design.gate.allowedDecisions } } : {})), (current.state === 'parked' && current.parkReason === 'funding'
+                            ? { waitingFor: 'funding: the payer adds funds and, where top-up is unavailable (topup_unavailable_payer_shard), submits the build again; an agent cannot' }
+                            : {})), (media ? { media: media.media, asset: media.asset } : {})),
+                        next: nextFor(current),
+                    };
+                }
+                catch (error) {
+                    return failure(error);
+                }
+            },
+        },
+        {
+            name: 'media_revise',
+            description: 'Ask for another round of the design under review. Name the candidate to revise; for an image, region limits the change to a rectangle of that candidate (PNG only); for a multi-scene video, sceneIds regenerates only those scenes and keeps every other scene byte for byte.',
+            inputSchema: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['runId', 'feedback', 'idempotencyKey'],
+                properties: {
+                    runId: RUN_ID,
+                    feedback: { type: 'string', minLength: 1, maxLength: 4000, description: 'What to change.' },
+                    candidateId: { type: 'string', description: 'The candidate to revise; without it the whole round is redone from the feedback.' },
+                    sceneIds: { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 6 },
+                    region: REGION,
+                    idempotencyKey: KEY,
+                },
+            },
+            async execute(raw) {
+                var _a, _b;
+                const input = isRecord(raw) ? raw : {};
+                const feedback = text(input.feedback, 4000);
+                const key = text(input.idempotencyKey, 256);
+                if (!feedback || !key)
+                    return refuse('input_invalid', 'runId, feedback and idempotencyKey are required.', []);
+                const review = await openReview(input);
+                if ('ok' in review)
+                    return review;
+                if (!((_b = (_a = review.run.design) === null || _a === void 0 ? void 0 : _a.gate) === null || _b === void 0 ? void 0 : _b.allowedDecisions.includes('request_changes'))) {
+                    return refuse('decision_not_allowed', 'This round takes no revision (it may be the last one): select a candidate instead.', ['media_select']);
+                }
+                const candidate = input.candidateId === undefined ? undefined : candidateOf(review.run, input.candidateId);
+                if (input.candidateId !== undefined && !candidate) {
+                    return refuse('candidate_unknown', `No candidate ${String(input.candidateId)} in the round under review.`, ['media_inspect']);
+                }
+                const sceneIds = Array.isArray(input.sceneIds) ? input.sceneIds.filter((id) => typeof id === 'string') : undefined;
+                if (sceneIds && (!(candidate === null || candidate === void 0 ? void 0 : candidate.scenes) || !sceneIds.every((id) => candidate.scenes.some((scene) => scene.id === id)))) {
+                    return refuse('scenes_unknown', 'sceneIds must name scenes of the multi-scene candidate being revised (candidateId).', ['media_inspect']);
+                }
+                const area = input.region === undefined ? undefined : region(input.region);
+                if (input.region !== undefined
+                    && (!area || (candidate === null || candidate === void 0 ? void 0 : candidate.mimeType) !== 'image/png' || area.x + area.width > candidate.width || area.y + area.height > candidate.height)) {
+                    return refuse('region_invalid', 'region must lie inside the PNG candidate being revised (candidateId).', ['media_inspect']);
+                }
+                try {
+                    const decided = await client.decideGate(appId, review.run.runId, review.gateId, Object.assign(Object.assign(Object.assign(Object.assign({ decision: 'request_changes', feedback: { text: feedback } }, (candidate ? { selectedArtifactId: candidate.id } : {})), (sceneIds ? { sceneIds } : {})), (area ? { region: area } : {})), { idempotencyKey: key }));
+                    return { ok: true, data: { runId: review.run.runId, state: decided.state }, next: ['media_inspect'] };
+                }
+                catch (error) {
+                    return failure(error);
+                }
+            },
+        },
+        {
+            name: 'media_select',
+            description: 'Choose a candidate of the round under review. The chosen candidate is what the build releases, through the app\'s landing policy.',
+            inputSchema: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['runId', 'candidateId', 'idempotencyKey'],
+                properties: { runId: RUN_ID, candidateId: { type: 'string' }, idempotencyKey: KEY },
+            },
+            async execute(raw) {
+                const input = isRecord(raw) ? raw : {};
+                const key = text(input.idempotencyKey, 256);
+                if (!key)
+                    return refuse('input_invalid', 'runId, candidateId and idempotencyKey are required.', []);
+                const review = await openReview(input);
+                if ('ok' in review)
+                    return review;
+                const candidate = candidateOf(review.run, input.candidateId);
+                if (!candidate)
+                    return refuse('candidate_unknown', `No candidate ${String(input.candidateId)} in the round under review.`, ['media_inspect']);
+                try {
+                    const decided = await client.decideGate(appId, review.run.runId, review.gateId, {
+                        decision: 'approve',
+                        selectedArtifactId: candidate.id,
+                        idempotencyKey: key,
+                    });
+                    return { ok: true, data: { runId: review.run.runId, state: decided.state, selectedArtifactId: candidate.id }, next: ['media_propose', 'media_inspect'] };
+                }
+                catch (error) {
+                    return failure(error);
+                }
+            },
+        },
+        {
+            name: 'media_export',
+            description: 'A short-lived signed URL for one verified image or video of a build (a published release, or a candidate the build deposited), with its digest.',
+            inputSchema: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['runId', 'artifactId'],
+                properties: { runId: RUN_ID, artifactId: { type: 'string' } },
+            },
+            async execute(raw) {
+                var _a, _b;
+                const input = isRecord(raw) ? raw : {};
+                const runId = text(input.runId, 128);
+                const artifactId = text(input.artifactId, 64);
+                if (!runId || !artifactId)
+                    return refuse('input_invalid', 'runId and artifactId are required.', []);
+                try {
+                    const view = await client.media(appId, runId);
+                    const artifact = (_b = (_a = view.media) === null || _a === void 0 ? void 0 : _a.artifacts) === null || _b === void 0 ? void 0 : _b.find((entry) => entry.id === artifactId);
+                    if (!artifact) {
+                        return refuse('artifact_unavailable', `Run ${runId} has no verified artifact ${artifactId} yet; a candidate under review is exported from its round's url (media_inspect).`, ['media_inspect']);
+                    }
+                    const signed = await client.mediaDownloadUrl(appId, runId, artifactId);
+                    return {
+                        ok: true,
+                        data: { runId, artifactId, url: signed.url, expiresAtMs: signed.expiresAtMs, sha256: artifact.sha256, mimeType: artifact.mimeType, bytes: artifact.bytes },
+                        next: ['media_inspect'],
+                    };
+                }
+                catch (error) {
+                    return failure(error);
+                }
+            },
+        },
+        {
+            name: 'media_propose',
+            description: 'Put a build\'s chosen candidate forward for publication and report where it stands. Publishing is decided by the app\'s landing policy (the owner approves the release, or the policy lands it); this tool never approves it.',
+            inputSchema: { type: 'object', additionalProperties: false, required: ['runId'], properties: { runId: RUN_ID } },
+            async execute(raw) {
+                var _a;
+                const runId = text(isRecord(raw) ? raw.runId : undefined, 128);
+                if (!runId)
+                    return refuse('input_invalid', 'runId is required.', []);
+                try {
+                    const current = await run(runId);
+                    if (current.state === 'promoted') {
+                        const view = await client.media(appId, runId);
+                        return { ok: true, data: { runId, state: 'published', release: view.asset.currentRelease }, next: nextFor(current) };
+                    }
+                    if (current.state === 'parked' && current.parkReason === 'gate') {
+                        const gate = current.gates.find((entry) => !entry.decided);
+                        return { ok: true, data: Object.assign(Object.assign({ runId, state: 'awaiting_publication' }, (gate ? { gateId: gate.gateId } : {})), { decidedBy: 'the app owner, under the landing policy' }), next: ['media_inspect'] };
+                    }
+                    if ((_a = current.design) === null || _a === void 0 ? void 0 : _a.gate) {
+                        return refuse('not_selected', 'Choose a candidate first (media_select); only a chosen candidate can be published.', ['media_select', 'media_revise']);
+                    }
+                    return refuse('not_proposable', `Run ${runId} is ${current.state}${current.parkReason ? ` (${current.parkReason})` : ''}; it has no candidate waiting for publication.`, nextFor(current));
+                }
+                catch (error) {
+                    return failure(error);
+                }
+            },
+        },
+    ];
+}
+
 /**
  * Registered first-party product surfaces only, with
  * one exact Drafted exception for delegated review/decision routes. Other
@@ -7605,6 +7963,9 @@ const builds = {
     uploadInput,
     list: list$1,
     watch,
+    media,
+    mediaDownloadUrl,
+    rollbackMedia,
 };
 
 async function create(options = {}) {
@@ -8324,5 +8685,5 @@ class PrivyExpoProvider {
     }
 }
 
-export { BUILD_REVIEW_CAPABILITY_REFRESH_SCHEMA as $, logout as A, getAuthProvider as B, signInAnonymously as C, loginWithPrivy as D, loginWithRedirect as E, completeLoginFromRedirect as F, loginWithPopup as G, completeLoginInPopup as H, useAuth as I, useQuery as J, useBuildRun as K, apps as L, getIdToken as M, onramp as N, onrampQuote as O, onrampStatus as P, setPlatform as Q, OffchainAuthProvider as R, PrivyExpoProvider as S, builds as T, BuildsApiError as U, NON_TERMINAL_STATES as V, TERMINAL_STATES as W, RUN_STATES as X, PARK_REASONS as Y, FAILURE_REASONS as Z, BUILD_REVIEW_CAPABILITY_SCHEMA as _, signMessageWithTurnkey as a, BUILD_DELEGATED_REVIEW_CAPABILITY_SCHEMA as a0, signTransactionWithTurnkey as b, signTransactionV1WithTurnkey as c, signAndSubmitTransactionWithTurnkey as d, bs58 as e, getWallets as f, getPlatform as g, hasTurnkeyWallet as h, isSolanaMobileWallet as i, solanaMobileWalletLeavesPage as j, setAuthLoading as k, bufferExports as l, setStoredAuthMethod as m, normalizeSolanaRpcUrl as n, confirmAndCheckTransaction as o, resolveSolanaRpcUrl as p, init as q, resolveSolanaWalletStandardChain as r, setCurrentUser as s, transactionHasSignature as t, getCurrentUser as u, onAuthStateChanged as v, onAuthLoadingChanged as w, getAuthLoading as x, waitForAuthReady as y, login as z };
-//# sourceMappingURL=index.native-r1I-9E8e.mjs.map
+export { BUILD_REVIEW_CAPABILITY_SCHEMA as $, logout as A, getAuthProvider as B, signInAnonymously as C, loginWithPrivy as D, loginWithRedirect as E, completeLoginFromRedirect as F, loginWithPopup as G, completeLoginInPopup as H, useAuth as I, useQuery as J, useBuildRun as K, apps as L, getIdToken as M, onramp as N, onrampQuote as O, onrampStatus as P, setPlatform as Q, OffchainAuthProvider as R, PrivyExpoProvider as S, builds as T, BuildsApiError as U, mediaAgentTools as V, NON_TERMINAL_STATES as W, TERMINAL_STATES as X, RUN_STATES as Y, PARK_REASONS as Z, FAILURE_REASONS as _, signMessageWithTurnkey as a, BUILD_REVIEW_CAPABILITY_REFRESH_SCHEMA as a0, BUILD_DELEGATED_REVIEW_CAPABILITY_SCHEMA as a1, signTransactionWithTurnkey as b, signTransactionV1WithTurnkey as c, signAndSubmitTransactionWithTurnkey as d, bs58 as e, getWallets as f, getPlatform as g, hasTurnkeyWallet as h, isSolanaMobileWallet as i, solanaMobileWalletLeavesPage as j, setAuthLoading as k, bufferExports as l, setStoredAuthMethod as m, normalizeSolanaRpcUrl as n, confirmAndCheckTransaction as o, resolveSolanaRpcUrl as p, init as q, resolveSolanaWalletStandardChain as r, setCurrentUser as s, transactionHasSignature as t, getCurrentUser as u, onAuthStateChanged as v, onAuthLoadingChanged as w, getAuthLoading as x, waitForAuthReady as y, login as z };
+//# sourceMappingURL=index.native-3T0IcOed.mjs.map