@sogni-ai/sogni-client 5.82.0 → 5.84.0

package/AGENTS.md

@@ -135,6 +135,8 @@ Generated artifacts:
   - `workflows.{start, list, get, events, streamEvents, resume, reseed, cancel}`
   - `workflows.templates.{list, get, create, update, delete, fork}`
 - `replay: ReplayApi` - RunRecord write/list/get via `/v1/replay/records`
+- `changelog: ChangelogApi` - Public platform changelog via `/v1/changelog`, no sign-in needed
+  - `changelog.{list, get, products}`
 - `apiClient: ApiClient` - Internal REST + WebSocket communication
 
 ### Core Entity Hierarchy
@@ -244,6 +246,11 @@ The SDK supports two families of video models with **fundamentally different FPS
 - Minimal call: `referenceVideo` + `upscaleResolution` + `numberOfMedia: 1` + empty prompt. `frames`, `fps`, `width` and `height` are optional; the server probes the upload and adopts the verified source values, and rejects only values a caller sent that conflict with the source. The SDK sets no frame-count or duration limit: the server enforces the maximum clip length and returns a clear error for a source that is too long. Estimates take the output size, the source's `frames`/`fps`, and `sourceWidth`/`sourceHeight`.
 - `isVideoUpscaleModel()` detects it; `getVideoWorkflowType()` returns `'upscale'`. Hosted chat/workflows expose it as the `upscale_video` tool.
 
+**RelayVSR** (`RELAYVSR_X2_VIDEO_UPSCALE_MODEL_ID`, `RELAYVSR_X4_VIDEO_UPSCALE_MODEL_ID`) takes the same request and adds `upscaleResolution: 2160`:
+- Opt-in by model id; FlashVSR stays the `upscale_video` default. `model: 'relayvsr'` on the hosted tool selects it.
+- X2 takes sources up to 1080x1920 and delivers at most twice their size; X4 takes sources up to 768x1344 and delivers at most four times. Output long edge at most 3840px. The server checks these against the probed source.
+- The SDK refuses `detailPreference`, `processingSpeed` and `seed`, fixes seed to 0, and sends neither option on the wire. `isRelayVsrModel()` detects both; `isVideoUpscaleModel()` covers them.
+
 ### Key Files
 - `src/Projects/utils/index.ts` - `isWanModel()`, `isLtx2Model()`, `calculateVideoFrames()`
 - `src/Projects/createJobRequestMessage.ts` - Uses `calculateVideoFrames()` for duration→frames conversion
@@ -398,7 +405,7 @@ const urls = await project.waitForCompletion();
 | Text-to-Video | `*_t2v*` | None |
 | Image-to-Video | `*_i2v*` | `referenceImage` (and/or `referenceImageEnd`) |
 | First/Last-Frame Video | `*_flf2v*` (MiniMax H3) | `referenceImage` + `referenceImageEnd` |
-| MiniMax H3 intermediate keyframes | every H3 id except `*_t2v*`: `*_i2v*`, `*_flf2v*`, `*_ia2v*`, `*_flfa2v*`, `*_a2v*`, `*_r2v*` (`isMinimaxH3KeyframeModel`, 23 ids) | optional `keyframes: [{ image, frameIndex }]`, up to 8, alongside the workflow's own uploads; `frameIndex` is a 0-based 24 fps frame from 1 to `frames - 2` (pass `frames`: `duration` snaps to the 124 + n*17 grid); images upload to `keyframeImage1..N` in order (r2v references keep their `contextImage` slots); the prompt names each keyframe `<Picture N>` after the workflow's own pictures, lists it in the alignment line (r2v: keyframe entry, `keyframe completion` task, retention entry), describes what it shows, and cuts to a new shot where framing or light changes (see `llms.txt`) |
+| MiniMax H3 intermediate keyframes | every H3 id except `*_t2v*`: `*_i2v*`, `*_flf2v*`, `*_ia2v*`, `*_flfa2v*`, `*_a2v*`, `*_r2v*` (`isMinimaxH3KeyframeModel`, 24 ids) | optional `keyframes: [{ image, frameIndex }]`, up to 8, alongside the workflow's own uploads; `frameIndex` is a 0-based 24 fps frame from 1 to `frames - 2` (pass `frames`: `duration` snaps to the 124 + n*17 grid); images upload to `keyframeImage1..N` in order (r2v references keep their `contextImage` slots); the prompt names each keyframe `<Picture N>` after the workflow's own pictures, lists it in the alignment line (r2v: keyframe entry, `keyframe completion` task, retention entry), describes what it shows, and cuts to a new shot where framing or light changes (see `llms.txt`) |
 | Reference-to-Video | `*_r2v*` (Happy Horse) | 1-9 images via `referenceImage`/`referenceImageUrls` |
 | Video-to-Video | `*_v2v*` (LTX-2.3) | `referenceVideo` + `controlNet` |
 | Sound-to-Video | `*_s2v*` (WAN only) | `referenceImage` + `referenceAudio` |
@@ -407,7 +414,7 @@ const urls = await project.waitForCompletion();
 | Audio-to-Video | `*_a2v*` (LTX-2.3, MiniMax H3 FastH3) | `referenceAudio` |
 | Animate-Move | `*_animate-move*` | `referenceImage` + `referenceVideo` |
 | Animate-Replace | `*_animate-replace*` | `referenceImage` + `referenceVideo` |
-| Video Upscale | `flashvsr_*` | exactly one `referenceVideo` (promptless) |
+| Video Upscale | `flashvsr_*`, `relayvsr_*` | exactly one `referenceVideo` (promptless) |
 
 ## LLM Chat — Thinking Models & Tool Calling
 

package/CHANGELOG.md

@@ -1,3 +1,25 @@
+# [5.84.0](https://github.com/Sogni-AI/sogni-client/compare/v5.83.0...v5.84.0) (2026-11-15)
+
+
+### Bug Fixes
+
+* **chat:** keep FlashVSR's 2160 refusal in hosted tool validation ([e65764b](https://github.com/Sogni-AI/sogni-client/commit/e65764b71aee32607339b357fe37d509d1db4007))
+* **chat:** validate an unknown upscale_video model as 5.83.0 did ([a00f0e7](https://github.com/Sogni-AI/sogni-client/commit/a00f0e70f3a35989fbdce69d0f2e090cbf46a69c))
+
+
+### Features
+
+* **minimax-h3:** add the MiniMax H3 Prism reference-to-video model id ([cda5219](https://github.com/Sogni-AI/sogni-client/commit/cda521925bde3eb95a6548b20b03ceea35f1d422))
+* **video:** add RelayVSR video upscaling models ([a613f03](https://github.com/Sogni-AI/sogni-client/commit/a613f03ae0b76198e6e6c4c8fa19f3411f3d0f9a))
+* **video:** refuse a RelayVSR output past 3840 on the long edge ([77261b9](https://github.com/Sogni-AI/sogni-client/commit/77261b9c0e0734ec020c58a6a79a073ebaf3a1d7))
+
+# [5.83.0](https://github.com/Sogni-AI/sogni-client/compare/v5.82.0...v5.83.0) (2026-11-14)
+
+
+### Features
+
+* **changelog:** add sogni.changelog to read the public Sogni changelog ([68a264a](https://github.com/Sogni-AI/sogni-client/commit/68a264a2255e13af7b554b13eddea49b9bb223d3))
+
 # [5.82.0](https://github.com/Sogni-AI/sogni-client/compare/v5.81.0...v5.82.0) (2026-11-13)
 
 

package/README.md

@@ -228,7 +228,8 @@ const sogni = await SogniClient.createInstance({
 ```
 
 Socket-backed project generation and chat completions are unavailable in REST-only mode. Hosted
-chat, durable workflows, replay records, announcements, and account REST APIs remain available.
+chat, durable workflows, replay records, announcements, the platform changelog, and account REST
+APIs remain available.
 
 ### Connection metadata and event subscriptions
 
@@ -1365,11 +1366,15 @@ Example model IDs:
 - `minimax-h3-fastvideo-int8_t2v_turbo_2stage` / `minimax-h3-fastvideo-int8_i2v_turbo_2stage` / `minimax-h3-fastvideo-int8_flf2v_turbo_2stage` / `minimax-h3-fastvideo-int8_ia2v_turbo_2stage` / `minimax-h3-fastvideo-int8_flfa2v_turbo_2stage` / `minimax-h3-fastvideo-int8_a2v_turbo_2stage` (MiniMax H3 FastH3 Two-Stage: the FastH3 Turbo request, delivered at twice the canvas with the same length and audio. 720p: the chosen aspect at a 384 px short edge, 672×384 → 1344×768. 1080p: a 544 px short edge, 960×544 → 1920×1088. 2K: the 768p canvas, 1344×768 → 2688×1536)
 - `minimax-h3-ref2va-fp8_r2v_2stage` / `minimax-h3-ref2va-fp8_r2v_balanced_2stage` (MiniMax H3 Two-Stage Reference-to-Video: the Standard 20-step or Balanced 8-step Ref2VA request, delivered at twice the canvas with the same length, audio and references; the same 384/544/768 px canvas choices as the FastH3 Two-Stage ids)
 - `minimax-h3-fastvideo-omni-int8_r2v_turbo` / `minimax-h3-fastvideo-omni-int8_r2v_turbo_2stage` (MiniMax H3 FastH3 Reference: FastVideo's FastH3 Omni, the FastH3 tier's Reference-to-Video on its own distilled checkpoint, with the same references, catalog LoRAs and Personal LoRAs as the other r2v ids; omit `steps`, since it is not a four-step Turbo id despite the suffix. The `_2stage` id takes the same request and delivers twice the canvas)
+- `minimax-h3-prism-int8_r2v` (MiniMax H3 Prism: an optional Reference-to-Video model for mature themes with its recipe fixed at 8 Euler steps; the same references, keyframes and catalog LoRAs as the other r2v ids at the 768p class only, with no two-stage id; requires `disableNSFWFilter: true` and is subject to server authorization)
 - `flashvsr_v1.1_tiny_long_bf16` (FlashVSR v1.1 promptless 1080p/1440p video upscaling of one finished video)
+- `relayvsr_x2_lightx2v_int8_convrot`, `relayvsr_x4_int8_convrot` (RelayVSR 2x and 4x promptless video upscaling up to 2160p of one finished video)
 
 The repository does not bundle sample prompts or input media for the 10Eros model. Creators
 who choose to use it must provide their own prompt and image to
-`examples/workflow_image_to_video.mjs`. Optional test prompts and images are available from the
+`examples/workflow_image_to_video.mjs`. The same applies to MiniMax H3 Prism in
+`examples/workflow_minimax_h3_video.mjs` (`--model minimax-h3-r2v-prism`), which also requires
+`--disable-safe-content-filter`. Optional test prompts and images are available from the
 [model author's sample gallery](https://civitai.red/models/2447875/ltx23-10eros).
 
 ### Video Parameters
@@ -1384,13 +1389,13 @@ When creating video projects, you can specify:
 - `steps` - Increase inference steps to increase quality
 - `seed` - Random seed for reproducibility
 - `referenceImage` - Reference image for workflows that require it (i2v, s2v, animate-move, animate-replace)
-- `referenceVideo` - Reference video for animate and v2v workflows, and the source video for FlashVSR upscaling
-- `upscaleResolution` - FlashVSR only: output short edge, `1080` or `1440`
+- `referenceVideo` - Reference video for animate and v2v workflows, and the source video for FlashVSR and RelayVSR upscaling
+- `upscaleResolution` - Video upscaling only: output short edge, `1080` or `1440`, or `2160` on RelayVSR
 - `referenceVideoDurations` - Optional MiniMax H3 r2v duration hints in `[referenceVideo, ...referenceVideos]` order for early client-side validation; Socket probes the uploaded files and uses measured durations for pricing and admission
 - `referenceVideoCompression` - Legacy MiniMax H3 reference-video preference (`'none'` or `'vpack'`), retained for compatibility. Current services select compression automatically; this field no longer selects compression. Leave it unset for new requests.
 - `referenceAudio` - Reference audio for sound-to-video workflows (s2v, ia2v, flfa2v, a2v)
 - `referenceImageEnd` - Last frame for i2v, flf2v and the MiniMax H3 FastH3 flfa2v audio-guide workflow
-- `keyframes` - Every MiniMax H3 workflow except t2v (23 ids, `isMinimaxH3KeyframeModel()`: i2v and flf2v on every tier, Sound to Video ia2v/flfa2v/a2v, and r2v): up to `MINIMAX_H3_MAX_KEYFRAMES` (8) `{ image, frameIndex }` stills pinned between the first and last frame. `frameIndex` is the 0-based frame at 24 fps (`Math.round(seconds * 24)`), an integer from 1 to `frames - 2`, each frame used once. Pass `frames` from the H3 grid (124, 141, 158, … 362) so the count is exact: `duration` snaps to the grid (`duration: 6` renders 141 frames, not 144). Frame 0 and the last frame are never keyframes: i2v, flf2v and flfa2v set them with `referenceImage` / `referenceImageEnd`, ia2v sets frame 0 with `referenceImage`, and a2v and r2v cannot pin them. The prompt names each keyframe `<Picture N>` (MiniMax's keyframe format), numbered in time order after the workflow's own pictures: after the first frame on i2v and ia2v (after the last frame on a last-frame-only i2v job), after the first and last frames on flf2v and flfa2v, from `<Picture 1>` on a2v, and after the reference images on r2v; keyframes still never count as references. i2v, flf2v and Sound to Video prompts open with one alignment line listing every picture at its mark (`How the reference pictures align with the target video — Picture 1 (from Shot 1) aligns with the 0.00-second mark of the target video; Picture 2 (from Shot 2) aligns with the 2.88-second mark of the target video.`), the shot where a keyframe lands says "the shot's keyframe corresponds to `<Picture N>`", and r2v adds a `<Picture N> is the keyframe of [Shot M], showing ...` entry, `keyframe completion` in the summary tasks and a `<Picture N> ([Shot M] keyframe): fully_preserved - ...` retention entry. H3's text encoder never sees the keyframe images, so the prompt must still describe what each keyframe shows at its time. On Sound to Video the audio drives the performance and keyframes pin how it looks at their times. When a keyframe changes the framing, camera angle, location or light, start a new shot (a hard cut) in the prompt at its time: two differently framed or lit stills inside one continuous shot cross-fade, and a shot described differently from its still can flash the still for a single frame. Images upload to their own `keyframeImage1..N` slots in array order, so r2v sends its references (`referenceImage`, `contextImages`) and keyframes together. If no worker serving the model can pin keyframes yet, the job is refused with error code `4100` MiniMax H3 keyframe pricing: the first two keyframes are included; each extra keyframe adds output time at the job's per-second rate, 0.75 s on FastH3 and 0.3 s on every other tier, FastH3 Reference included (an 8 s FastH3 clip with 8 keyframes: 32 + 18 = 50 Spark). Pass `keyframeCount` (or the job's `keyframes`) to `estimateVideoCost` to quote it.
+- `keyframes` - Every MiniMax H3 workflow except t2v (24 ids, `isMinimaxH3KeyframeModel()`: i2v and flf2v on every tier, Sound to Video ia2v/flfa2v/a2v, and r2v): up to `MINIMAX_H3_MAX_KEYFRAMES` (8) `{ image, frameIndex }` stills pinned between the first and last frame. `frameIndex` is the 0-based frame at 24 fps (`Math.round(seconds * 24)`), an integer from 1 to `frames - 2`, each frame used once. Pass `frames` from the H3 grid (124, 141, 158, … 362) so the count is exact: `duration` snaps to the grid (`duration: 6` renders 141 frames, not 144). Frame 0 and the last frame are never keyframes: i2v, flf2v and flfa2v set them with `referenceImage` / `referenceImageEnd`, ia2v sets frame 0 with `referenceImage`, and a2v and r2v cannot pin them. The prompt names each keyframe `<Picture N>` (MiniMax's keyframe format), numbered in time order after the workflow's own pictures: after the first frame on i2v and ia2v (after the last frame on a last-frame-only i2v job), after the first and last frames on flf2v and flfa2v, from `<Picture 1>` on a2v, and after the reference images on r2v; keyframes still never count as references. i2v, flf2v and Sound to Video prompts open with one alignment line listing every picture at its mark (`How the reference pictures align with the target video — Picture 1 (from Shot 1) aligns with the 0.00-second mark of the target video; Picture 2 (from Shot 2) aligns with the 2.88-second mark of the target video.`), the shot where a keyframe lands says "the shot's keyframe corresponds to `<Picture N>`", and r2v adds a `<Picture N> is the keyframe of [Shot M], showing ...` entry, `keyframe completion` in the summary tasks and a `<Picture N> ([Shot M] keyframe): fully_preserved - ...` retention entry. H3's text encoder never sees the keyframe images, so the prompt must still describe what each keyframe shows at its time. On Sound to Video the audio drives the performance and keyframes pin how it looks at their times. When a keyframe changes the framing, camera angle, location or light, start a new shot (a hard cut) in the prompt at its time: two differently framed or lit stills inside one continuous shot cross-fade, and a shot described differently from its still can flash the still for a single frame. Images upload to their own `keyframeImage1..N` slots in array order, so r2v sends its references (`referenceImage`, `contextImages`) and keyframes together. If no worker serving the model can pin keyframes yet, the job is refused with error code `4100` MiniMax H3 keyframe pricing: the first two keyframes are included; each extra keyframe adds output time at the job's per-second rate, 0.75 s on FastH3 and 0.3 s on every other tier, FastH3 Reference included (an 8 s FastH3 clip with 8 keyframes: 32 + 18 = 50 Spark). Pass `keyframeCount` (or the job's `keyframes`) to `estimateVideoCost` to quote it.
 - `referenceImageUrls` - Loose image context URLs for Seedance, Happy Horse, and Wan 3; Wan 3 accepts up to 10
 - `referenceVideoUrls` - Loose video context URLs for Seedance and Wan 3; Wan 3 accepts up to 5
 - `referenceAudioUrls` - Loose audio context URLs for Seedance and Wan 3; Wan 3 accepts up to 5
@@ -1619,6 +1624,30 @@ const [upscaledUrl] = await project.waitForCompletion(); // MP4 with the origina
 
 To show a price first, call `estimateVideoCost()` with the output `width`/`height` (the source scaled so its short edge equals the target, both edges rounded to even pixels), the source's `frames` and `fps`, `steps: 1`, and `sourceWidth`/`sourceHeight`; the job itself is charged from the verified source. In hosted chat and durable workflows, the same operation is the promptless `upscale_video` tool.
 
+### Video Upscale Example (RelayVSR)
+
+`RELAYVSR_X2_VIDEO_UPSCALE_MODEL_ID` (`relayvsr_x2_lightx2v_int8_convrot`) and `RELAYVSR_X4_VIDEO_UPSCALE_MODEL_ID` (`relayvsr_x4_int8_convrot`) upscale one finished video to 1080p, 1440p, or 2160p on its short edge. The request is the same as FlashVSR's: one `referenceVideo`, `upscaleResolution`, `numberOfMedia: 1`, and an empty prompt. The output keeps every source frame, the exact frame rate, the full aspect ratio, and the original audio.
+
+X2 takes a source up to 1080x1920 pixels (either orientation) and delivers at most twice its size; X4 takes a source up to 768x1344 and delivers at most four times its size. The target must be larger than the source's short edge, and the output's long edge can be at most 3840px, so 2160p needs a source short edge of exactly 1080px on X2 or 540px to 768px on X4. Sources must be 1-60 fps, SDR, and 100 MB or less, and the server enforces the maximum clip length. Variable-frame-rate, rotated and non-square-pixel clips need no re-export for RelayVSR: the server conforms them, and every limit applies to the clip as it plays.
+
+```javascript
+import fs from 'node:fs';
+import { RELAYVSR_X2_VIDEO_UPSCALE_MODEL_ID } from '@sogni-ai/sogni-client';
+
+const project = await sogni.projects.create({
+  type: 'video',
+  network: 'fast',
+  modelId: RELAYVSR_X2_VIDEO_UPSCALE_MODEL_ID,
+  positivePrompt: '',
+  numberOfMedia: 1,
+  referenceVideo: fs.readFileSync('./clip-1080p.mp4'),
+  upscaleResolution: 2160 // 1080 | 1440 | 2160: the output's short edge
+});
+const [upscaledUrl] = await project.waitForCompletion(); // MP4 with the original audio
+```
+
+`isRelayVsrModel(modelId)` detects both models, and `isVideoUpscaleModel(modelId)` covers them too. The SDK refuses `detailPreference`, `processingSpeed`, and `seed` for RelayVSR. Quote it the same way as FlashVSR, with the output `width`/`height` and `sourceWidth`/`sourceHeight`; the price follows the source's size and length, not the target. In hosted chat and durable workflows, set `model: 'relayvsr'` on `upscale_video`; the server picks X2 when the target is at most twice the source's short edge and X4 otherwise. FlashVSR stays the tool's default.
+
 ## LLM Text Generation & Tool Calling
 
 The Sogni SDK supports LLM text generation through the Sogni Supernet, providing an OpenAI-compatible chat completions API with streaming, multi-turn conversations, and tool calling (function calling).
@@ -1691,7 +1720,7 @@ Combine LLM intelligence with Sogni's media generation capabilities. The SDK exp
 
 - **Generation** — `generate_image`, `edit_image`, `generate_video`, `sound_to_video`, `video_to_video`, `generate_music`, `generate_speech`
 - **Image adapters** — `restore_photo`, `apply_style`, `refine_result`, `change_angle`, `animate_photo` (image-to-video with multi-source fan-out)
-- **Upscaling** — `upscale_image` (promptless RTX VSR), `upscale_video` (promptless FlashVSR 1080p/1440p video upscale that keeps every frame, the frame rate, and the original audio)
+- **Upscaling** — `upscale_image` (promptless RTX VSR), `upscale_video` (promptless FlashVSR 1080p/1440p video upscale, or RelayVSR up to 2160p by `model: 'relayvsr'`, that keeps every frame, the frame rate, and the original audio)
 - **Video composition / post-production** — `stitch_video`, `orbit_video`, `dance_montage`, `extend_video`, `replace_video_segment`, `overlay_video`, `add_subtitles`
 - **Synchronous composition and planning** — `enhance_prompt`, `compose_script`, `compose_lyrics`, `compose_instrumental`, `compose_workflow`, `compose_workflow_template`
 
@@ -1911,6 +1940,30 @@ async function startWithRetry(params, attempts = 5) {
 
 See `examples/workflow_creative_agent_workflows.mjs` for start/list/get/events/stream/cancel coverage. The underlying REST endpoints remain documented in the [LLM API durable workflows reference](https://github.com/Sogni-AI/sogni-api/blob/main/docs/llm-api.md#durable-creative-agent-workflows).
 
+## Platform changelog
+
+`sogni.changelog` reads Sogni's public changelog: what changed for artists, developers and worker operators. These reads need no sign-in, so a REST-only client without an API key can make them:
+
+```javascript
+const sogni = await SogniClient.createInstance({ disableSocket: true });
+
+const filters = { audience: 'developer', since: '2026-11-01' };
+const { entries, nextCursor } = await sogni.changelog.list(filters);
+for (const entry of entries) console.log(entry.publishedAt, entry.title, entry.url);
+
+// The next page takes the same filters plus the cursor; nextCursor is null on the last page.
+const older = nextCursor ? await sogni.changelog.list({ ...filters, cursor: nextCursor }) : null;
+
+const entry = await sogni.changelog.get(entries[0].id);
+const products = await sogni.changelog.products(); // [{ id, label, audiences }]
+```
+
+- `list(options)` returns `{ entries, nextCursor }`, newest first. `audience` (`artist`, `developer`, `worker`), `product` (ids from `products()`) and `type` (`new`, `improved`, `fixed`, `release`, `deprecated`, `removed`, `notice`) take one value or an array. `since` (inclusive) and `until` (exclusive) take an ISO 8601 date or a date-time with a zone. `actionRequired: true` lists only entries you need to act on. `limit` defaults to 50; the API returns at most 100.
+- `get(id)` returns one entry. An id with no published entry throws `ApiError` with `status` 404 and `payload.errorCode` 204.
+- For a deprecation or removal, `effectiveAt` is the day the old behavior stops working.
+
+Responses can be up to five minutes old, so poll no more often than that. The [Changelog API reference](https://docs.sogni.ai/api-reference/changelog/) has the full contract, including the JSON Feed and Atom feeds.
+
 ## Code Examples
 
 ### Hosted World Builds (server-side)

package/dist/Changelog/index.d.ts

@@ -0,0 +1,28 @@
+import ApiGroup from '../ApiGroup.js';
+import type { ChangelogEntry, ChangelogProduct, ListChangelogOptions, ListChangelogResult } from './types.js';
+/**
+ * The public Sogni changelog (`/v1/changelog`): what changed on Sogni for
+ * artists, developers and worker operators.
+ *
+ * These reads need no sign-in, so they work on a client that is not
+ * authenticated. Responses may be up to five minutes old; poll no more often
+ * than that. A refused request throws `ApiError` with the API's status and
+ * message.
+ *
+ * Full contract: https://docs.sogni.ai/api-reference/changelog/
+ */
+declare class ChangelogApi extends ApiGroup {
+    /**
+     * One page of published entries, newest first. Pass the returned
+     * `nextCursor` as `cursor`, with the same filters, for the next page.
+     */
+    list(options?: ListChangelogOptions): Promise<ListChangelogResult>;
+    /**
+     * One published entry by its id. An id with no published entry throws
+     * `ApiError` with status `404` and `payload.errorCode` `204`.
+     */
+    get(id: string): Promise<ChangelogEntry>;
+    /** The products entries can name, in display order. */
+    products(): Promise<ChangelogProduct[]>;
+}
+export default ChangelogApi;

package/dist/Changelog/index.js

@@ -0,0 +1,81 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ApiGroup_js_1 = __importDefault(require("../ApiGroup.js"));
+const index_js_1 = require("../ApiClient/index.js");
+function joined(value) {
+    return Array.isArray(value) ? value.join(',') : value;
+}
+/**
+ * The public Sogni changelog (`/v1/changelog`): what changed on Sogni for
+ * artists, developers and worker operators.
+ *
+ * These reads need no sign-in, so they work on a client that is not
+ * authenticated. Responses may be up to five minutes old; poll no more often
+ * than that. A refused request throws `ApiError` with the API's status and
+ * message.
+ *
+ * Full contract: https://docs.sogni.ai/api-reference/changelog/
+ */
+class ChangelogApi extends ApiGroup_js_1.default {
+    /**
+     * One page of published entries, newest first. Pass the returned
+     * `nextCursor` as `cursor`, with the same filters, for the next page.
+     */
+    list() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            const res = yield this.client.rest.get('/v1/changelog', {
+                audience: joined(options.audience),
+                product: joined(options.product),
+                type: joined(options.type),
+                since: options.since,
+                until: options.until,
+                actionRequired: options.actionRequired ? 'true' : undefined,
+                limit: options.limit,
+                cursor: options.cursor
+            });
+            return res.data;
+        });
+    }
+    /**
+     * One published entry by its id. An id with no published entry throws
+     * `ApiError` with status `404` and `payload.errorCode` `204`.
+     */
+    get(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const res = yield this.client.rest.get(`/v1/changelog/${encodeURIComponent(id)}`);
+            const entry = (_a = res.data) === null || _a === void 0 ? void 0 : _a.entry;
+            if (!entry) {
+                // An empty id requests the list itself, and `products` or `feed.json` the
+                // product list or the feed; none of them is an entry.
+                throw new index_js_1.ApiError(404, {
+                    status: 'error',
+                    message: 'Changelog entry not found',
+                    errorCode: 204
+                });
+            }
+            return entry;
+        });
+    }
+    /** The products entries can name, in display order. */
+    products() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.client.rest.get('/v1/changelog/products');
+            return res.data.products;
+        });
+    }
+}
+exports.default = ChangelogApi;
+//# sourceMappingURL=index.js.map

package/dist/Changelog/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/Changelog/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAAA,iEAAsC;AACtC,oDAA8D;AAQ9D,SAAS,MAAM,CAAC,KAAoC;IAClD,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;AACxD,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,YAAa,SAAQ,qBAAQ;IACjC;;;OAGG;IACG,IAAI;6DAAC,UAAgC,EAAE;YAC3C,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAmC,eAAe,EAAE;gBACxF,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC;gBAClC,OAAO,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC;gBAChC,IAAI,EAAE,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC;gBAC1B,KAAK,EAAE,OAAO,CAAC,KAAK;gBACpB,KAAK,EAAE,OAAO,CAAC,KAAK;gBACpB,cAAc,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS;gBAC3D,KAAK,EAAE,OAAO,CAAC,KAAK;gBACpB,MAAM,EAAE,OAAO,CAAC,MAAM;aACvB,CAAC,CAAC;YACH,OAAO,GAAG,CAAC,IAAI,CAAC;QAClB,CAAC;KAAA;IAED;;;OAGG;IACG,GAAG,CAAC,EAAU;;;YAClB,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CACpC,iBAAiB,kBAAkB,CAAC,EAAE,CAAC,EAAE,CAC1C,CAAC;YACF,MAAM,KAAK,GAAG,MAAA,GAAG,CAAC,IAAI,0CAAE,KAAK,CAAC;YAC9B,IAAI,CAAC,KAAK,EAAE,CAAC;gBACX,0EAA0E;gBAC1E,sDAAsD;gBACtD,MAAM,IAAI,mBAAQ,CAAC,GAAG,EAAE;oBACtB,MAAM,EAAE,OAAO;oBACf,OAAO,EAAE,2BAA2B;oBACpC,SAAS,EAAE,GAAG;iBACf,CAAC,CAAC;YACL,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC;KAAA;IAED,uDAAuD;IACjD,QAAQ;;YACZ,MAAM,GAAG,GACP,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CACxB,wBAAwB,CACzB,CAAC;YACJ,OAAO,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC;QAC3B,CAAC;KAAA;CACF;AAED,kBAAe,YAAY,CAAC"}

package/dist/Changelog/types.d.ts

@@ -0,0 +1,83 @@
+/** Who a changelog entry is for. */
+export type ChangelogAudience = 'artist' | 'developer' | 'worker';
+/**
+ * The kind of change. Every entry has exactly one:
+ * - `new`: something you could not do before
+ * - `improved`: a change to something that already worked
+ * - `fixed`: a fix
+ * - `release`: a versioned release, such as a worker or SDK version
+ * - `deprecated`: still works, until `effectiveAt`
+ * - `removed`: no longer available
+ * - `notice`: anything else you should know
+ */
+export type ChangelogEntryType = 'new' | 'improved' | 'fixed' | 'release' | 'deprecated' | 'removed' | 'notice';
+/** A page related to a changelog entry. */
+export interface ChangelogLink {
+    label: string;
+    url: string;
+}
+/** One published changelog entry. Times are ISO 8601 UTC strings. */
+export interface ChangelogEntry {
+    /** Permanent identifier. It does not change once the entry is published. */
+    id: string;
+    /** The entry's page on sogni.ai. */
+    url: string;
+    title: string;
+    /** Short summary in plain text. */
+    summary: string;
+    /** The full text in Markdown. */
+    bodyMarkdown: string | null;
+    type: ChangelogEntryType;
+    audiences: ChangelogAudience[];
+    /** Product ids, as listed by `changelog.products()`. */
+    products: string[];
+    /** The product version the change shipped in. */
+    version: string | null;
+    links: ChangelogLink[];
+    /** `true` when you need to change something, such as for a model retirement. */
+    actionRequired: boolean;
+    /** When the change takes effect. For a deprecation or removal, the day the old behavior stops working. */
+    effectiveAt: string | null;
+    /** When the entry was published. Lists sort and filter on it. */
+    publishedAt: string;
+    /** When any public field of the entry last changed. */
+    updatedAt: string;
+}
+/** A product that changelog entries can name. */
+export interface ChangelogProduct {
+    /** The id to use with the `product` filter. */
+    id: string;
+    /** Display name. */
+    label: string;
+    audiences: ChangelogAudience[];
+}
+/**
+ * Filters and paging for `changelog.list()`. Every field is optional. An entry
+ * must match every filter given; a filter given several values matches entries
+ * that have any of them (at most 20 values per filter).
+ */
+export interface ListChangelogOptions {
+    audience?: ChangelogAudience | ChangelogAudience[];
+    /** Product ids from `changelog.products()`. */
+    product?: string | string[];
+    type?: ChangelogEntryType | ChangelogEntryType[];
+    /**
+     * Entries published at or after this time: an ISO 8601 date (`'2026-11-01'`,
+     * read as midnight UTC) or a date-time with a zone (`'2026-11-01T17:00:00Z'`).
+     */
+    since?: string;
+    /** Entries published before this time, in the same format as `since`. */
+    until?: string;
+    /** `true` lists only the entries you need to act on. */
+    actionRequired?: boolean;
+    /** Entries per page. The API defaults to 50 and returns at most 100. */
+    limit?: number;
+    /** The previous page's `nextCursor`. Send the same filters with it. */
+    cursor?: string;
+}
+/** One page of changelog entries, newest first. */
+export interface ListChangelogResult {
+    entries: ChangelogEntry[];
+    /** Pass as `cursor` to get the next page. `null` on the last page. */
+    nextCursor: string | null;
+}

package/dist/Changelog/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/Changelog/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/Changelog/types.ts"],"names":[],"mappings":""}

package/dist/Chat/_hostedToolsManifest.generated.js

@@ -808,7 +808,7 @@ exports.SOGNI_HOSTED_TOOLS_MANIFEST = {
             "type": "function",
             "function": {
                 "name": "upscale_video",
-                "description": "Upscale an existing video to 1080p or 1440p with FlashVSR video super-resolution. This is promptless, deterministic enhancement, not a generative edit: it keeps every source frame, the exact frame rate, the full aspect ratio, and the original audio, and it never changes content, trims, crops, restyles, or interpolates frames. Use it when the user asks to upscale, enlarge, sharpen, or increase the resolution of an uploaded or previously generated video, or wants an HD, 1080p, 1440p, or 2K copy of it. Do not use it to create, restyle, extend, or edit a video; when the user explicitly asks a generative model such as Seedance to re-render the clip, use video_to_video. The output is at most twice the source size, so 1080p needs a source whose short edge is 540-768px and 1440p needs 720-768px, and the source can be at most about 1344x768 pixels (768x1344 in portrait). It must also be 1-60 fps and at most 100 MB. The server sets the maximum clip length and rejects a source that is too long; never quote a length limit yourself, and if the tool reports that rejection, relay that error to the user. It cannot produce 4K or any size above 1440p; when the user asks for one, say so and offer 1440p. Each upscale costs credits based on the source video's size and length. Optional detailPreference (stable or sharper), processingSpeed (stable or faster), and seed tune the result; omit them unless the user asks, and none of them changes the price.",
+                "description": "Upscale an existing video to 1080p, 1440p or 2160p (4K) with recommended RelayVSR, or to 1080p or 1440p with FlashVSR. This is promptless, deterministic enhancement, not a generative edit: it keeps every source frame, the exact frame rate, the full aspect ratio, and the original audio, and it never changes content, trims, crops, restyles, or interpolates frames. Use it when the user asks to upscale, enlarge, sharpen, or increase the resolution of an uploaded or previously generated video, or wants an HD, 1080p, 1440p, 2K, or 4K copy of it. Do not use it to create, restyle, extend, or edit a video; when the user explicitly asks a generative model such as Seedance to re-render the clip, use video_to_video. Explicitly set model to relayvsr for new upscales. Use flashvsr when the user requests FlashVSR or specifically wants its detailPreference, processingSpeed or seed controls. Omitted model retains FlashVSR for compatibility. With FlashVSR the output is at most twice the source size, so 1080p needs a source whose short edge is 540-768px and 1440p needs 720-768px, and the source can be at most about 1344x768 pixels (768x1344 in portrait). With RelayVSR the output is at most twice the source size for a source up to 1920x1080 pixels (1080x1920 in portrait), or four times for a source up to 1344x768 (768x1344 in portrait), so 2160p needs a source whose short edge is 540-768px or exactly 1080px, and the output's long edge can be at most 3840px. The source must also be 1-60 fps and at most 100 MB. The server sets the maximum clip length and rejects a source that is too long; never quote a length limit yourself, and if the tool reports that rejection, relay that error to the user. FlashVSR cannot produce 4K or any size above 1440p, so a 4K request always uses relayvsr. Nothing here produces a size above 2160p; when the user asks for one, say so and offer 2160p. Each upscale costs credits based on the source video's size and length. With FlashVSR, optional detailPreference (stable or sharper), processingSpeed (stable or faster), and seed tune the result; omit them unless the user asks, and none of them changes the price. RelayVSR refuses all three.",
                 "parameters": {
                     "type": "object",
                     "properties": {
@@ -816,13 +816,22 @@ exports.SOGNI_HOSTED_TOOLS_MANIFEST = {
                             "type": "number",
                             "description": "Source video to upscale. Non-negative values select a prior generated video result by 0-based index. Negative values select uploaded videos: -1 is the first uploaded video, -2 the second, and so on. If omitted, use the latest generated video, falling back to the most recent uploaded video."
                         },
+                        "model": {
+                            "type": "string",
+                            "enum": [
+                                "flashvsr",
+                                "relayvsr"
+                            ],
+                            "description": "Upscaler. Explicitly select relayvsr, recommended for new upscales to 1080p, 1440p or 2160p. Use flashvsr when requested or for its detailPreference, processingSpeed or seed controls; it reaches 1080p or 1440p. RelayVSR takes none of those options. Omitted model retains FlashVSR for compatibility."
+                        },
                         "targetResolution": {
                             "type": "number",
                             "enum": [
                                 1080,
-                                1440
+                                1440,
+                                2160
                             ],
-                            "description": "Output resolution of the short edge in pixels: 1440 for 1440p/2K or 1080 for 1080p/Full HD. The long edge follows the source aspect ratio, so portrait videos stay portrait. Default: 1440, or 1080 when the source's short edge is below 720px. Set 1080 when the user asks for 1080p or Full HD."
+                            "description": "Output resolution of the short edge in pixels: 2160 for 2160p/4K (relayvsr only), 1440 for 1440p/2K, or 1080 for 1080p/Full HD. The long edge follows the source aspect ratio, so portrait videos stay portrait. Default: 1440, or 1080 when the source is too small for 1440p. Set 1080 when the user asks for 1080p or Full HD, and 2160 with model relayvsr when the user asks for 4K or 2160p."
                         },
                         "detailPreference": {
                             "type": "string",
@@ -830,7 +839,7 @@ exports.SOGNI_HOSTED_TOOLS_MANIFEST = {
                                 "stable",
                                 "sharper"
                             ],
-                            "description": "Detail preference. stable, the default, gives the most temporally stable result. sharper renders crisper fine detail with a little more risk of shimmer between frames. Set sharper only when the user asks for a sharper, crisper, or more detailed upscale; otherwise omit it. It does not change the price."
+                            "description": "FlashVSR only. Detail preference. stable, the default, gives the most temporally stable result. sharper renders crisper fine detail with a little more risk of shimmer between frames. Set sharper only when the user asks for a sharper, crisper, or more detailed upscale; otherwise omit it. It does not change the price."
                         },
                         "processingSpeed": {
                             "type": "string",
@@ -838,13 +847,13 @@ exports.SOGNI_HOSTED_TOOLS_MANIFEST = {
                                 "stable",
                                 "faster"
                             ],
-                            "description": "Processing speed. stable, the default, gives the most stable result. faster finishes sooner with slightly less stable detail. Set faster only when the user asks for a quicker upscale; otherwise omit it. It does not change the price."
+                            "description": "FlashVSR only. Processing speed. stable, the default, gives the most stable result. faster finishes sooner with slightly less stable detail. Set faster only when the user asks for a quicker upscale; otherwise omit it. It does not change the price."
                         },
                         "seed": {
                             "type": "integer",
                             "minimum": -1,
                             "maximum": 4294967295,
-                            "description": "Seed for the upscaler's fine texture, 0 through 4294967295; different seeds give slightly different fine detail. Omit it to keep the repeatable default of 0. Use -1 for a random seed. Set it only when the user gives a seed or asks for a different or random variation of an upscale."
+                            "description": "FlashVSR only. Seed for the upscaler's fine texture, 0 through 4294967295; different seeds give slightly different fine detail. Omit it to keep the repeatable default of 0. Use -1 for a random seed. Set it only when the user gives a seed or asks for a different or random variation of an upscale."
                         }
                     },
                     "required": []