@lovable.dev/sdk 0.1.10 → 1.1.0

package/dist/index.js

@@ -1,23 +1,55 @@
 // src/client.ts
 import createClient from "openapi-fetch";
 
+// src/retryFetch.ts
+var RETRY_DELAYS_MS = [100, 300, 500];
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function parseRetryAfterMs(headers) {
+  const raw = headers.get("retry-after");
+  if (!raw) return void 0;
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
+  const dateMs = Date.parse(raw);
+  if (!Number.isNaN(dateMs)) {
+    const delta = dateMs - Date.now();
+    return delta > 0 ? delta : 0;
+  }
+  return void 0;
+}
+function makeRetryFetch(baseFetch = (input) => globalThis.fetch(input)) {
+  return async (input) => {
+    const clone = () => input.clone();
+    let response = await baseFetch(clone());
+    for (const planned of RETRY_DELAYS_MS) {
+      if (response.status !== 429) break;
+      const serverDelay = parseRetryAfterMs(response.headers);
+      await sleep(Math.max(planned, serverDelay ?? 0));
+      response = await baseFetch(clone());
+    }
+    return response;
+  };
+}
+
 // src/types.ts
 var ApiError = class extends Error {
   status;
   type;
   detail;
   props;
-  constructor(status, message, type, detail, props) {
+  rateLimit;
+  constructor(status, message, type, detail, props, rateLimit) {
     super(message);
     this.status = status;
     this.type = type;
     this.detail = detail;
     this.props = props;
+    this.rateLimit = rateLimit;
   }
 };
 
 // src/client.ts
 var DEFAULT_BASE_URL = "https://api.lovable.dev";
+var PUBLIC_API_CURSOR_VERSION = 1;
 function normalizeBaseUrl(url) {
   if (!url) return DEFAULT_BASE_URL;
   const normalized = url.replace(/\/$/, "");
@@ -26,6 +58,25 @@ function normalizeBaseUrl(url) {
   }
   return normalized;
 }
+function encodePublicCursor(id) {
+  const raw = JSON.stringify({ v: PUBLIC_API_CURSOR_VERSION, id });
+  const bytes = new TextEncoder().encode(raw);
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function normalizeWorkspaceList(body) {
+  return body.data ?? body.workspaces ?? [];
+}
+function cursorHasMore(body) {
+  return body.pagination?.has_more ?? body.has_more ?? false;
+}
+function requireCreateProjectId(project) {
+  if (!project.id) throw new Error("Create project response missing project ID");
+  return project;
+}
 var errorMiddleware = {
   async onResponse({ response }) {
     if (response.ok) return;
@@ -37,9 +88,32 @@ var errorMiddleware = {
     const message = buildErrorMessage(errorBody, response.status, response.statusText);
     const type = errorBody?.type ?? errorBody?.title;
     const detail = errorBody?.detail ?? errorBody?.details;
-    throw new ApiError(response.status, message, type, detail, errorBody?.props);
+    throw new ApiError(response.status, message, type, detail, errorBody?.props, parseRateLimitInfo(response.headers));
   }
 };
+function parseRateLimitInfo(headers) {
+  const limit = parsePositiveInt(headers.get("x-ratelimit-limit"));
+  const remaining = parsePositiveInt(headers.get("x-ratelimit-remaining"));
+  const retryAfterMs = parseRetryAfterMs2(headers.get("retry-after"));
+  if (limit == null && remaining == null && retryAfterMs == null) return void 0;
+  return { limit, remaining, retryAfterMs };
+}
+function parsePositiveInt(raw) {
+  if (raw == null) return void 0;
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 0 ? n : void 0;
+}
+function parseRetryAfterMs2(raw) {
+  if (!raw) return void 0;
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
+  const dateMs = Date.parse(raw);
+  if (!Number.isNaN(dateMs)) {
+    const delta = dateMs - Date.now();
+    return delta > 0 ? delta : 0;
+  }
+  return void 0;
+}
 function buildErrorMessage(body, status, statusText) {
   return body?.message || body?.title || (statusText ? `HTTP ${status}: ${statusText}` : `HTTP ${status}`);
 }
@@ -69,7 +143,8 @@ var LovableClient = class {
         ...this.authHeaders,
         ...this.extraHeaders,
         Accept: "application/json"
-      }
+      },
+      fetch: makeRetryFetch()
     });
     this.typedClient.use(errorMiddleware);
   }
@@ -83,112 +158,98 @@ var LovableClient = class {
   get typed() {
     return this.typedClient;
   }
-  async rawRequest(method, path, body, init) {
-    const url = `${this.baseUrl}${path}`;
-    const headers = {
-      "X-Client-Source": this.clientSource,
-      ...init?.headers,
-      ...this.authHeaders,
-      ...this.extraHeaders,
-      Accept: "application/json"
-    };
-    if (body !== void 0) {
-      headers["Content-Type"] = "application/json";
-    }
-    const response = await fetch(url, {
-      method,
-      headers,
-      body: body !== void 0 ? JSON.stringify(body) : void 0,
-      signal: init?.signal
-    });
-    if (!response.ok) {
-      let errorBody;
-      try {
-        errorBody = await response.json();
-      } catch {
-      }
-      const message = buildErrorMessage(errorBody, response.status, response.statusText);
-      const type = errorBody?.type ?? errorBody?.title;
-      const detail = errorBody?.detail ?? errorBody?.details;
-      throw new ApiError(response.status, message, type, detail, errorBody?.props);
-    }
-    return response;
-  }
-  async request(method, path, body) {
-    const response = await this.rawRequest(method, path, body);
-    if (response.status === 204) {
-      return void 0;
-    }
-    return response.json();
-  }
-  async requestText(method, path) {
-    const response = await this.rawRequest(method, path);
-    return response.text();
-  }
   /**
    * Get the current authenticated user and their workspaces.
    * Useful for validating an API key and discovering workspace IDs.
    */
   async me() {
     const { data } = await this.typed.GET("/v1/me");
-    return { ...data, workspaces: data.workspaces ?? [] };
+    return {
+      ...data,
+      workspaces: normalizeWorkspaceList(
+        data
+      )
+    };
   }
   /**
-   * List all workspaces the authenticated user has access to
+   * List workspaces the authenticated user has access to.
    */
-  async listWorkspaces() {
-    const response = await this.request("GET", "/v1/workspaces");
-    return response.workspaces ?? [];
+  async listWorkspaces(options = {}) {
+    const { data } = await this.typed.GET("/v1/workspaces", {
+      params: { query: options }
+    });
+    return { ...data, workspaces: normalizeWorkspaceList(data) };
   }
   /**
    * Get a specific workspace by ID
    */
   async getWorkspace(workspaceId) {
-    const response = await this.request("GET", `/v1/workspaces/${workspaceId}`);
-    return response.workspace;
+    const { data } = await this.typed.GET("/v1/workspaces/{workspace_id}", {
+      params: { path: { workspace_id: workspaceId } }
+    });
+    return data.workspace;
   }
   /**
    * List projects in a workspace.
    * Supports full-text search, filtering by visibility/publish status/folder/creator,
-   * and pagination via offset or cursor.
+   * and cursor pagination.
    */
   async listProjects(workspaceId, options) {
-    const params = new URLSearchParams();
-    if (options?.query) params.set("q", options.query);
-    if (options?.visibility) params.set("visibility", options.visibility);
-    if (options?.publish_status) params.set("publish_status", options.publish_status);
-    if (options?.folder_id) params.set("folder_id", options.folder_id);
-    if (options?.user_id) params.set("user_id", options.user_id);
-    if (options?.sort_by) params.set("sort_by", options.sort_by);
-    if (options?.sort_order) params.set("sort_order", options.sort_order);
-    if (options?.viewed_by_me) params.set("viewed_by_me", "true");
-    if (options?.limit !== void 0) params.set("limit", String(options.limit));
-    if (options?.offset !== void 0) params.set("offset", String(options.offset));
-    if (options?.cursor) params.set("cursor", options.cursor);
-    const query = params.toString();
-    const path = `/v1/workspaces/${workspaceId}/projects${query ? `?${query}` : ""}`;
-    return this.request("GET", path);
+    const { data } = await this.typed.GET("/v1/projects", {
+      params: {
+        query: {
+          workspace_id: workspaceId,
+          q: options?.query,
+          visibility: options?.visibility,
+          publish_status: options?.publish_status,
+          folder_id: options?.folder_id,
+          folder_ids: options?.folder_ids,
+          user_id: options?.user_id,
+          type: options?.type,
+          include_risk: options?.include_risk,
+          search_fields: options?.search_fields,
+          viewed_by_me: options?.viewed_by_me,
+          cursor: options?.cursor,
+          limit: options?.limit
+        }
+      }
+    });
+    const projects = data.projects ?? data.data ?? null;
+    const total = data.total;
+    return {
+      ...data,
+      projects,
+      ...total === void 0 ? {} : { total },
+      has_more: data.pagination?.has_more ?? data.has_more
+    };
   }
   /**
    * Create a new project in a workspace
    */
   async createProject(workspaceId, options) {
     let fileRefs;
+    let ephemeralFileRefs;
     if (options.uploadedFiles?.length) {
-      fileRefs = options.uploadedFiles;
+      ({ fileRefs, ephemeralFileRefs } = this.partitionUploadedFiles(options.uploadedFiles));
     } else if (options.files?.length) {
-      fileRefs = await this.uploadFiles(options.files);
+      ephemeralFileRefs = await this.uploadEphemeralFiles(options.files);
     }
     const body = {
       description: options.description,
       template_project_id: options.templateProjectId
     };
+    if (options.projectName) {
+      body.display_name = options.projectName;
+    }
     if (options.visibility) {
       body.visibility = options.visibility;
     }
     if (options.techStack) {
       body.tech_stack = options.techStack;
     }
+    if (options.sandboxTemplate) {
+      body.sandbox_template = options.sandboxTemplate;
+    }
     if (options.selectedLibraries?.length) {
       body.selected_libraries = options.selectedLibraries;
     }
@@ -198,73 +259,101 @@ var LovableClient = class {
     if (fileRefs?.length) {
       body.files = fileRefs;
     }
-    const project = await this.request("POST", `/v1/workspaces/${workspaceId}/projects`, body);
-    return project;
+    if (options.fileUrls?.length) {
+      body.file_urls = options.fileUrls;
+    }
+    if (ephemeralFileRefs?.length) {
+      body.ephemeral_files = ephemeralFileRefs;
+    }
+    const { data } = await this.typed.POST("/v1/projects", {
+      body: { ...body, workspace_id: workspaceId }
+    });
+    return requireCreateProjectId(data);
   }
   /**
    * Send a chat message to a project.
    *
    * The API accepts the message and processes it in the background.
    * Returns the message ID and status. Use `waitForMessageCompletion()`
-   * to poll for the AI response, or `waitForResponse()` for SSE streaming.
+   * to poll for the AI response.
    */
   async chat(projectId, options) {
     let fileRefs;
+    let ephemeralFileRefs;
     if (options.uploadedFiles?.length) {
-      fileRefs = options.uploadedFiles;
+      ({ fileRefs, ephemeralFileRefs } = this.partitionUploadedFiles(options.uploadedFiles));
     } else if (options.files?.length) {
-      fileRefs = await this.uploadFiles(options.files);
+      fileRefs = await this.uploadProjectFiles(projectId, options.files);
     }
     const body = {
       message: options.message
     };
+    if (options.variantId) {
+      body.variant_id = options.variantId;
+    }
     if (fileRefs) {
       body.files = fileRefs;
     }
+    if (ephemeralFileRefs) {
+      body.ephemeral_files = ephemeralFileRefs;
+    }
     if (options.planMode) {
       body.plan_mode = true;
     }
-    if (options.customModel) {
-      body.custom_model_endpoint = options.customModel.endpoint;
-      body.custom_model_api_key = options.customModel.apiKey;
-      body.custom_model_name = options.customModel.modelName;
-    }
-    if (options.customModelDisableRace) {
-      body.custom_model_disable_race = true;
-    }
     if (options.continuation) {
       body.continuation = options.continuation;
     }
-    return this.request("POST", `/v1/projects/${projectId}/messages`, body);
+    const { data } = await this.typed.POST("/v1/messages", {
+      body: { ...body, project_id: projectId }
+    });
+    return data;
   }
   /**
-   * Invite a user to a workspace as a collaborator
+   * Create an independent variant from the project's current main branch, or from a full baseSha when provided.
    */
-  async inviteCollaborator(workspaceId, options) {
-    const body = {
-      email: options.email,
-      role: options.role ?? "member"
-    };
-    return this.request("POST", `/workspaces/${workspaceId}/memberships`, body);
+  async createVariant(projectId, options = {}) {
+    const { data } = await this.typed.POST("/v1/projects/{project_id}/variants", {
+      params: { path: { project_id: projectId } },
+      body: { label: options.label, base_sha: options.baseSha }
+    });
+    return data;
+  }
+  /**
+   * Get project details by ID
+   */
+  async getProject(projectId) {
+    const { data } = await this.typed.GET("/v1/projects/{project_id}", {
+      params: { path: { project_id: projectId } }
+    });
+    return data;
   }
   /**
-   * List members of a workspace
+   * Create an anonymous, one-hour static preview URL for one exact HTTPS parent origin.
    */
-  async listWorkspaceMembers(workspaceId) {
-    const response = await this.request("GET", `/workspaces/${workspaceId}/memberships`);
-    return response.memberships ?? [];
+  async createEmbedUrl(projectId, parentOrigin) {
+    const { data } = await this.typed.POST("/v1/projects/{project_id}/embed-url", {
+      params: { path: { project_id: projectId } },
+      body: { parent_origin: parentOrigin }
+    });
+    return data;
   }
   /**
-   * Remove a member from a workspace
+   * Update supported project fields.
    */
-  async removeWorkspaceMember(workspaceId, userId) {
-    await this.request("DELETE", `/workspaces/${workspaceId}/memberships/${userId}`);
+  async updateProject(projectId, options) {
+    const { data } = await this.typed.PATCH("/v1/projects/{project_id}", {
+      params: { path: { project_id: projectId } },
+      body: options
+    });
+    return data;
   }
   /**
-   * Get project details by ID
+   * Soft-delete a project. Repeated deletes are treated as successful.
    */
-  async getProject(projectId) {
-    return this.request("GET", `/v1/projects/${projectId}`);
+  async deleteProject(projectId) {
+    await this.typed.DELETE("/v1/projects/{project_id}", {
+      params: { path: { project_id: projectId } }
+    });
   }
   /**
    * Get the preview URL for a project.
@@ -297,7 +386,10 @@ var LovableClient = class {
    * @returns Whether the database is enabled and which stack is used
    */
   async getDatabaseStatus(projectId) {
-    return this.request("GET", `/v1/projects/${projectId}/database`);
+    const { data } = await this.typed.GET("/v1/database", {
+      params: { query: { project_id: projectId } }
+    });
+    return data;
   }
   /**
    * Enable (provision) a cloud database for a project.
@@ -309,7 +401,10 @@ var LovableClient = class {
    * @returns The database status after enablement
    */
   async enableDatabase(projectId) {
-    return this.request("POST", `/v1/projects/${projectId}/database/enable`);
+    const { data } = await this.typed.POST("/v1/database/enable", {
+      body: { project_id: projectId }
+    });
+    return data;
   }
   /**
    * Execute a SQL query against the project's cloud database.
@@ -322,111 +417,211 @@ var LovableClient = class {
    * @returns Query result rows as JSON objects
    */
   async queryDatabase(projectId, sql) {
-    return this.request("POST", `/v1/projects/${projectId}/database/query`, { sql });
+    const compat = this.typedClient;
+    const { data } = await compat.POST("/v1/database/query", {
+      body: { project_id: projectId, sql }
+    });
+    return data;
   }
   // ---------------------------------------------------------------------------
   // Messages
   // ---------------------------------------------------------------------------
   /**
    * Get a message by ID. Returns the message content, status, and (for user messages)
-   * the AI response if available. Use to poll for completion after `chat()`.
+   * the AI response if available.
+   *
+   * Pass `waitSeconds` to long-poll: the server holds the request until the
+   * message reaches a terminal state (completed / stopped / error / awaiting_input) or the
+   * duration elapses. This replaces client-side polling for `waitForMessageCompletion`.
    */
-  async getMessage(projectId, messageId) {
-    return this.request("GET", `/v1/projects/${projectId}/messages/${messageId}`);
+  async getMessage(projectId, messageId, options) {
+    const waitSeconds = options?.waitSeconds;
+    const query = {
+      wait: waitSeconds && waitSeconds > 0 ? `${Math.floor(waitSeconds)}s` : void 0,
+      thread_id: options?.threadId
+    };
+    const { data } = await this.typed.GET("/v1/messages/{message_id}", {
+      params: { path: { message_id: messageId }, query: { ...query, project_id: projectId } }
+    });
+    return data;
   }
   /**
-   * List recent messages in a project, newest first. Use `before` (a message ID
-   * from a prior page) to paginate backwards through history.
+   * List recent messages in a project, newest first. Use `cursor` from the
+   * previous page's `pagination.next_cursor` to paginate through history.
    */
   async listMessages(projectId, params) {
-    const qs = new URLSearchParams();
-    if (params?.limit !== void 0) qs.set("limit", String(params.limit));
-    if (params?.before) qs.set("before", params.before);
-    const suffix = qs.toString() ? `?${qs.toString()}` : "";
-    return this.request("GET", `/v1/projects/${projectId}/messages${suffix}`);
+    const cursor = params?.cursor ?? (params?.before ? encodePublicCursor(params.before) : void 0);
+    const { data } = await this.typed.GET("/v1/messages", {
+      params: {
+        query: { project_id: projectId, limit: params?.limit, cursor }
+      }
+    });
+    return {
+      ...data,
+      messages: data.data,
+      has_more: cursorHasMore(data)
+    };
   }
   /**
-   * Poll for message completion. Waits until the AI response reaches a terminal
-   * status (completed, stopped) or the timeout expires.
+   * Wait for the AI response to reach a terminal status (completed, stopped, error, awaiting_input)
+   * or for `timeout` to elapse.
    *
-   * Handles edge cases: 404 grace period for race conditions between queue
-   * dequeue and event creation, and queue pause detection.
+   * Primary path is SSE against `/v1/messages/{message_id}/stream`: one
+   * held connection that pushes a snapshot on every relevant change and closes
+   * on terminal. If SSE isn't reachable (proxy strips text/event-stream, server
+   * returns 404 / 415 / 501) we fall back to the long-poll JSON endpoint on the
+   * same URL. Both paths share the same `MessageCompletionResult` shape.
    */
   async waitForMessageCompletion(projectId, messageId, options) {
-    const pollInterval = options?.pollInterval ?? 3e3;
     const timeout = options?.timeout ?? 6e5;
     const deadline = Date.now() + timeout;
+    const sse = await this.waitForMessageCompletionViaSSE(projectId, messageId, deadline, options?.threadId);
+    if (sse.kind === "result") {
+      return sse.result;
+    }
+    if (Date.now() >= deadline) {
+      return timeoutResult(messageId, timeout);
+    }
+    return this.waitForMessageCompletionViaLongPoll(projectId, messageId, deadline, timeout, options);
+  }
+  /**
+   * @deprecated Use `chat()` or `createProject()`'s returned `message_id`,
+   * then call `waitForMessageCompletion(projectId, messageId)`.
+   *
+   * Throws when the turn pauses for human input (`awaiting_input`) — the
+   * legacy `ChatResponse` shape cannot carry resume metadata. HITL-capable
+   * flows need `waitForMessageCompletion` plus `respondToTool`.
+   */
+  async waitForResponse(projectId, options) {
+    const messages = await this.listMessages(projectId, { limit: 10 });
+    const latest = messages.messages?.find((message) => message.role === "user");
+    if (!latest?.message_id) {
+      throw new Error(`No messages found for project ${projectId}`);
+    }
+    const completionOptions = options?.timeout === void 0 ? void 0 : { timeout: options.timeout };
+    const result = await this.waitForMessageCompletion(projectId, latest.message_id, completionOptions);
+    if (result.status !== "completed" && result.status !== "stopped") {
+      throw new Error(result.error ?? `Message ${latest.message_id} did not complete (status: ${result.status})`);
+    }
+    return {
+      content: result.content,
+      messageId: result.message_id,
+      previewUrl: this.getPreviewUrl(projectId)
+    };
+  }
+  async waitForMessageCompletionViaSSE(projectId, messageId, deadline, threadId) {
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) return { kind: "timeout" };
+    const url = new URL(`${this.baseUrl}/v1/messages/${encodeURIComponent(messageId)}/stream`);
+    url.searchParams.set("project_id", projectId);
+    if (threadId) {
+      url.searchParams.set("thread_id", threadId);
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), remaining);
+    let response;
+    try {
+      response = await fetch(url, {
+        headers: {
+          ...this.authHeaders,
+          ...this.extraHeaders,
+          "X-Client-Source": this.clientSource,
+          Accept: "text/event-stream"
+        },
+        signal: controller.signal
+      });
+    } catch (err) {
+      clearTimeout(timeoutId);
+      if (isAbortError(err)) return { kind: "timeout" };
+      return { kind: "fallback" };
+    }
+    if (!response.ok) {
+      clearTimeout(timeoutId);
+      if (response.status === 404 || response.status === 415 || response.status === 501) {
+        await cancelResponseBody(response);
+        return { kind: "fallback" };
+      }
+      if (response.status >= 500) {
+        await cancelResponseBody(response);
+        return { kind: "fallback" };
+      }
+      const detail = await safeReadText(response);
+      throw new ApiError(response.status, detail || `HTTP ${response.status}`);
+    }
+    if (!response.body) {
+      clearTimeout(timeoutId);
+      return { kind: "fallback" };
+    }
+    try {
+      for await (const frame of parseSSEFrames(response.body)) {
+        if (!frame.data) continue;
+        let snapshot;
+        try {
+          snapshot = JSON.parse(frame.data);
+        } catch {
+          continue;
+        }
+        const queuedResult = queuedExitResult(snapshot, messageId);
+        if (queuedResult) return { kind: "result", result: queuedResult };
+        const terminal = terminalResultFromMessage(snapshot, messageId);
+        if (terminal) {
+          return { kind: "result", result: terminal };
+        }
+      }
+      return { kind: "fallback" };
+    } catch (err) {
+      if (isAbortError(err)) return { kind: "timeout" };
+      return { kind: "fallback" };
+    } finally {
+      clearTimeout(timeoutId);
+      controller.abort();
+    }
+  }
+  async waitForMessageCompletionViaLongPoll(projectId, messageId, deadline, totalTimeoutMs, options) {
+    const waitSeconds = Math.max(1, Math.min(55, options?.waitSeconds ?? 30));
+    const transientBackoffMs = 1e3;
     let notFoundSince = null;
     const notFoundGraceMs = 15e3;
     while (Date.now() < deadline) {
+      const remainingMs = deadline - Date.now();
+      const perCallSeconds = Math.min(waitSeconds, Math.floor(remainingMs / 1e3));
+      const waitOptions = perCallSeconds > 0 ? { waitSeconds: perCallSeconds } : void 0;
+      const callStartedAt = Date.now();
       try {
-        const msg = await this.getMessage(projectId, messageId);
+        const msg = await this.getMessage(projectId, messageId, { ...waitOptions, threadId: options?.threadId });
         notFoundSince = null;
-        if (msg.status === "queued") {
-          if (msg.queue_paused && msg.queue_pause_reason !== "hitl_tool") {
+        const queuedResult = queuedExitResult(msg, messageId);
+        if (queuedResult) return queuedResult;
+        const terminal = terminalResultFromMessage(msg, messageId);
+        if (terminal) return terminal;
+        if (Date.now() - callStartedAt < transientBackoffMs) {
+          await sleep2(Math.min(transientBackoffMs, Math.max(0, deadline - Date.now())));
+        }
+      } catch (err) {
+        if (err instanceof ApiError) {
+          if (err.status === 404) {
+            if (notFoundSince === null) {
+              notFoundSince = Date.now();
+            }
+            if (Date.now() - notFoundSince < notFoundGraceMs) {
+              await sleep2(Math.min(transientBackoffMs, Math.max(0, deadline - Date.now())));
+              continue;
+            }
             return {
               status: "error",
               message_id: messageId,
               content: "",
-              error: `Message is queued (position ${msg.queue_position ?? "unknown"}) but the queue is paused` + (msg.queue_pause_reason ? ` (reason: ${msg.queue_pause_reason})` : "") + `. Unpause the queue in the Lovable editor, or use wait=false to return immediately.`
+              error: "Message not found. It may have been deleted from the queue."
             };
           }
-          await sleep(pollInterval);
-          continue;
-        }
-        const ai = msg.response;
-        if (ai) {
-          if (ai.status === "completed" || ai.status === "stopped") {
-            return {
-              status: ai.status === "completed" ? "completed" : "error",
-              message_id: ai.message_id,
-              content: ai.content,
-              edit_id: ai.edit_id,
-              commit_sha: ai.commit_sha,
-              summary: ai.summary,
-              cost_credits: ai.cost_credits
-            };
+          if (err.status < 500) {
+            throw err;
           }
         }
-        if (msg.role === "assistant") {
-          if (msg.status === "completed" || msg.status === "stopped") {
-            return {
-              status: msg.status === "completed" ? "completed" : "error",
-              message_id: msg.message_id,
-              content: msg.content,
-              edit_id: msg.edit_id,
-              commit_sha: msg.commit_sha,
-              summary: msg.summary,
-              cost_credits: msg.cost_credits
-            };
-          }
-        }
-        await sleep(pollInterval);
-      } catch (err) {
-        if (err instanceof ApiError && err.status === 404) {
-          if (notFoundSince === null) {
-            notFoundSince = Date.now();
-          }
-          if (Date.now() - notFoundSince < notFoundGraceMs) {
-            await sleep(pollInterval);
-            continue;
-          }
-          return {
-            status: "error",
-            message_id: messageId,
-            content: "",
-            error: "Message not found. It may have been deleted from the queue."
-          };
-        }
-        await sleep(pollInterval);
+        await sleep2(Math.min(transientBackoffMs, Math.max(0, deadline - Date.now())));
       }
     }
-    return {
-      status: "timeout",
-      message_id: messageId,
-      content: "",
-      error: `Agent did not finish within ${timeout / 1e3}s`
-    };
+    return timeoutResult(messageId, totalTimeoutMs);
   }
   // ---------------------------------------------------------------------------
   // Knowledge
@@ -440,73 +635,87 @@ var LovableClient = class {
   }
   /** Set workspace knowledge. Max 10,000 characters. */
   async setWorkspaceKnowledge(workspaceId, content) {
-    return this.request("PUT", `/v1/workspaces/${workspaceId}/knowledge`, { content });
+    const { data } = await this.typed.PUT("/v1/workspaces/{workspace_id}/knowledge", {
+      params: { path: { workspace_id: workspaceId } },
+      body: { content }
+    });
+    return data;
   }
   // ---------------------------------------------------------------------------
   // Workspace skills
   // ---------------------------------------------------------------------------
   /** List workspace skills. */
-  async listWorkspaceSkills(workspaceId, options) {
-    const qs = new URLSearchParams();
-    if (options?.includeMarkdown) qs.set("include_markdown", "true");
-    const suffix = qs.toString() ? `?${qs.toString()}` : "";
-    return this.request("GET", `/v1/workspaces/${workspaceId}/skills${suffix}`);
+  async listWorkspaceSkills(workspaceId, options = {}) {
+    const { data } = await this.typed.GET("/v1/workspaces/{workspace_id}/skills", {
+      params: {
+        path: { workspace_id: workspaceId },
+        query: { include_markdown: options.includeMarkdown, limit: options.limit, offset: options.offset }
+      }
+    });
+    return { ...data, skills: data.skills ?? [] };
   }
   /** Get a single workspace skill, including SKILL.md contents. */
   async getWorkspaceSkill(workspaceId, skillName) {
-    return this.request(
-      "GET",
-      `/v1/workspaces/${workspaceId}/skills/${encodeURIComponent(skillName)}`
-    );
+    const { data } = await this.typed.GET("/v1/workspaces/{workspace_id}/skills/{skill_name}", {
+      params: { path: { workspace_id: workspaceId, skill_name: skillName } }
+    });
+    return data;
   }
   /** Create a workspace skill from full SKILL.md markdown. */
   async createWorkspaceSkill(workspaceId, skillName, markdown) {
-    return this.request(
-      "POST",
-      `/v1/workspaces/${workspaceId}/skills/${encodeURIComponent(skillName)}`,
-      { markdown }
-    );
+    const { data } = await this.typed.POST("/v1/workspaces/{workspace_id}/skills/{skill_name}", {
+      params: { path: { workspace_id: workspaceId, skill_name: skillName } },
+      body: { markdown }
+    });
+    return data;
   }
   /** Update a workspace skill by replacing its SKILL.md markdown. */
   async updateWorkspaceSkill(workspaceId, skillName, markdown) {
-    return this.request(
-      "PUT",
-      `/v1/workspaces/${workspaceId}/skills/${encodeURIComponent(skillName)}`,
-      { markdown }
-    );
+    const { data } = await this.typed.PUT("/v1/workspaces/{workspace_id}/skills/{skill_name}", {
+      params: { path: { workspace_id: workspaceId, skill_name: skillName } },
+      body: { markdown }
+    });
+    return data;
   }
   /** Delete a workspace skill. */
   async deleteWorkspaceSkill(workspaceId, skillName) {
-    return this.request(
-      "DELETE",
-      `/v1/workspaces/${workspaceId}/skills/${encodeURIComponent(skillName)}`
-    );
+    const { data } = await this.typed.DELETE("/v1/workspaces/{workspace_id}/skills/{skill_name}", {
+      params: { path: { workspace_id: workspaceId, skill_name: skillName } }
+    });
+    return data;
   }
   // ---------------------------------------------------------------------------
   // Project skills
   // ---------------------------------------------------------------------------
   /** List project skills, including whether each skill is enabled. */
-  async listProjectSkills(projectId) {
-    return this.request("GET", `/v1/projects/${projectId}/skills`);
+  async listProjectSkills(projectId, options = {}) {
+    const { data } = await this.typed.GET("/v1/skills", {
+      params: { query: { project_id: projectId, limit: options.limit, cursor: options.cursor } }
+    });
+    const skills = data.skills ?? data.data ?? [];
+    return { ...data, skills };
   }
   /** Enable or disable a project skill without removing it from the project repo. */
   async setProjectSkillEnabled(projectId, skillName, enabled) {
-    return this.request(
-      "PUT",
-      `/v1/projects/${projectId}/skills/${encodeURIComponent(skillName)}/enabled`,
-      { enabled }
-    );
+    const { data } = await this.typed.PATCH("/v1/skills/{skill_name}", {
+      params: { path: { skill_name: skillName } },
+      body: { project_id: projectId, enabled }
+    });
+    return data;
   }
   /** Get project knowledge (custom instructions for the AI agent). */
   async getProjectKnowledge(projectId) {
-    const { data } = await this.typed.GET("/v1/projects/{project_id}/knowledge", {
-      params: { path: { project_id: projectId } }
+    const { data } = await this.typed.GET("/v1/knowledge", {
+      params: { query: { project_id: projectId } }
     });
     return data;
   }
   /** Set project knowledge. Max 10,000 characters. */
   async setProjectKnowledge(projectId, content) {
-    return this.request("PUT", `/v1/projects/${projectId}/knowledge`, { content });
+    const { data } = await this.typed.PUT("/v1/knowledge", {
+      body: { project_id: projectId, content }
+    });
+    return data;
   }
   // ---------------------------------------------------------------------------
   // Git operations
@@ -517,138 +726,207 @@ var LovableClient = class {
    * or `sha` for a specific commit.
    */
   async getDiff(projectId, params) {
-    const qs = new URLSearchParams();
-    if (params.messageId) qs.set("message_id", params.messageId);
-    if (params.sha) qs.set("sha", params.sha);
-    if (params.baseSha) qs.set("base_sha", params.baseSha);
-    return this.request("GET", `/v1/projects/${projectId}/git/diff?${qs.toString()}`);
-  }
-  /** List all files in a project at a specific git ref. */
-  async listFiles(projectId, ref) {
-    const qs = new URLSearchParams({ ref });
-    return this.request("GET", `/v1/projects/${projectId}/git/files?${qs.toString()}`);
-  }
-  /** Read the raw content of a single file at a specific git ref. Returns text. */
+    const { data } = await this.typed.GET("/v1/git/diff", {
+      params: {
+        query: { project_id: projectId, message_id: params.messageId, sha: params.sha, base_sha: params.baseSha }
+      }
+    });
+    return data;
+  }
+  async listFiles(projectId, refOrOptions, options = {}) {
+    const ref = typeof refOrOptions === "string" ? refOrOptions : void 0;
+    const pagination = typeof refOrOptions === "string" ? options : refOrOptions ?? options;
+    const { data } = await this.typed.GET("/v1/git/files", {
+      params: { query: { project_id: projectId, ref, limit: pagination.limit, cursor: pagination.cursor } }
+    });
+    const files = data.data ?? [];
+    return { ...data, data: files, files };
+  }
+  /** Read the raw content of a single file. Omitting ref uses the API default. */
   async readFile(projectId, path, ref) {
-    const qs = new URLSearchParams({ path, ref });
-    return this.requestText("GET", `/v1/projects/${projectId}/git/file?${qs.toString()}`);
+    const { data } = await this.typed.GET("/v1/git/files/{path}", {
+      params: { path: { path }, query: { project_id: projectId, ref } },
+      parseAs: "text"
+    });
+    return data;
   }
   // ---------------------------------------------------------------------------
   // Edits
   // ---------------------------------------------------------------------------
   /** List the edit history of a project. */
   async listEdits(projectId, params) {
-    const qs = new URLSearchParams();
-    if (params?.limit !== void 0) qs.set("limit", String(params.limit));
-    if (params?.before) qs.set("before", params.before);
-    const suffix = qs.toString() ? `?${qs.toString()}` : "";
-    return this.request("GET", `/v1/projects/${projectId}/edits${suffix}`);
+    const { data } = await this.typed.GET("/v1/edits", {
+      params: {
+        query: { project_id: projectId, limit: params?.limit, before: params?.before }
+      }
+    });
+    return data;
   }
   // ---------------------------------------------------------------------------
   // File upload
   // ---------------------------------------------------------------------------
-  /** Get a presigned URL for uploading a file. Returns the upload URL and file ID. */
+  /** Get an ephemeral presigned URL for uploading a file before a project exists. */
   async getFileUploadUrl(params) {
-    return this.request("POST", "/v1/files/upload-url", params);
+    return this.getEphemeralFileUploadUrl({ content_type: params.content_type });
+  }
+  /** Get a project-scoped presigned URL for uploading a file. Returns the upload URL, file ID, and required PUT headers. */
+  async getProjectFileUploadUrl(projectId, params) {
+    const { data } = await this.typed.POST("/v1/project-files/upload-url", {
+      body: { project_id: projectId, ...params }
+    });
+    return data;
+  }
+  /** Get an ephemeral presigned URL for uploading a file before a project exists. */
+  async getEphemeralFileUploadUrl(params) {
+    const { data } = await this.typed.POST("/v1/files/ephemeral-upload-url", { body: params });
+    return data;
   }
   // ---------------------------------------------------------------------------
   // Visibility
   // ---------------------------------------------------------------------------
-  /** Set a project's visibility (draft, private, or public). */
+  /** Set a project's visibility (draft, private, workspace_view, or public). */
   async setProjectVisibility(projectId, visibility) {
-    return this.request("PUT", `/v1/projects/${projectId}/visibility`, { visibility });
+    return this.updateProject(projectId, { visibility });
   }
   /** Set a folder's visibility (personal or workspace). */
   async setFolderVisibility(workspaceId, folderId, visibility) {
-    return this.request("PUT", `/v1/workspaces/${workspaceId}/folders/${folderId}/visibility`, {
-      visibility
+    const { data } = await this.typed.PUT("/v1/workspaces/{workspace_id}/folders/{folder_id}/visibility", {
+      params: { path: { workspace_id: workspaceId, folder_id: folderId } },
+      body: { visibility }
     });
+    return data;
+  }
+  /** Move projects into a folder, removing existing folder memberships first. */
+  async moveProjectsToFolder(workspaceId, folderId, projectIds) {
+    const { data } = await this.typed.POST("/v1/workspaces/{workspace_id}/folders/{folder_id}/projects/move", {
+      params: { path: { workspace_id: workspaceId, folder_id: folderId } },
+      body: { project_ids: projectIds }
+    });
+    return data;
   }
   // ---------------------------------------------------------------------------
   // Library & template projects
   // ---------------------------------------------------------------------------
   /** List available design system library projects in a workspace. */
-  async listLibraryProjects(workspaceId) {
-    return this.request(
-      "GET",
-      `/v1/workspaces/${workspaceId}/available-library-projects`
-    );
+  async listLibraryProjects(workspaceId, options = {}) {
+    const { data } = await this.typed.GET("/v1/workspaces/{workspace_id}/available-library-projects", {
+      params: { path: { workspace_id: workspaceId }, query: options }
+    });
+    return { ...data, libraries: data.libraries ?? [] };
   }
   /** List available template projects in a workspace. */
-  async listTemplateProjects(workspaceId) {
-    return this.request(
-      "GET",
-      `/v1/workspaces/${workspaceId}/available-template-projects`
-    );
+  async listTemplateProjects(workspaceId, options = {}) {
+    const { data } = await this.typed.GET("/v1/workspaces/{workspace_id}/available-template-projects", {
+      params: { path: { workspace_id: workspaceId }, query: options }
+    });
+    return { ...data, templates: data.templates ?? [] };
   }
   // ---------------------------------------------------------------------------
   // Connectors (MCP servers)
   // ---------------------------------------------------------------------------
   /** List all connectors in a workspace. */
-  async listConnectors(workspaceId) {
-    return this.request("GET", `/v1/workspaces/${workspaceId}/connectors`);
+  async listConnectors(workspaceId, options = {}) {
+    const { data } = await this.typed.GET("/v1/connectors", {
+      params: {
+        query: {
+          workspace_id: workspaceId,
+          type: options.type,
+          status: options.status,
+          limit: options.limit,
+          cursor: options.cursor
+        }
+      }
+    });
+    const connectors = data.connectors ?? data.data ?? [];
+    return { ...data, data: connectors, connectors, has_more: cursorHasMore(data) };
   }
   /** Add a connector to a workspace. The server URL is tested before saving. */
   async addConnector(workspaceId, body) {
-    return this.request("POST", `/v1/workspaces/${workspaceId}/connectors`, body);
+    const { data } = await this.typed.POST("/v1/connectors", {
+      body: { ...body, workspace_id: workspaceId }
+    });
+    return data;
   }
   /** Remove a connector from a workspace. */
   async removeConnector(workspaceId, connectorId) {
-    return this.request("DELETE", `/v1/workspaces/${workspaceId}/connectors/${connectorId}`);
+    const { data } = await this.typed.DELETE("/v1/connectors/{connector_id}", {
+      params: { path: { connector_id: connectorId }, query: { workspace_id: workspaceId } }
+    });
+    return data;
   }
   /** Browse available connector templates. */
-  async listAvailableConnectors(workspaceId) {
-    return this.request(
-      "GET",
-      `/v1/workspaces/${workspaceId}/available-connectors`
-    );
+  async listAvailableConnectors(workspaceId, options = {}) {
+    const { data } = await this.typed.GET("/v1/available-connectors", {
+      params: { query: { workspace_id: workspaceId, limit: options.limit, cursor: options.cursor } }
+    });
+    const catalog = data.catalog ?? data.data ?? [];
+    return { ...data, data: catalog, catalog, has_more: cursorHasMore(data) };
   }
   // ---------------------------------------------------------------------------
   // Connectors
   // ---------------------------------------------------------------------------
   /** List standard (OAuth-based) connectors in a workspace. */
-  async listStandardConnectors(workspaceId) {
-    return this.request(
-      "GET",
-      `/v1/workspaces/${workspaceId}/connectors/standard`
-    );
+  async listStandardConnectors(workspaceId, options = {}) {
+    const { data } = await this.typed.GET("/v1/connectors", {
+      params: { query: { workspace_id: workspaceId, type: "standard", limit: options.limit, cursor: options.cursor } }
+    });
+    const connectors = data.connectors ?? data.data ?? [];
+    return { ...data, data: connectors, connectors, has_more: cursorHasMore(data) };
   }
   /** List seamless (zero-config) connectors in a workspace. */
-  async listSeamlessConnectors(workspaceId) {
-    return this.request(
-      "GET",
-      `/v1/workspaces/${workspaceId}/connectors/seamless`
-    );
+  async listSeamlessConnectors(workspaceId, options = {}) {
+    const { data } = await this.typed.GET("/v1/connectors", {
+      params: { query: { workspace_id: workspaceId, type: "seamless", limit: options.limit, cursor: options.cursor } }
+    });
+    const connectors = data.connectors ?? data.data ?? [];
+    return { ...data, data: connectors, connectors, has_more: cursorHasMore(data) };
   }
   /** List MCP connectors in a workspace. */
-  async listMCPConnectors(workspaceId) {
-    return this.request(
-      "GET",
-      `/v1/workspaces/${workspaceId}/connectors/mcp`
-    );
+  async listMCPConnectors(workspaceId, options = {}) {
+    const { data } = await this.typed.GET("/v1/connectors", {
+      params: { query: { workspace_id: workspaceId, type: "mcp", limit: options.limit, cursor: options.cursor } }
+    });
+    const connectors = data.connectors ?? data.data ?? [];
+    return { ...data, data: connectors, connectors, has_more: cursorHasMore(data) };
   }
   /** List authenticated connections (accounts) in a workspace. */
-  async listConnections(workspaceId, params) {
-    const qs = new URLSearchParams();
-    if (params?.connector_id) qs.set("connector_id", params.connector_id);
-    const suffix = qs.toString() ? `?${qs.toString()}` : "";
-    return this.request("GET", `/v1/workspaces/${workspaceId}/connections${suffix}`);
+  async listConnections(workspaceId, params = {}) {
+    const { data } = await this.typed.GET("/v1/connections", {
+      params: {
+        query: {
+          workspace_id: workspaceId,
+          connector_id: params.connector_id,
+          limit: params.limit,
+          cursor: params.cursor
+        }
+      }
+    });
+    const connections = data.data ?? [];
+    return { ...data, data: connections, connections, has_more: cursorHasMore(data) };
   }
   // ---------------------------------------------------------------------------
   // Analytics
   // ---------------------------------------------------------------------------
   /** Get historical analytics for a published project. */
   async getProjectAnalytics(projectId, params) {
-    const qs = new URLSearchParams({
-      startDate: params.startDate,
-      endDate: params.endDate
+    const { data } = await this.typed.GET("/v1/analytics", {
+      params: {
+        query: {
+          project_id: projectId,
+          startDate: params.startDate,
+          endDate: params.endDate,
+          granularity: params.granularity
+        }
+      }
     });
-    if (params.granularity) qs.set("granularity", params.granularity);
-    return this.request("GET", `/v1/projects/${projectId}/analytics?${qs.toString()}`);
+    return data;
   }
   /** Get real-time visitor trend for a published project. */
   async getProjectAnalyticsTrend(projectId) {
-    return this.request("GET", `/v1/projects/${projectId}/analytics/trend`);
+    const { data } = await this.typed.GET("/v1/analytics/trend", {
+      params: { query: { project_id: projectId } }
+    });
+    return data;
   }
   /**
    * Publish a project.
@@ -661,50 +939,57 @@ var LovableClient = class {
    * @returns Deployment info including deployment ID
    */
   async publish(projectId, options) {
-    return this.request("POST", `/v1/projects/${projectId}/deployments`, {
-      name: options?.name
+    const { data } = await this.typed.POST("/v1/deployments", {
+      body: { project_id: projectId, name: options?.name }
     });
+    return data;
   }
   /**
    * Remix (fork) an existing project, optionally at a specific message point in time.
    *
-   * When `messageId` is provided, the remix captures the project state as it was
-   * just before that message was processed (default). Set `remixMode: "including"`
-   * to include the message and its AI response in the remix.
+   * When `messageId` is provided, the remix captures the project state after
+   * that message and its AI response by default. Set `remixMode: "before"` to
+   * start before the message was processed.
    * Without `messageId`, the full current state is remixed.
    *
    * @param sourceProjectId - The project to remix from
    * @param options.workspaceId - Target workspace for the new project
    * @param options.messageId - Optional message ID to snapshot at
-   * @param options.remixMode - "before" (default): state before the message; "including": state after the message and its AI response
+   * @param options.remixMode - "including" (server default): state after the message and its AI response; "before": state before the message
    * @param options.includeHistory - Whether to preserve chat history (default: false)
    * @param options.includeCustomKnowledge - Whether to copy custom instructions (default: false)
    * @param options.initialMessage - Optional initial message to send after remix
+   * @param options.description - Optional custom description for the new project
    * @returns The remix job ID for polling progress
    */
   async remixProject(sourceProjectId, options) {
     const body = {
       workspace_id: options.workspaceId,
+      source_project_id: sourceProjectId,
       include_history: options.includeHistory,
       include_custom_knowledge: options.includeCustomKnowledge,
-      project_name: options.projectName,
+      description: options.description,
+      display_name: options.projectName,
       skip_initial_remix_message: options.skipInitialRemixMessage,
       skip_integrations: options.skipIntegrations
     };
     if (options.messageId) {
       body.message_id = options.messageId;
-      body.remix_mode = options.remixMode ?? "before";
+      if (options.remixMode) {
+        body.remix_mode = options.remixMode;
+      }
     }
     if (options.initialMessage) {
-      body.initial_message = {
-        id: crypto.randomUUID(),
-        message: options.initialMessage,
-        chat_only: false,
-        headless: true
-      };
+      body.initial_message = options.initialMessage;
+    }
+    const { data } = await this.typed.POST("/v1/projects", {
+      body
+    });
+    const remix = data;
+    if (!remix?.job_id) {
+      throw new Error("Failed to get job ID from remix create");
     }
-    const response = await this.request("POST", `/v1/projects/${sourceProjectId}/remix/init`, body);
-    return response.job_id;
+    return remix.job_id;
   }
   /**
    * Wait for a remix operation to complete.
@@ -724,21 +1009,25 @@ var LovableClient = class {
     const timeout = options?.timeout ?? 3e5;
     const startTime = Date.now();
     while (true) {
-      const progress = await this.request(
-        "GET",
-        `/v1/projects/${sourceProjectId}/remix/progress?job_id=${encodeURIComponent(jobId)}`
-      );
-      options?.onProgress?.(progress.status, progress.step);
-      if (progress.status === "completed" && progress.result) {
+      const { data } = await this.typed.GET("/v1/projects/{project_id}/remix/progress", {
+        params: {
+          path: { project_id: sourceProjectId },
+          query: { job_id: jobId }
+        }
+      });
+      const progress = data;
+      const status = progress.status;
+      options?.onProgress?.(status, progress.step);
+      if (status === "completed" && progress.result) {
         return { projectId: progress.result.project_id };
       }
-      if (progress.status === "error") {
+      if (status === "error") {
         throw new Error(progress.error_message ?? "Remix failed");
       }
       if (Date.now() - startTime > timeout) {
         throw new Error(`Timeout waiting for remix of project ${sourceProjectId}`);
       }
-      await sleep(pollInterval);
+      await sleep2(pollInterval);
     }
   }
   /**
@@ -771,140 +1060,59 @@ var LovableClient = class {
       if (Date.now() - startTime > timeout) {
         throw new Error(`Timeout waiting for project ${projectId} to be ready`);
       }
-      await sleep(pollInterval);
-    }
-  }
-  /**
-   * Wait for the AI response to a chat message.
-   *
-   * Connects to the project's message stream (SSE) and accumulates the
-   * response content until the message is complete. Returns the full
-   * response text along with the project's preview URL.
-   *
-   * Use this after `chat()` or after `createProject()` with `initialMessage`.
-   *
-   * @param projectId - The project ID to listen for
-   * @param options.timeout - Maximum time to wait in ms (default: 300000 = 5 minutes)
-   * @returns The AI response content and preview URL
-   * @throws Error if the stream fails or timeout is reached
-   */
-  async waitForResponse(projectId, options) {
-    const timeout = options?.timeout ?? 3e5;
-    const url = `${this.baseUrl}/v1/projects/${projectId}/messages/stream`;
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-    try {
-      const response = await fetch(url, {
-        headers: {
-          ...this.authHeaders,
-          ...this.extraHeaders
-        },
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        throw new ApiError(response.status, `Failed to connect to message stream: HTTP ${response.status}`);
-      }
-      if (!response.body) {
-        throw new Error("Response body is not readable");
-      }
-      const result = await this.consumeSSEStream(response.body);
-      return {
-        content: result.content,
-        messageId: result.messageId,
-        previewUrl: this.getPreviewUrl(projectId)
-      };
-    } catch (err) {
-      if (err instanceof DOMException && err.name === "AbortError") {
-        throw new Error(`Timeout waiting for response on project ${projectId}`);
-      }
-      throw err;
-    } finally {
-      clearTimeout(timeoutId);
+      await sleep2(pollInterval);
     }
   }
   isFileInput(file) {
     return "data" in file;
   }
-  async uploadFile(file) {
+  async uploadFile(file, getUploadUrl) {
     const fileName = this.isFileInput(file) ? file.name : file.name;
     const mimeType = this.isFileInput(file) ? file.type : file.type;
     const body = this.isFileInput(file) ? file.data : file;
-    const { url, file_id: objectPath } = await this.request(
-      "POST",
-      "/v1/files/upload-url",
-      {
-        file_name: fileName,
-        content_type: mimeType
-      }
-    );
+    const uploadUrl = await getUploadUrl(fileName, mimeType);
+    const { url, file_id: objectPath, headers } = uploadUrl;
     const uploadResponse = await fetch(url, {
       method: "PUT",
       body,
-      headers: { "Content-Type": mimeType }
+      headers: { "Content-Type": mimeType, ...headers }
     });
     if (!uploadResponse.ok) {
       throw new Error(`File upload failed for "${fileName}": HTTP ${uploadResponse.status}`);
     }
     return { file_id: objectPath, type: "user_upload", file_name: fileName, mime_type: mimeType };
   }
-  async uploadFiles(files) {
-    return Promise.all(files.map((file) => this.uploadFile(file)));
+  async uploadProjectFiles(projectId, files) {
+    return Promise.all(
+      files.map(
+        (file) => this.uploadFile(
+          file,
+          (_fileName, mimeType) => this.getProjectFileUploadUrl(projectId, { content_type: mimeType })
+        )
+      )
+    );
   }
-  async consumeSSEStream(body) {
-    const reader = body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    let content = "";
-    let messageId = "";
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        const parts = buffer.split("\n\n");
-        buffer = parts.pop() ?? "";
-        for (const part of parts) {
-          if (!part.trim()) continue;
-          const lines = part.split("\n");
-          let eventType = "";
-          let eventData = "";
-          for (const line of lines) {
-            if (line.startsWith("event: ")) {
-              eventType = line.slice(7);
-            } else if (line.startsWith("data: ")) {
-              eventData = line.slice(6);
-            }
-          }
-          if (eventType === "message" && eventData) {
-            try {
-              const data = JSON.parse(eventData);
-              if (typeof data.content === "string") {
-                content += data.content;
-              }
-              if (typeof data.message_id === "string" && data.message_id) {
-                messageId = data.message_id;
-              }
-              if (data.is_final) {
-                return { content, messageId };
-              }
-            } catch {
-            }
-          }
-          if (eventType === "error") {
-            let detail = "Stream error from server";
-            try {
-              const data = JSON.parse(eventData);
-              if (data.message) detail = data.message;
-            } catch {
-            }
-            throw new Error(detail);
-          }
-        }
+  async uploadEphemeralFiles(files) {
+    return Promise.all(
+      files.map(
+        (file) => this.uploadFile(file, (_fileName, mimeType) => this.getEphemeralFileUploadUrl({ content_type: mimeType }))
+      )
+    );
+  }
+  partitionUploadedFiles(files) {
+    const fileRefs = [];
+    const ephemeralFileRefs = [];
+    for (const file of files) {
+      if (file.file_id.startsWith("ephemeral/")) {
+        ephemeralFileRefs.push(file);
+      } else {
+        fileRefs.push(file);
       }
-    } finally {
-      void reader.cancel();
     }
-    return { content, messageId };
+    return {
+      fileRefs: fileRefs.length > 0 ? fileRefs : void 0,
+      ephemeralFileRefs: ephemeralFileRefs.length > 0 ? ephemeralFileRefs : void 0
+    };
   }
   /**
    * Wait for a project to be published (deployed).
@@ -934,13 +1142,123 @@ var LovableClient = class {
       if (Date.now() - startTime > timeout) {
         throw new Error(`Timeout waiting for project ${projectId} to be published`);
       }
-      await sleep(pollInterval);
+      await sleep2(pollInterval);
     }
   }
 };
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function isAbortError(err) {
+  return typeof err === "object" && err !== null && "name" in err && err.name === "AbortError";
+}
+async function safeReadText(response) {
+  try {
+    return await response.text();
+  } catch {
+    return "";
+  }
+}
+async function cancelResponseBody(response) {
+  try {
+    await response.body?.cancel();
+  } catch {
+  }
+}
+async function* parseSSEFrames(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let sep = buffer.indexOf("\n\n");
+      while (sep !== -1) {
+        const raw = buffer.slice(0, sep);
+        buffer = buffer.slice(sep + 2);
+        sep = buffer.indexOf("\n\n");
+        let event = "message";
+        const dataLines = [];
+        for (const line of raw.split("\n")) {
+          if (!line || line.startsWith(":")) continue;
+          if (line.startsWith("event:")) {
+            event = line.slice(6).trimStart();
+          } else if (line.startsWith("data:")) {
+            dataLines.push(line.slice(5).trimStart());
+          }
+        }
+        if (dataLines.length === 0) continue;
+        yield { event, data: dataLines.join("\n") };
+      }
+    }
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+    try {
+      await body.cancel();
+    } catch {
+    }
+  }
+}
+function terminalResultFromMessage(msg, fallbackMessageId) {
+  const ai = msg.response;
+  if (ai && isTerminalAIStatus(ai.status)) {
+    return {
+      status: messageCompletionStatus(ai.status),
+      message_id: ai.message_id || fallbackMessageId,
+      content: ai.content,
+      edit_id: ai.edit_id,
+      commit_sha: ai.commit_sha,
+      summary: ai.summary,
+      cost_credits: ai.cost_credits,
+      awaiting_input: ai.awaiting_input,
+      ...ai.status === "error" ? { error: "Agent reported an error." } : {}
+    };
+  }
+  if (msg.role === "assistant" && isTerminalAIStatus(msg.status)) {
+    return {
+      status: messageCompletionStatus(msg.status),
+      message_id: msg.message_id || fallbackMessageId,
+      content: msg.content,
+      edit_id: msg.edit_id,
+      commit_sha: msg.commit_sha,
+      summary: msg.summary,
+      cost_credits: msg.cost_credits,
+      awaiting_input: msg.awaiting_input,
+      ...msg.status === "error" ? { error: "Agent reported an error." } : {}
+    };
+  }
+  return null;
+}
+function messageCompletionStatus(status) {
+  return status === "completed" || status === "stopped" || status === "awaiting_input" ? status : "error";
+}
+function isTerminalAIStatus(status) {
+  return status === "completed" || status === "stopped" || status === "error" || status === "awaiting_input";
+}
+function queuedExitResult(msg, fallbackMessageId) {
+  if (msg.status !== "queued") return null;
+  if (!msg.queue_paused) return null;
+  if (msg.queue_pause_reason === "hitl_tool") return null;
+  return {
+    status: "error",
+    message_id: fallbackMessageId,
+    content: "",
+    error: `Message is queued (position ${msg.queue_position ?? "unknown"}) but the queue is paused` + (msg.queue_pause_reason ? ` (reason: ${msg.queue_pause_reason})` : "") + `. Unpause the queue in the Lovable editor, or use wait=false to return immediately.`
+  };
+}
+function timeoutResult(messageId, timeoutMs) {
+  return {
+    status: "timeout",
+    message_id: messageId,
+    content: "",
+    error: `Agent did not finish within ${Math.max(0, Math.round(timeoutMs / 1e3))}s`
+  };
+}
 export {
   ApiError,
   LovableClient