@playdrop/playdrop-cli 0.16.16 → 0.17.1

package/dist/commands/devGameServer.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidDevRedisNamespace = isValidDevRedisNamespace;
+exports.startDevGameServer = startDevGameServer;
+const node_child_process_1 = require("node:child_process");
+const node_module_1 = require("node:module");
+const node_net_1 = require("node:net");
+const mongodb_1 = require("mongodb");
+const ioredis_1 = require("ioredis");
+const serverBuild_1 = require("../apps/serverBuild");
+const EXPECTED_REDIS_VERSION = "7.4.5";
+const EXPECTED_MONGODB_VERSION = "8.0.26";
+function isValidDevRedisNamespace(namespace) {
+    return /^colyseus:[a-z0-9_.-]+:[a-z0-9_.-]+:$/u.test(namespace);
+}
+function requireServiceUrl(name) {
+    const value = process.env[name]?.trim() ?? "";
+    if (!value)
+        throw new Error(`${name.toLowerCase()}_missing`);
+    return value;
+}
+async function verifyRedis(redisUrl, namespace) {
+    const redis = new ioredis_1.Redis(redisUrl, { connectTimeout: 2000, maxRetriesPerRequest: 1, lazyConnect: true });
+    redis.on("error", () => undefined);
+    try {
+        await redis.connect();
+        const info = await redis.info("server");
+        const version = /^redis_version:([^\r\n]+)/m.exec(info)?.[1]?.trim() ?? "unknown";
+        if (version !== EXPECTED_REDIS_VERSION) {
+            throw new Error(`playdrop_dev_redis_version_mismatch:expected=${EXPECTED_REDIS_VERSION}:actual=${version}`);
+        }
+        const probeKey = `${namespace}preflight:${process.pid}`;
+        await redis.set(probeKey, "1", "EX", 5);
+        if ((await redis.get(probeKey)) !== "1")
+            throw new Error("playdrop_dev_redis_probe_failed");
+        await redis.del(probeKey);
+    }
+    finally {
+        await redis.quit().catch(() => undefined);
+    }
+}
+async function verifyScopedMongoUrl(mongoUrl) {
+    const mongo = new mongodb_1.MongoClient(mongoUrl, { serverSelectionTimeoutMS: 2000, maxPoolSize: 1 });
+    try {
+        await mongo.connect();
+        const database = mongo.db();
+        const buildInfo = (await database.admin().command({ buildInfo: 1 }));
+        const version = typeof buildInfo.version === "string" ? buildInfo.version : "unknown";
+        if (version !== EXPECTED_MONGODB_VERSION) {
+            throw new Error(`playdrop_dev_mongo_version_mismatch:expected=${EXPECTED_MONGODB_VERSION}:actual=${version}`);
+        }
+        const hello = (await database.admin().command({ hello: 1 }));
+        if (typeof hello.setName !== "string" || hello.isWritablePrimary !== true) {
+            throw new Error("playdrop_dev_mongo_replica_set_unavailable");
+        }
+        const probe = database.collection("_playdrop_dev_preflight");
+        await probe.updateOne({ _id: "scope" }, { $set: { checkedAt: new Date() } }, { upsert: true });
+        await probe.deleteOne({ _id: "scope" });
+        await mongo.db("admin").listCollections().toArray().then(() => { throw new Error("playdrop_dev_mongo_scope_failed"); }, (error) => {
+            if (!(error && typeof error === "object" && "code" in error && error.code === 13))
+                throw error;
+        });
+    }
+    finally {
+        await mongo.close().catch(() => undefined);
+    }
+}
+async function provisionScopedMongoUrl(mongoUrl, appId) {
+    const mongo = new mongodb_1.MongoClient(mongoUrl, { serverSelectionTimeoutMS: 2000, maxPoolSize: 1 });
+    try {
+        await mongo.connect();
+        const admin = mongo.db("admin");
+        const buildInfo = (await admin.command({ buildInfo: 1 }));
+        const version = typeof buildInfo.version === "string" ? buildInfo.version : "unknown";
+        if (version !== EXPECTED_MONGODB_VERSION) {
+            throw new Error(`playdrop_dev_mongo_version_mismatch:expected=${EXPECTED_MONGODB_VERSION}:actual=${version}`);
+        }
+        const hello = (await admin.command({ hello: 1 }));
+        if (hello.setName !== "playdrop-rs0" || hello.isWritablePrimary !== true) {
+            throw new Error("playdrop_dev_mongo_replica_set_unavailable");
+        }
+        const databaseName = `app_${appId}`;
+        const username = `playdrop-app-${appId}`;
+        const password = `playdrop-local-app-${appId}`;
+        const database = mongo.db(databaseName);
+        const users = (await database.command({ usersInfo: username }));
+        if (Array.isArray(users.users) && users.users.length > 0) {
+            await database.command({
+                updateUser: username,
+                pwd: password,
+                roles: [{ role: "readWrite", db: databaseName }],
+            });
+        }
+        else {
+            await database.command({
+                createUser: username,
+                pwd: password,
+                roles: [{ role: "readWrite", db: databaseName }],
+            });
+        }
+        const scoped = new URL(mongoUrl);
+        scoped.username = username;
+        scoped.password = password;
+        scoped.pathname = `/${databaseName}`;
+        scoped.searchParams.set("authSource", databaseName);
+        scoped.searchParams.set("maxPoolSize", "5");
+        const scopedUrl = scoped.toString();
+        const scopedClient = new mongodb_1.MongoClient(scopedUrl, { serverSelectionTimeoutMS: 2000, maxPoolSize: 1 });
+        try {
+            await scopedClient.connect();
+            await scopedClient.db().command({ ping: 1 });
+            const probe = scopedClient.db().collection("_playdrop_dev_preflight");
+            await probe.updateOne({ _id: "scope" }, { $set: { checkedAt: new Date() } }, { upsert: true });
+            await probe.deleteOne({ _id: "scope" });
+            await scopedClient.db("admin").listCollections().toArray().then(() => { throw new Error("playdrop_dev_mongo_scope_failed"); }, (error) => {
+                if (!(error && typeof error === "object" && "code" in error && error.code === 13))
+                    throw error;
+            });
+        }
+        finally {
+            await scopedClient.close().catch(() => undefined);
+        }
+        return scopedUrl;
+    }
+    finally {
+        await mongo.close().catch(() => undefined);
+    }
+}
+async function reserveLocalPort() {
+    const server = (0, node_net_1.createServer)();
+    await new Promise((resolveListen, rejectListen) => {
+        server.once("error", rejectListen);
+        server.listen(0, "127.0.0.1", () => resolveListen());
+    });
+    const address = server.address();
+    if (!address || typeof address === "string")
+        throw new Error("dev_rooms_port_unavailable");
+    await new Promise((resolveClose, rejectClose) => server.close((error) => error ? rejectClose(error) : resolveClose()));
+    return address.port;
+}
+function resolveDevRuntimeEntry(task) {
+    if (!task.packageJsonPath)
+        throw new Error("server_package_json_required");
+    const requireFromProject = (0, node_module_1.createRequire)(task.packageJsonPath);
+    try {
+        return requireFromProject.resolve("@playdrop/server/dev-runtime");
+    }
+    catch {
+        throw new Error("server_dev_runtime_missing:@playdrop/server must be installed in the game project");
+    }
+}
+async function waitForReady(child, timeoutMs = 10000) {
+    await new Promise((resolveReady, rejectReady) => {
+        let output = "";
+        const timer = setTimeout(() => rejectReady(new Error("dev_rooms_start_timeout")), timeoutMs);
+        const fail = (error) => {
+            clearTimeout(timer);
+            rejectReady(error);
+        };
+        child.once("error", fail);
+        child.once("exit", (code) => fail(new Error(`dev_rooms_exited:${code ?? "signal"}`)));
+        child.stdout?.on("data", (chunk) => {
+            const text = String(chunk);
+            process.stdout.write(text);
+            output += text;
+            for (const line of output.split("\n")) {
+                try {
+                    const event = JSON.parse(line);
+                    if (event.event === "rooms_runtime_ready") {
+                        clearTimeout(timer);
+                        resolveReady();
+                        return;
+                    }
+                }
+                catch {
+                    // Wait for a complete ready event line.
+                }
+            }
+            output = output.slice(-8192);
+        });
+        child.stderr?.on("data", (chunk) => process.stderr.write(chunk));
+    });
+}
+async function startDevGameServer(input) {
+    if (!input.task.server)
+        return null;
+    const redisUrl = requireServiceUrl("PLAYDROP_DEV_REDIS_URL");
+    const baseMongoUrl = requireServiceUrl("PLAYDROP_DEV_MONGO_URL");
+    const workerScoped = process.env.PLAYDROP_WORKER_CONTEXT === "1";
+    const redisNamespace = process.env.PLAYDROP_DEV_REDIS_NAMESPACE?.trim() ||
+        `colyseus:${input.credential.environment}:${input.credential.deploymentId}:`;
+    if (!isValidDevRedisNamespace(redisNamespace)) {
+        throw new Error("playdrop_dev_redis_namespace_invalid");
+    }
+    const scopedMongoUrl = workerScoped
+        ? baseMongoUrl
+        : await provisionScopedMongoUrl(baseMongoUrl, input.credential.appId);
+    await Promise.all([
+        verifyRedis(redisUrl, redisNamespace),
+        verifyScopedMongoUrl(scopedMongoUrl),
+    ]);
+    const build = await (0, serverBuild_1.buildGameServer)(input.task);
+    if (!build)
+        throw new Error("server_build_missing");
+    const port = await reserveLocalPort();
+    const runtimeEntry = resolveDevRuntimeEntry(input.task);
+    const child = (0, node_child_process_1.spawn)(process.execPath, ["--max-old-space-size=192", runtimeEntry], {
+        cwd: input.task.projectDir,
+        detached: process.platform !== "win32",
+        stdio: ["ignore", "pipe", "pipe"],
+        env: {
+            NODE_ENV: "development",
+            ...(process.env.TMPDIR ? { TMPDIR: process.env.TMPDIR } : {}),
+            ...(process.env.LANG ? { LANG: process.env.LANG } : {}),
+            PLAYDROP_ROOMS_BUNDLE: build.bundlePath,
+            PLAYDROP_ROOMS_MANIFEST: build.manifestPath,
+            PLAYDROP_ROOMS_PORT: String(port),
+            PLAYDROP_ROOMS_ENVIRONMENT: input.credential.environment,
+            PLAYDROP_ROOMS_DEPLOYMENT_ID: input.credential.deploymentId,
+            PLAYDROP_ROOMS_PUBLIC_ADDRESS: input.publicAddress,
+            PLAYDROP_PLATFORM_API_URL: input.platformApiUrl,
+            PLAYDROP_SERVICE_TOKEN: input.credential.serviceToken,
+            PLAYDROP_DEV_REDIS_URL: redisUrl,
+            PLAYDROP_DEV_REDIS_NAMESPACE: redisNamespace,
+            PLAYDROP_DEV_MONGO_URL: scopedMongoUrl,
+            PLAYDROP_MONGO_URL: scopedMongoUrl,
+        },
+    });
+    try {
+        await waitForReady(child);
+    }
+    catch (error) {
+        child.kill("SIGTERM");
+        throw error;
+    }
+    return { process: child, port, build };
+}

package/dist/commands/devRuntimeAssets.d.ts

@@ -13,6 +13,7 @@ export type LocalDevAppMetadata = {
     controllerMode: AppControllerMode;
     previewable: boolean;
     editorSupported: boolean;
+    hasServer: boolean;
     assetSpecSupport: AppMetadataAssetSpecSupport[];
     version: string | null;
     tweakValues?: TweakValues;

package/dist/commands/devRuntimeAssets.js

@@ -21,6 +21,7 @@ function createEmptyDevRuntimeAssetManifest() {
                 controllerMode: types_1.DEFAULT_APP_CONTROLLER_MODE,
                 previewable: types_1.DEFAULT_APP_PREVIEWABLE,
                 editorSupported: false,
+                hasServer: false,
                 assetSpecSupport: [],
                 version: null,
             },
@@ -120,6 +121,7 @@ function buildLocalAppMetadata(task) {
         controllerMode: task.controllerMode ?? types_1.DEFAULT_APP_CONTROLLER_MODE,
         previewable: task.previewable ?? types_1.DEFAULT_APP_PREVIEWABLE,
         editorSupported: task.editorSupported ?? false,
+        hasServer: Boolean(task.server),
         assetSpecSupport: task.assetSpecSupport.map((entry) => ({
             assetSpecRef: entry.assetSpec,
             versionRange: entry.versionRange,

package/dist/commands/devServer.d.ts

@@ -10,11 +10,14 @@ export interface StartDevServerOptions {
     port: number;
     projectInfo: ProjectInfo;
     runtimeAssetManifest?: DevRuntimeAssetManifestRegistration | null;
+    roomsPort?: number | null;
+    roomsProcess?: ChildProcess | null;
 }
 export interface DevServerHandle {
     server: null;
     devProcess: ChildProcess | null;
     startedDevProcess: boolean;
+    roomsProcess: ChildProcess | null;
     appUrl: string;
     close(): Promise<void>;
 }

package/dist/commands/devServer.js

@@ -24,7 +24,7 @@ const npmProcess_1 = require("./npmProcess");
 exports.DEV_ROUTER_PORT = 8888;
 const DEV_ROUTER_HOST = "127.0.0.1";
 const CONTROL_PREFIX = "/_playdrop";
-const DEV_ROUTER_PROTOCOL_VERSION = 3;
+const DEV_ROUTER_PROTOCOL_VERSION = 4;
 const APPROVED_PLAYDROP_WEB_ORIGINS = new Set(["https://playdrop.ai", "https://www.playdrop.ai"]);
 const CONTENT_TYPE_BY_EXTENSION = {
     ".html": "text/html; charset=utf-8",
@@ -231,6 +231,88 @@ function parseMountPath(pathname) {
         assetPath: rest.map((entry) => decodeURIComponent(entry)).join("/"),
     };
 }
+function resolveRoomsProxyTarget(rawUrl) {
+    let url;
+    try {
+        url = new URL(rawUrl || "/", `http://${DEV_ROUTER_HOST}`);
+    }
+    catch {
+        return null;
+    }
+    let decodedPathname;
+    try {
+        decodedPathname = decodeURIComponent(url.pathname);
+    }
+    catch {
+        return null;
+    }
+    const parsed = parseMountPath(decodedPathname);
+    if (!parsed || (parsed.assetPath !== "_playdrop/rooms" && !parsed.assetPath.startsWith("_playdrop/rooms/"))) {
+        return null;
+    }
+    const mountId = routerMountIdsByKey.get(parsed.key);
+    const mount = mountId ? routerMountsById.get(mountId) : null;
+    if (!mount?.roomsPort)
+        return null;
+    const suffix = parsed.assetPath.slice("_playdrop/rooms".length);
+    return { mount, upstreamPath: `${suffix || "/"}${url.search}` };
+}
+function proxyRoomsRequest(req, res, target) {
+    const proxy = node_http_1.default.request({
+        hostname: DEV_ROUTER_HOST,
+        port: target.mount.roomsPort,
+        method: req.method,
+        path: target.upstreamPath,
+        headers: { ...req.headers, host: `${DEV_ROUTER_HOST}:${target.mount.roomsPort}` },
+    }, (upstream) => {
+        res.statusCode = upstream.statusCode ?? 502;
+        for (const [name, value] of Object.entries(upstream.headers)) {
+            if (value !== undefined)
+                res.setHeader(name, value);
+        }
+        upstream.pipe(res);
+    });
+    proxy.on("error", () => {
+        if (!res.headersSent)
+            respondWithText(res, req.method || "GET", 502, "rooms_runtime_unavailable");
+        else
+            res.destroy();
+    });
+    req.pipe(proxy);
+}
+function proxyRoomsUpgrade(req, socket, head) {
+    cleanupStaleRouterMounts();
+    const target = resolveRoomsProxyTarget(req.url);
+    if (!target) {
+        socket.end("HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\n");
+        return;
+    }
+    const proxy = node_http_1.default.request({
+        hostname: DEV_ROUTER_HOST,
+        port: target.mount.roomsPort,
+        method: req.method,
+        path: target.upstreamPath,
+        headers: { ...req.headers, host: `${DEV_ROUTER_HOST}:${target.mount.roomsPort}` },
+    });
+    proxy.on("upgrade", (upstreamResponse, upstreamSocket, upstreamHead) => {
+        const headers = upstreamResponse.rawHeaders.reduce((lines, value, index, all) => {
+            if (index % 2 === 0)
+                lines.push(`${value}: ${all[index + 1] ?? ""}`);
+            return lines;
+        }, []);
+        socket.write(`HTTP/1.1 ${upstreamResponse.statusCode ?? 101} ${upstreamResponse.statusMessage ?? "Switching Protocols"}\r\n${headers.join("\r\n")}\r\n\r\n`);
+        if (upstreamHead.length > 0)
+            socket.write(upstreamHead);
+        if (head.length > 0)
+            upstreamSocket.write(head);
+        upstreamSocket.pipe(socket).pipe(upstreamSocket);
+    });
+    proxy.on("response", (response) => {
+        socket.end(`HTTP/1.1 ${response.statusCode ?? 502} ${response.statusMessage ?? "Bad Gateway"}\r\nConnection: close\r\n\r\n`);
+    });
+    proxy.on("error", () => socket.destroy());
+    proxy.end();
+}
 function getOwnedRuntimeAssetFile(mount, ownedAssetName, role) {
     const files = mount.runtimeAssetManifest?.ownedAssetFiles?.[ownedAssetName];
     if (!files) {
@@ -431,7 +513,8 @@ async function fetchRouterHealth(port = exports.DEV_ROUTER_PORT, timeoutMs = 400
 function isCompatibleRouterHealth(health) {
     return (health.protocolVersion === DEV_ROUTER_PROTOCOL_VERSION &&
         health.capabilities?.runtimeAssetManifest === true &&
-        health.capabilities?.runtimeAssetManifestLookup === true);
+        health.capabilities?.runtimeAssetManifestLookup === true &&
+        health.capabilities?.roomsProxy === true);
 }
 async function ensureDevRouterRunning(port = exports.DEV_ROUTER_PORT) {
     const existingHealth = await fetchRouterHealth(port);
@@ -520,7 +603,7 @@ async function updateMountedDevRuntimeAssetManifest(input) {
     }
 }
 async function startDevServer(options) {
-    const { appName, appType, creatorUsername, htmlPath, port, projectInfo, runtimeAssetManifest } = options;
+    const { appName, appType, creatorUsername, htmlPath, port, projectInfo, runtimeAssetManifest, roomsPort, roomsProcess } = options;
     const ownerPid = process.pid;
     let closing = false;
     const devProcess = spawnDevScript(projectInfo);
@@ -550,6 +633,7 @@ async function startDevServer(options) {
             repoRoot,
             ownerPid,
             runtimeAssetManifest: runtimeAssetManifest ?? null,
+            roomsPort: roomsPort ?? null,
         }, port);
         mountId = registeredMount.mountId;
         appUrl = registeredMount.appUrl;
@@ -558,6 +642,7 @@ async function startDevServer(options) {
         if (devProcess && !devProcess.killed) {
             devProcess.kill();
         }
+        await terminateChildProcessTree(roomsProcess ?? null);
         throw error;
     }
     const heartbeat = setInterval(() => {
@@ -569,6 +654,7 @@ async function startDevServer(options) {
         server: null,
         devProcess,
         startedDevProcess,
+        roomsProcess: roomsProcess ?? null,
         appUrl,
         close: async () => {
             if (closing)
@@ -579,7 +665,7 @@ async function startDevServer(options) {
                 await unregisterDevMount(mountId, port);
             }
             finally {
-                await terminateChildProcessTree(devProcess);
+                await Promise.all([terminateChildProcessTree(devProcess), terminateChildProcessTree(roomsProcess ?? null)]);
             }
         },
     };
@@ -645,6 +731,7 @@ function createDevRouterServer(initialPort = exports.DEV_ROUTER_PORT) {
                 capabilities: {
                     runtimeAssetManifest: true,
                     runtimeAssetManifestLookup: true,
+                    roomsProxy: true,
                 },
             });
             return;
@@ -724,6 +811,7 @@ function createDevRouterServer(initialPort = exports.DEV_ROUTER_PORT) {
             const staticRoot = body.staticRoot?.trim();
             const repoRoot = body.repoRoot?.trim();
             const ownerPid = Number(body.ownerPid);
+            const roomsPort = body.roomsPort == null ? null : Number(body.roomsPort);
             if (!creatorUsername ||
                 !appType ||
                 !appName ||
@@ -731,7 +819,8 @@ function createDevRouterServer(initialPort = exports.DEV_ROUTER_PORT) {
                 !staticRoot ||
                 !repoRoot ||
                 !Number.isInteger(ownerPid) ||
-                ownerPid <= 0) {
+                ownerPid <= 0 ||
+                (roomsPort !== null && (!Number.isInteger(roomsPort) || roomsPort < 1 || roomsPort > 65535))) {
                 sendJson(res, 400, { error: "invalid_mount_request" });
                 return;
             }
@@ -755,6 +844,7 @@ function createDevRouterServer(initialPort = exports.DEV_ROUTER_PORT) {
                     existingMount.ownerPid = ownerPid;
                     existingMount.updatedAt = Date.now();
                     existingMount.runtimeAssetManifest = body.runtimeAssetManifest ?? null;
+                    existingMount.roomsPort = roomsPort;
                     sendJson(res, 200, {
                         mountId: existingMount.id,
                         appUrl: buildLocalDevAppUrl({ creatorUsername, appType, appName, port: activePort }),
@@ -778,6 +868,7 @@ function createDevRouterServer(initialPort = exports.DEV_ROUTER_PORT) {
                 ownerPid,
                 updatedAt: Date.now(),
                 runtimeAssetManifest: body.runtimeAssetManifest ?? null,
+                roomsPort,
             };
             routerMountsById.set(mount.id, mount);
             routerMountIdsByKey.set(key, mount.id);
@@ -820,6 +911,11 @@ function createDevRouterServer(initialPort = exports.DEV_ROUTER_PORT) {
             return;
         }
         if (method !== "GET" && method !== "HEAD") {
+            const roomsTarget = resolveRoomsProxyTarget(req.url);
+            if (roomsTarget) {
+                proxyRoomsRequest(req, res, roomsTarget);
+                return;
+            }
             res.setHeader("Allow", "GET, HEAD, POST, DELETE, OPTIONS");
             respondWithText(res, method, 405, "Method not allowed");
             return;
@@ -836,6 +932,15 @@ function createDevRouterServer(initialPort = exports.DEV_ROUTER_PORT) {
             respondWithText(res, method, 404, "Not found");
             return;
         }
+        if (parsedMountPath.assetPath === "_playdrop/rooms" || parsedMountPath.assetPath.startsWith("_playdrop/rooms/")) {
+            const roomsTarget = resolveRoomsProxyTarget(req.url);
+            if (!roomsTarget) {
+                respondWithText(res, method, 503, "rooms_runtime_unavailable");
+                return;
+            }
+            proxyRoomsRequest(req, res, roomsTarget);
+            return;
+        }
         if (parsedMountPath.assetPath === "_playdrop/runtime-assets") {
             if (!mount.runtimeAssetManifest) {
                 sendJson(res, 500, { error: "runtime_asset_manifest_not_registered" });
@@ -901,6 +1006,7 @@ function createDevRouterServer(initialPort = exports.DEV_ROUTER_PORT) {
     const server = node_http_1.default.createServer((req, res) => {
         void handleRequest(req, res);
     });
+    server.on("upgrade", proxyRoomsUpgrade);
     server.on("listening", () => {
         const address = server.address();
         if (address && typeof address === "object" && typeof address.port === "number") {

package/dist/commands/generation.d.ts

@@ -1,5 +1,7 @@
-import type { ImageAttachment } from "@playdrop/ai-client";
 type AiGenerateOptions = {
+    system?: string;
+    textSize?: string;
+    responseSchema?: string;
     subcategory?: string;
     assetName?: string;
     assetDisplayName?: string;
@@ -33,16 +35,43 @@ type AiListOptions = {
     offset?: string | number;
     format?: string;
 };
+type GenerationModality = "TEXT" | "JSON" | "IMAGE" | "MUSIC" | "SFX" | "SPEECH" | "VIDEO" | "MODEL_3D";
+type ImageAttachment = {
+    url: string;
+} | {
+    data: string;
+    mimeType: "image/png" | "image/jpeg" | "image/webp";
+};
+type GenerateRequest = Record<string, any> & {
+    modality: GenerationModality;
+    input: string;
+};
+type ParsedGenerateInput = {
+    modality: GenerationModality;
+    request: GenerateRequest;
+    timeoutSeconds: number;
+    pollIntervalMs: number;
+};
 export declare function resolveImageAttachment(value: string | undefined, optionName: "image1" | "image2"): ImageAttachment | undefined;
+export declare function buildGenerateRequest(typeInput: string, promptInput: string, options: AiGenerateOptions): ParsedGenerateInput;
 export declare function generate(typeInput: string, promptInput: string, options?: AiGenerateOptions): Promise<void>;
-type AiJobBrowseOptions = {
+type AiTaskBrowseOptions = {
     type?: string;
     limit?: string | number;
     offset?: string | number;
     json?: boolean;
 };
-export declare function browseGenerationJobs(options?: AiJobBrowseOptions): Promise<void>;
-export declare function showGenerationJob(id: string | undefined, options?: {
+export declare function browseGenerationTasks(options?: AiTaskBrowseOptions): Promise<void>;
+export declare function showGenerationTask(id: string | undefined, options?: {
+    json?: boolean;
+}): Promise<void>;
+export declare function showGenerationTaskEvents(id: string | undefined, options?: {
+    json?: boolean;
+}): Promise<void>;
+export declare function cancelGenerationTask(id: string | undefined, options?: {
+    json?: boolean;
+}): Promise<void>;
+export declare function clearGenerationTask(id: string | undefined, options?: {
     json?: boolean;
 }): Promise<void>;
 export declare function generations(options?: AiListOptions): Promise<void>;