@nodaro/sdk 2.5.0 → 2.7.0

package/dist/index.cjs

@@ -146,6 +146,20 @@ var JobAbortedError = class extends NodaroError {
   }
   jobId;
 };
+var StudioPreviewUnavailable = class extends NodaroError {
+  constructor(message = "This deployment does not preview operation batches; nothing was sent") {
+    super(message, "studio_preview_unavailable", 0);
+    this.name = "StudioPreviewUnavailable";
+  }
+};
+var StudioPreviewAppliedError = class extends NodaroError {
+  constructor(applied, message = applied ? "Asked for a preview and this deployment APPLIED the batch; the change is written \u2014 see `applied`" : "Asked for a preview and this deployment answered with neither one nor a body to read; the batch may have been applied \u2014 re-read the production before deciding anything") {
+    super(message, "studio_preview_applied", 0);
+    this.applied = applied;
+    this.name = "StudioPreviewAppliedError";
+  }
+  applied;
+};
 var JobHeldError = class extends NodaroError {
   constructor(message, jobId) {
     super(message, "job_held", 0);
@@ -2037,6 +2051,47 @@ var LlmResource = class {
   }
 };
 
+// src/sse.ts
+async function* readSseStream(res, opts = {}) {
+  if (!res.ok) {
+    let errBody = {};
+    try {
+      errBody = await res.json();
+    } catch {
+    }
+    throwFromResponse(res.status, errBody);
+  }
+  if (!res.body) {
+    throw new NodaroError(`${opts.label ?? "event stream"} has no response body`, "empty_stream", res.status);
+  }
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let sep;
+      while ((sep = buffer.indexOf("\n\n")) >= 0) {
+        const frame = buffer.slice(0, sep);
+        buffer = buffer.slice(sep + 2);
+        for (const line of frame.split("\n")) {
+          if (!line.startsWith("data:")) continue;
+          try {
+            yield JSON.parse(line.slice(5).trim());
+          } catch {
+          }
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+    await res.body.cancel().catch(() => {
+    });
+  }
+}
+
 // src/resources/media.ts
 var MediaResource = class {
   constructor(client) {
@@ -2073,43 +2128,7 @@ var MediaResource = class {
       headers: token ? { Authorization: `Bearer ${token}` } : {},
       signal: opts.signal
     });
-    if (!res.ok) {
-      let errBody = {};
-      try {
-        errBody = await res.json();
-      } catch {
-      }
-      throwFromResponse(res.status, errBody);
-    }
-    if (!res.body) {
-      throw new NodaroError("progress stream has no response body", "empty_stream", res.status);
-    }
-    const reader = res.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    try {
-      for (; ; ) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        let sep;
-        while ((sep = buffer.indexOf("\n\n")) >= 0) {
-          const frame = buffer.slice(0, sep);
-          buffer = buffer.slice(sep + 2);
-          for (const line of frame.split("\n")) {
-            if (!line.startsWith("data:")) continue;
-            try {
-              yield JSON.parse(line.slice(5).trim());
-            } catch {
-            }
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-      await res.body.cancel().catch(() => {
-      });
-    }
+    yield* readSseStream(res, { label: "progress stream" });
   }
   /**
    * Copy an external media URL into your Nodaro storage (`POST /v1/save-to-storage`)
@@ -2154,6 +2173,31 @@ var MediaResource = class {
   imageOverlay(input) {
     return this.client.request("POST", "/v1/image-overlay", { body: input });
   }
+  /**
+   * Ask a vision model WHERE one overlay layer should sit on a base image
+   * (`POST /v1/image-overlay/suggest-placement`) — it reads the picture and
+   * keeps the element off the faces, the subject and the busiest texture.
+   * The answer comes back in {@link MediaResource.imageOverlay}'s own percent
+   * units — `anchor`, `x`/`y` offsets, `width` — so it drops straight onto a
+   * layer (`const { reason, ...box } = placement`), plus a one-sentence
+   * `reason` you can show a user. Nothing is composited here: apply the
+   * placement yourself.
+   *
+   * `layerAspect` is the element's width / height (1 = square, the default) so
+   * the proposed box stays in proportion; `intent` says what the element is
+   * ("a logo", "a price badge"); `safeArea` is the always-visible region as
+   * fractions of the canvas (a platform preset's safe area), which the
+   * placement is kept inside. Unlike the other media calls this one answers
+   * synchronously — there is nothing to poll; `jobId` is the billing record
+   * (one image-to-text call).
+   */
+  suggestOverlayPlacement(input) {
+    return this.client.request(
+      "POST",
+      "/v1/image-overlay/suggest-placement",
+      { body: input }
+    );
+  }
   /**
    * Trim a video to a range (`POST /v1/trim-video`). Give the range in whichever
    * unit fits: `startTime`/`endTime` seconds, `trim*Frames`, `trim*Seconds`, or
@@ -2647,19 +2691,27 @@ var StudioProductionsResource = class {
     );
     return res.data;
   }
-  /**
-   * Apply a batch of operations. Atomic: one bad operation refuses the whole
-   * batch with a `StudioOpError` naming its index, and nothing is written. On
-   * success adopt `production` wholesale and carry `version` forward as the
-   * next `baseVersion`.
-   */
   async ops(productionId, input) {
-    const res = await this.client.request(
+    if (input.dryRun !== true) {
+      const res2 = await this.client.request(
+        "POST",
+        this.path(productionId, "/ops"),
+        { body: input }
+      );
+      return res2.data;
+    }
+    const ping = await this.client.request(
       "POST",
       this.path(productionId, "/ops"),
-      { body: input }
+      { body: { ops: [], dryRun: true } }
     );
-    return res.data;
+    if (ping?.data?.dryRun !== true) throw new StudioPreviewUnavailable();
+    const res = await this.client.request("POST", this.path(productionId, "/ops"), { body: input });
+    const data = res?.data;
+    if (data?.dryRun !== true) {
+      throw new StudioPreviewAppliedError(data);
+    }
+    return data;
   }
   /**
    * Land every generation that has finished since you last looked, and report
@@ -2867,6 +2919,103 @@ var StudioResource = class {
   }
 };
 
+// src/resources/copilot.ts
+var COPILOT_FRAME_TYPES = /* @__PURE__ */ new Set([
+  "metadata",
+  "token",
+  "tool_call",
+  "workflow_updated",
+  "workflow_created",
+  "run_proposed",
+  "memory_saved",
+  "usage",
+  "done",
+  "error"
+]);
+function isCopilotFrame(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const type = value.type;
+  return typeof type === "string" && COPILOT_FRAME_TYPES.has(type);
+}
+var CopilotResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Open a conversation (`POST /v1/copilot/threads`) — on `workflowId`, or on
+   * a workflow the server creates from `prompt`. Re-opening a workflow that
+   * already has an active thread answers THAT thread rather than a second one.
+   */
+  create(input) {
+    return this.client.request("POST", "/v1/copilot/threads", { body: input });
+  }
+  /**
+   * The active thread for a workflow (`GET /v1/copilot/threads?workflowId=…`),
+   * or `null` when the user has none open on it.
+   */
+  list(params) {
+    return this.client.request("GET", "/v1/copilot/threads", { query: { workflowId: params.workflowId } });
+  }
+  /**
+   * One thread with its messages (`GET /v1/copilot/threads/:id`). `after` reads
+   * only what followed that sequence number (the panel's catch-up); `limit`
+   * caps the page at the server's own ceiling.
+   */
+  get(id, opts = {}) {
+    return this.client.request("GET", `/v1/copilot/threads/${encodeURIComponent(id)}`, {
+      query: { ...opts.after !== void 0 ? { after: opts.after } : {}, ...opts.limit !== void 0 ? { limit: opts.limit } : {} }
+    });
+  }
+  /**
+   * Close a conversation (`DELETE /v1/copilot/threads/:id`). Archival, not
+   * deletion — the messages stay readable. Refused while a turn is running.
+   */
+  archive(id) {
+    return this.client.request("DELETE", `/v1/copilot/threads/${encodeURIComponent(id)}`);
+  }
+  /**
+   * Stop the running turn (`POST /v1/copilot/threads/:id/cancel`). Answers the
+   * turn it asked to stop; the turn's own stream ends with a `done` frame.
+   */
+  cancel(id) {
+    return this.client.request("POST", `/v1/copilot/threads/${encodeURIComponent(id)}/cancel`);
+  }
+  /**
+   * Send one message and iterate the turn's frames
+   * (`POST /v1/copilot/threads/:id/messages`, server-sent events).
+   *
+   * Deliberately NOT routed through `client.request`: that path arms an abort
+   * timer around the whole exchange, and a turn legitimately runs for minutes —
+   * inheriting `timeoutMs` would cut the assistant off mid-answer. The caller
+   * owns the lifetime instead: pass `signal` to end the stream, or stop
+   * iterating (the reader cancels the body, which ends the request).
+   *
+   * A frame kind this package does not model is skipped rather than thrown, so
+   * a newer server cannot break an older caller.
+   */
+  async *stream(threadId, opts) {
+    const url = `${this.client.baseUrl}/v1/copilot/threads/${encodeURIComponent(threadId)}/messages`;
+    const token = await this.client.auth.getToken();
+    const res = await this.client.fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...token ? { Authorization: `Bearer ${token}` } : {}
+      },
+      body: JSON.stringify({
+        message: opts.message,
+        ...opts.baseVersion !== void 0 ? { baseVersion: opts.baseVersion } : {},
+        ...opts.tier ? { tier: opts.tier } : {}
+      }),
+      signal: opts.signal
+    });
+    for await (const value of readSseStream(res, { label: "copilot stream" })) {
+      if (isCopilotFrame(value)) yield value;
+    }
+  }
+};
+
 // src/resources/community.ts
 var CommunityResource = class {
   constructor(client) {
@@ -3248,7 +3397,7 @@ var WorkspacesResource = class {
     return this.client.requestText("GET", `/v1/workspaces/${encodeURIComponent(id)}/usage`, { query: { ...opts, format: "csv" } });
   }
 };
-var SDK_VERSION = "2.5.0" ;
+var SDK_VERSION = "2.7.0" ;
 var CLIENT_HEADER = "X-Nodaro-Client";
 var isBrowser = () => typeof window !== "undefined" && typeof window.document !== "undefined";
 var NodaroClient = class _NodaroClient {
@@ -3300,6 +3449,7 @@ var NodaroClient = class _NodaroClient {
   shots;
   recast;
   studio;
+  copilot;
   community;
   templates;
   tutorials;
@@ -3346,6 +3496,7 @@ var NodaroClient = class _NodaroClient {
     this.shots = new ShotsResource(this);
     this.recast = new RecastResource(this);
     this.studio = new StudioResource(this);
+    this.copilot = new CopilotResource(this);
     this.community = new CommunityResource(this);
     this.templates = new TemplatesResource(this);
     this.tutorials = new TutorialsResource(this);
@@ -3598,6 +3749,7 @@ exports.CallbackAuth = CallbackAuth;
 exports.CatalogsResource = CatalogsResource;
 exports.CharactersResource = CharactersResource;
 exports.CommunityResource = CommunityResource;
+exports.CopilotResource = CopilotResource;
 exports.CreaturesResource = CreaturesResource;
 exports.CreditsResource = CreditsResource;
 exports.DeveloperAppsResource = DeveloperAppsResource;
@@ -3635,6 +3787,8 @@ exports.ShotsResource = ShotsResource;
 exports.StaticTokenAuth = StaticTokenAuth;
 exports.StorageExceededError = StorageExceededError;
 exports.StudioOpError = StudioOpError;
+exports.StudioPreviewAppliedError = StudioPreviewAppliedError;
+exports.StudioPreviewUnavailable = StudioPreviewUnavailable;
 exports.StudioProductionsResource = StudioProductionsResource;
 exports.StudioResource = StudioResource;
 exports.TemplatesResource = TemplatesResource;