@base44-preview/sdk 0.8.44-pr.265.8da157e → 0.8.44-pr.267.4549331

package/dist/modules/build.js

@@ -1,499 +0,0 @@
-import { Base44Error } from "../utils/axios-client.js";
-import { readSseFrames } from "../utils/sse.js";
-const KNOWN_EVENT_TYPES = new Set([
-    "state.changed",
-    "turn.started",
-    "turn.finished",
-    "message.updated",
-    "error",
-    "conversation.reset",
-    "files.changed",
-]);
-// A turn in one of these has stopped. `blocked` counts: it is out of credits,
-// which resumes on a top-up rather than on anything a caller can await.
-const SETTLED_STATUSES = new Set(["idle", "error", "blocked"]);
-const RECONNECT_BASE_MS = 1000;
-const RECONNECT_MAX_MS = 30000;
-// Retry only what a retry can fix. Everything else — a rejected credential, a
-// session the server will not serve — would fail identically forever, and
-// hammering it is worse than surfacing it.
-const isRetryableStatus = (status) => status === 408 || status === 429 || status >= 500;
-const asRecord = (value) => value && typeof value === "object" ? value : {};
-const asString = (value) => typeof value === "string" && value ? value : undefined;
-function toState(raw) {
-    const source = asRecord(raw);
-    const state = { status: source.status };
-    const waiting = asRecord(source.waiting_on);
-    const waitpointId = asString(waiting.waitpoint_id);
-    if (waitpointId) {
-        const toolName = asString(waiting.tool_name);
-        state.waitingOn = {
-            kind: waiting.kind,
-            waitpointId,
-            ...(toolName ? { toolName } : {}),
-        };
-    }
-    const reason = asString(source.reason);
-    if (reason)
-        state.reason = reason;
-    const turnId = asString(source.turn_id);
-    if (turnId)
-        state.turnId = turnId;
-    const errorSource = asString(source.error_source);
-    if (errorSource)
-        state.errorSource = errorSource;
-    const detail = asString(source.detail);
-    if (detail)
-        state.detail = detail;
-    return state;
-}
-function toToolCall(raw) {
-    var _a, _b, _c, _d, _e, _f;
-    const source = asRecord(raw);
-    return {
-        id: (_a = asString(source.id)) !== null && _a !== void 0 ? _a : "",
-        name: (_b = asString(source.name)) !== null && _b !== void 0 ? _b : "",
-        status: (_c = asString(source.status)) !== null && _c !== void 0 ? _c : "",
-        requiresUserInput: Boolean(source.requires_user_input),
-        waitingOnKind: (_d = source.waiting_on_kind) !== null && _d !== void 0 ? _d : null,
-        // Kept as the raw string the model produced. It arrives mid-generation, so
-        // it is routinely incomplete JSON and parsing it here would throw on the
-        // ticks that matter most.
-        arguments: (_e = asString(source.arguments)) !== null && _e !== void 0 ? _e : "",
-        display: (_f = source.display) !== null && _f !== void 0 ? _f : null,
-    };
-}
-function toMessage(raw) {
-    var _a, _b;
-    const source = asRecord(raw);
-    const toolCalls = source.tool_calls;
-    return {
-        messageId: (_a = asString(source.message_id)) !== null && _a !== void 0 ? _a : "",
-        role: source.role,
-        content: (_b = asString(source.content)) !== null && _b !== void 0 ? _b : "",
-        toolCalls: Array.isArray(toolCalls) ? toolCalls.map(toToolCall) : [],
-    };
-}
-/**
- * Projects one SSE frame onto a typed event, or drops it.
- *
- * Unrecognised types are dropped here rather than passed through. The contract
- * requires clients to ignore them, so doing it once at the boundary is what lets
- * {@link BuildEvent} stay a closed union that narrows on `type` — the alternative
- * is an open union whose `data` is `unknown` in every branch.
- */
-function toBuildEvent(data, frameId) {
-    var _a, _b;
-    let parsed;
-    try {
-        parsed = JSON.parse(data);
-    }
-    catch (_c) {
-        return null;
-    }
-    const source = asRecord(parsed);
-    const type = asString(source.type);
-    if (!type || !KNOWN_EVENT_TYPES.has(type))
-        return null;
-    const base = { seq: (_b = (_a = asString(source.seq)) !== null && _a !== void 0 ? _a : frameId) !== null && _b !== void 0 ? _b : "" };
-    const turnId = asString(source.turn_id);
-    if (type === "message.updated") {
-        return { ...base, turnId, type, data: toMessage(source.data) };
-    }
-    if (type === "conversation.reset" || type === "files.changed") {
-        return { ...base, turnId, type, data: {} };
-    }
-    return {
-        ...base,
-        turnId,
-        type: type,
-        data: toState(source.data),
-    };
-}
-async function streamFailure(response) {
-    var _a;
-    const body = await response.text().catch(() => "");
-    let detail = body;
-    try {
-        detail = (_a = asString(asRecord(JSON.parse(body)).detail)) !== null && _a !== void 0 ? _a : body;
-    }
-    catch (_b) {
-        /* a non-JSON error body is still the best message available */
-    }
-    return new Base44Error(detail || `Build stream failed with ${response.status}`, response.status, "BUILD_STREAM_FAILED", body, undefined);
-}
-/** Every route in the family hangs off this. */
-const buildPath = (appId) => `/v1/apps/${encodeURIComponent(appId)}/build`;
-/**
- * The credential, resolved per call.
- *
- * Empty when there is no getter, which leaves whatever the Axios client already
- * carries in place.
- */
-async function bearer(getToken) {
-    const token = getToken ? await getToken() : undefined;
-    return token ? { Authorization: `Bearer ${token}` } : {};
-}
-function delay(ms, signal) {
-    return new Promise((resolve) => {
-        const timer = setTimeout(done, ms);
-        signal.addEventListener("abort", done, { once: true });
-        function done() {
-            clearTimeout(timer);
-            signal.removeEventListener("abort", done);
-            resolve();
-        }
-    });
-}
-/**
- * The read half of a build session — what a grant can do.
- *
- * @param deps - Transport, app id and credential.
- * @returns The read-only session.
- * @internal
- */
-export function createBuildSessionReader(deps) {
-    const { axios, appId, getToken } = deps;
-    const path = buildPath(appId);
-    const eventsUrl = `${deps.serverUrl.replace(/\/+$/, "")}/api${path}/events`;
-    const authHeaders = () => bearer(getToken);
-    const getState = async () => {
-        const response = await axios.get(`${path}/state`, {
-            headers: await authHeaders(),
-        });
-        return toState(asRecord(response).state);
-    };
-    const getTurn = async (turnId) => {
-        var _a;
-        const response = asRecord(await axios.get(`${path}/turns/${encodeURIComponent(turnId)}`, {
-            headers: await authHeaders(),
-        }));
-        return {
-            turnId: (_a = asString(response.turn_id)) !== null && _a !== void 0 ? _a : turnId,
-            live: Boolean(response.live),
-            state: toState(response.state),
-        };
-    };
-    const listMessages = async (options = {}) => {
-        var _a;
-        const params = {};
-        if (options.after !== undefined)
-            params.after = options.after;
-        if (options.limit !== undefined)
-            params.limit = options.limit;
-        const response = asRecord(await axios.get(`${path}/messages`, {
-            params,
-            headers: await authHeaders(),
-        }));
-        const messages = response.messages;
-        return {
-            messages: Array.isArray(messages) ? messages.map(toMessage) : [],
-            nextAfter: (_a = asString(response.next_after)) !== null && _a !== void 0 ? _a : null,
-        };
-    };
-    const subscribe = (onEvent, options = {}) => {
-        var _a;
-        const controller = new AbortController();
-        let cursor = options.lastEventId;
-        let stopped = false;
-        const stop = () => {
-            if (stopped)
-                return;
-            stopped = true;
-            controller.abort();
-        };
-        (_a = options.signal) === null || _a === void 0 ? void 0 : _a.addEventListener("abort", stop, { once: true });
-        const fail = (error) => {
-            var _a;
-            stop();
-            (_a = options.onError) === null || _a === void 0 ? void 0 : _a.call(options, error);
-        };
-        void (async () => {
-            let attempt = 0;
-            while (!stopped) {
-                try {
-                    const headers = {
-                        Accept: "text/event-stream",
-                        ...(await authHeaders()),
-                    };
-                    // Resuming from the cursor is what makes a dropped connection cost
-                    // nothing: the server replays what was missed before any live event.
-                    // Without it every reconnect would replay the whole retained window.
-                    if (cursor)
-                        headers["Last-Event-ID"] = cursor;
-                    const response = await globalThis.fetch(eventsUrl, {
-                        method: "GET",
-                        headers,
-                        signal: controller.signal,
-                        cache: "no-store",
-                    });
-                    if (!response.ok || !response.body)
-                        throw await streamFailure(response);
-                    attempt = 0;
-                    for await (const frame of readSseFrames(response.body)) {
-                        if (stopped)
-                            return;
-                        if (frame.id)
-                            cursor = frame.id;
-                        const event = toBuildEvent(frame.data, frame.id);
-                        if (event)
-                            onEvent(event);
-                    }
-                    // The body ended without an error. A drained deploy looks exactly like
-                    // this, so it is a reconnect rather than a completion — a build has no
-                    // end the transport knows about.
-                }
-                catch (error) {
-                    if (stopped)
-                        return;
-                    if (error instanceof Base44Error && !isRetryableStatus(error.status)) {
-                        fail(error);
-                        return;
-                    }
-                }
-                if (stopped)
-                    return;
-                const backoff = Math.min(RECONNECT_MAX_MS, RECONNECT_BASE_MS * 2 ** attempt++);
-                // Jittered, so a fleet of partner workers reconnecting after one outage
-                // does not arrive together.
-                await delay(backoff * (0.5 + Math.random() / 2), controller.signal);
-            }
-        })();
-        return stop;
-    };
-    async function* iterate(options = {}) {
-        const queue = [];
-        // Held in an object because the generator reads what the callback writes,
-        // and control-flow narrowing does not follow a closure assignment.
-        const shared = {
-            failure: null,
-            ended: false,
-        };
-        let wake = null;
-        const unsubscribe = subscribe((event) => {
-            queue.push(event);
-            wake === null || wake === void 0 ? void 0 : wake();
-        }, {
-            ...options,
-            onError: (error) => {
-                shared.failure = error;
-                shared.ended = true;
-                wake === null || wake === void 0 ? void 0 : wake();
-            },
-        });
-        try {
-            for (;;) {
-                while (queue.length)
-                    yield queue.shift();
-                if (shared.failure)
-                    throw shared.failure;
-                if (shared.ended)
-                    return;
-                await new Promise((resolve) => {
-                    wake = resolve;
-                });
-                wake = null;
-            }
-        }
-        finally {
-            unsubscribe();
-        }
-    }
-    const stream = (options) => ({
-        [Symbol.asyncIterator]: () => iterate(options),
-    });
-    async function* iterateText(options) {
-        var _a;
-        const sent = new Map();
-        for await (const event of stream(options)) {
-            switch (event.type) {
-                case "message.updated": {
-                    if (event.data.role !== "assistant")
-                        break;
-                    const previous = (_a = sent.get(event.data.messageId)) !== null && _a !== void 0 ? _a : "";
-                    const current = event.data.content;
-                    if (current === previous)
-                        break;
-                    sent.set(event.data.messageId, current);
-                    // Streaming text only ever extends. A snapshot that is not an
-                    // extension means the message was rewritten — a retry, an edit — and a
-                    // chat surface has already made what it printed immutable, so the
-                    // honest rendering is a new paragraph rather than a patch.
-                    yield current.startsWith(previous)
-                        ? current.slice(previous.length)
-                        : `\n\n${current}`;
-                    break;
-                }
-                case "turn.finished":
-                case "error":
-                    return;
-                case "turn.started":
-                case "state.changed":
-                    // `blocked` ends it too. No `turn.finished` follows a turn that ran
-                    // out of credits, so waiting for one would hang the loop.
-                    if (event.data.status === "blocked")
-                        return;
-                    break;
-                default:
-                    break;
-            }
-        }
-    }
-    const streamText = (options) => ({
-        [Symbol.asyncIterator]: () => iterateText(options),
-    });
-    const waitForTurn = (turnId, options = {}) => new Promise((resolve, reject) => {
-        var _a;
-        let settled = false;
-        const finish = (act) => {
-            if (settled)
-                return;
-            settled = true;
-            unsubscribe();
-            act();
-        };
-        const unsubscribe = subscribe((event) => {
-            // Only the events whose payload is a state can settle a turn. Written
-            // as the positive set so the union narrows to that arm.
-            if (event.type !== "turn.started" &&
-                event.type !== "turn.finished" &&
-                event.type !== "state.changed" &&
-                event.type !== "error") {
-                return;
-            }
-            if (event.turnId !== turnId && event.data.turnId !== turnId)
-                return;
-            if (SETTLED_STATUSES.has(event.data.status)) {
-                finish(() => resolve(event.data));
-            }
-        }, { signal: options.signal, onError: (error) => finish(() => reject(error)) });
-        (_a = options.signal) === null || _a === void 0 ? void 0 : _a.addEventListener("abort", () => finish(() => {
-            var _a;
-            return reject(((_a = options.signal) === null || _a === void 0 ? void 0 : _a.reason) instanceof Error
-                ? options.signal.reason
-                : new Error("Waiting for the build turn was aborted"));
-        }), { once: true });
-        // The turn may already have ended — between the write returning and this
-        // call, or before a resumed process got here — and a finished turn emits
-        // nothing more to wait for. Asked after subscribing, so the transition
-        // cannot fall between the two.
-        getTurn(turnId).then((turn) => {
-            if (!turn.live && SETTLED_STATUSES.has(turn.state.status)) {
-                finish(() => resolve(turn.state));
-            }
-        }, (error) => {
-            // 404 means the turn is not in the retained window, which a running
-            // turn also looks like right after it starts. Keep waiting.
-            if (!(error instanceof Base44Error) || error.status !== 404) {
-                finish(() => reject(error));
-            }
-        });
-    });
-    return {
-        appId,
-        getState,
-        listMessages,
-        getTurn,
-        waitForTurn,
-        subscribe,
-        stream,
-        streamText,
-    };
-}
-/**
- * A build session with the writes, for a credential that may start turns.
- *
- * @param deps - Transport, app id and credential.
- * @returns The full session.
- * @internal
- */
-export function createBuildSessionModule(deps) {
-    const { axios, appId, getToken, serverUrl } = deps;
-    const path = buildPath(appId);
-    const reader = createBuildSessionReader(deps);
-    const authHeaders = () => bearer(getToken);
-    const writeHeaders = async (idempotencyKey) => ({
-        ...(await authHeaders()),
-        ...(idempotencyKey ? { "Idempotency-Key": idempotencyKey } : {}),
-    });
-    // The server answers with the path, not a URL. Joining it here means a partner
-    // can hand the result to a client that is not this SDK without knowing which
-    // host minted it.
-    const absolute = (url) => {
-        if (!url)
-            return "";
-        if (/^https?:\/\//i.test(url))
-            return url;
-        if (!/^https?:\/\//i.test(serverUrl))
-            return url;
-        return new URL(url, serverUrl).toString();
-    };
-    return {
-        ...reader,
-        async sendMessage(content, options = {}) {
-            var _a, _b;
-            const body = { content };
-            if (options.fileUrls !== undefined)
-                body.file_urls = options.fileUrls;
-            const response = asRecord(await axios.post(`${path}/messages`, body, {
-                headers: await writeHeaders(options.idempotencyKey),
-            }));
-            return {
-                sessionId: (_a = asString(response.session_id)) !== null && _a !== void 0 ? _a : appId,
-                turnId: (_b = asString(response.turn_id)) !== null && _b !== void 0 ? _b : "",
-            };
-        },
-        async respond(response, options = {}) {
-            var _a, _b;
-            const body = {
-                kind: response.kind,
-                waitpoint_id: response.waitpointId,
-            };
-            if (response.kind === "approval") {
-                body.approved = response.approved;
-            }
-            else if (response.value !== undefined) {
-                // Omitted rather than sent as null: leaving it out is how you decline,
-                // and an explicit null would be a second way to say the same thing.
-                body.value = response.value;
-            }
-            const result = asRecord(await axios.post(`${path}/responses`, body, {
-                headers: await writeHeaders(options.idempotencyKey),
-            }));
-            return {
-                sessionId: (_a = asString(result.session_id)) !== null && _a !== void 0 ? _a : appId,
-                turnId: (_b = asString(result.turn_id)) !== null && _b !== void 0 ? _b : "",
-            };
-        },
-        async cancel() {
-            await axios.post(`${path}/cancel`, undefined, {
-                headers: await authHeaders(),
-            });
-        },
-        async createGrant(options = {}) {
-            var _a, _b, _c, _d;
-            const body = {};
-            if (options.ttlSeconds !== undefined) {
-                body.token_ttl_seconds = options.ttlSeconds;
-            }
-            if (options.subject !== undefined)
-                body.subject = options.subject;
-            const response = asRecord(await axios.post(`${path}/grants`, body, {
-                headers: await authHeaders(),
-            }));
-            return {
-                sessionId: (_a = asString(response.session_id)) !== null && _a !== void 0 ? _a : appId,
-                grantId: (_b = asString(response.grant_id)) !== null && _b !== void 0 ? _b : "",
-                token: (_c = asString(response.token)) !== null && _c !== void 0 ? _c : "",
-                expiresIn: Number(response.expires_in),
-                expiresAt: (_d = asString(response.expires_at)) !== null && _d !== void 0 ? _d : "",
-                eventsUrl: absolute(asString(response.events_url)),
-            };
-        },
-        async revokeGrant(grantId) {
-            await axios.delete(`${path}/grants/${encodeURIComponent(grantId)}`, {
-                headers: await authHeaders(),
-            });
-        },
-    };
-}