@nodaro/sdk 2.29.0 → 2.32.0

package/dist/entries/apps.d.ts

@@ -0,0 +1,300 @@
+import { N as NodaroClientCore } from '../developer-apps-zSQXWmEG.js';
+import '@nodaro/shared/apps';
+import '@nodaro/shared/organizations';
+
+/**
+ * A published app — a workflow wrapped in a curated input/output presentation.
+ * Returned by the public `/v1/apps/browse` endpoint.
+ */
+interface PublishedApp {
+    id: string;
+    slug: string;
+    name: string;
+    description?: string | null;
+    creatorId: string;
+    creatorName?: string | null;
+    thumbnailUrl?: string | null;
+    category?: string | null;
+    isFeatured?: boolean;
+    runCount?: number;
+    /** The listed price per run; when `perMinuteCredits` is above 0, its fixed part. */
+    estimatedCredits?: number | null;
+    /**
+     * Credits per minute of the recording the app is given, when its price
+     * follows that recording's length: the price is `estimatedCredits` plus
+     * this per minute. 0 or absent when the price does not depend on a
+     * recording's length.
+     */
+    perMinuteCredits?: number;
+    /**
+     * Credits for each item beyond the creator's saved items of a list input
+     * the app's user fills: the price is the listed one plus this per further
+     * item. 0 or absent when the app has no such input.
+     */
+    perItemCredits?: number;
+    /**
+     * The listed price is a range: `estimatedCredits` (with `perMinuteCredits` /
+     * `perItemCredits`) is "from" — the app's saved settings — and these are
+     * "up to": the most a run can cost over the choices the app's user has (every
+     * exposed field, at the creator's restricted values where set). Present only
+     * when they differ from "from"; absent on an app published before the range
+     * existed until its next publish.
+     */
+    maxEstimatedCredits?: number;
+    maxPerMinuteCredits?: number;
+    maxPerItemCredits?: number;
+    createdAt: string;
+    updatedAt: string;
+}
+interface ListAppsParams {
+    /** Substring search across app name + description. */
+    search?: string;
+    /** Page size; backend caps at 50. */
+    limit?: number;
+    /** Cursor token returned by the previous page. */
+    cursor?: string;
+    /** Filter to a single category slug. */
+    category?: string;
+}
+interface ListAppsResult {
+    data: PublishedApp[];
+    nextCursor?: string | null;
+}
+/**
+ * App detail — includes the input schema (required + optional fields end users
+ * fill in) and the output mapping (which workflow nodes produce which display
+ * cards).
+ */
+interface PublishedAppDetail extends PublishedApp {
+    inputSchema: Record<string, unknown>;
+    outputs: Array<{
+        nodeId: string;
+        label: string;
+        type: string;
+    }>;
+    /**
+     * The app run alone: the listed price less its Render final part (run and
+     * charged separately) — fixed, per minute of the recording and per further
+     * list item. Absent from a server that predates them; read the listed
+     * `estimatedCredits` / `perMinuteCredits` / `perItemCredits` instead.
+     */
+    runEstimatedCredits?: number;
+    runPerMinuteCredits?: number;
+    runPerItemCredits?: number;
+    /**
+     * Whether this server charges Edit Plan per started minute of the recording
+     * (otherwise in 15/30/60/90/120/180-minute steps). Absent from a server that
+     * predates it: read it as the steps.
+     */
+    editPlanPerMinute?: boolean;
+}
+interface AppRunResult {
+    /** The execution-id that was started — poll via client.executions.get(). */
+    executionId: string;
+    status: "pending" | "running";
+    /** App-run id (distinct from executionId — used by listRuns/getRun). */
+    runId?: string;
+}
+interface AppRun {
+    id: string;
+    appSlug: string;
+    executionId: string;
+    status: "pending" | "running" | "completed" | "failed" | "cancelled";
+    inputs: Record<string, unknown>;
+    outputs?: Array<{
+        nodeId: string;
+        type: string;
+        url?: string;
+        text?: string;
+    }>;
+    startedAt: string;
+    finishedAt?: string | null;
+}
+interface ListAppRunsParams {
+    limit?: number;
+    cursor?: string;
+}
+/**
+ * Result of a soft-delete (archive) operation. The run is moved to the user's
+ * archive in the Nodaro UI; restoration and permanent deletion are UI-only by
+ * design — SDK / MCP / API delete callers can't accidentally destroy data.
+ */
+interface DeleteAppRunResult {
+    success: true;
+    archived: true;
+}
+/** Advanced per-run options for `apps.run`. */
+interface RunAppOptions {
+    /**
+     * Raw node-data overrides keyed by node id → field → value, merged onto the
+     * app's workflow for THIS run only. Reaches fields that are NOT exposed as app
+     * inputs — e.g. `{ [nodeId]: { promptPrefix: "…", promptSuffix: "…" } }` to
+     * wrap the end user's prompt with text they never see.
+     */
+    inputOverrides?: Record<string, Record<string, unknown>>;
+}
+/** Options for `apps.resume` — the Retry of a failed app run. */
+interface ResumeAppRunOptions {
+    /** Answer what the Retry would run and charge, and start nothing. */
+    dryRun?: boolean;
+    /**
+     * The app version you expect the Retry to run — the one starting over would
+     * run. Absent: the app's latest. A run of another version is refused with
+     * `app_run_version_changed`; send the run's own version (the refusal's
+     * `runVersion`) to continue on it anyway.
+     */
+    version?: number;
+}
+/** One step a Retry runs again. */
+interface AppRunResumeStep {
+    nodeId: string;
+    type: string;
+    /** The node's label, or `null` when it has none. */
+    label: string | null;
+}
+/** What a Retry would do (`apps.resume(…, { dryRun: true })`); nothing is started. */
+interface AppRunResumePlan {
+    runId: string;
+    /** The failed execution the Retry continues. */
+    continuesExecutionId: string;
+    /** The app version the Retry runs (the run's own). */
+    appVersion: number | null;
+    /** Every node the Retry runs, in graph order. */
+    nodeIds: string[];
+    /** The steps that run again. */
+    steps: AppRunResumeStep[];
+    /** What the Retry is expected to charge, the creator's fee included; `null` without credits. */
+    estimatedCredits: number | null;
+    /** Clips handed back at no cost. */
+    reusedClips: number;
+    /** Whether your balance and your app credits cover what the Retry holds while it runs; `null` without credits. */
+    sufficient: boolean | null;
+    /** Your spendable balance; `null` without credits. */
+    available: number | null;
+    /** Your app credits, present only when they are what stops the Retry (it would be refused `insufficient_app_credits`). */
+    appCreditsAllowance?: number;
+}
+/**
+ * A Retry that started. `deduped: true` when a concurrent double press reached
+ * the same Retry; a second call made while the first is pending is refused
+ * with `already_running` (`AlreadyRunningError`) instead.
+ */
+interface AppRunResumeResult {
+    /** The Retry's execution — the run now points at it. Poll via client.executions.get(). */
+    executionId: string;
+    runId: string;
+    status: "pending";
+    /** Every node the Retry runs. */
+    nodeIds: string[];
+    /** `true` when a concurrent press had already started this Retry. */
+    deduped?: true;
+}
+/**
+ * The `code` the server gives an `apps.resume` refusal. Nothing is written or
+ * billed when a Retry is refused. How each arrives:
+ * - `app_run_version_changed` as `AppRunVersionChangedError`;
+ * - `already_running` as `AlreadyRunningError` (with the live `executionId`);
+ * - `not_found` and `continuation_not_found` as `NotFoundError`, whose `code`
+ *   is always `not_found` (the server's message is kept);
+ * - `insufficient_credits` and `insufficient_app_credits` as
+ *   `InsufficientCreditsError`, whose `code` is always `insufficient_credits`
+ *   (the server's message says which);
+ * - the rest as `NodaroError` carrying this code.
+ */
+type AppRunResumeRefusalCode = 
+/** No such run of yours under this app. */
+"not_found"
+/** The run's execution is not yours. */
+ | "continuation_not_found"
+/** A malformed run id or body, or a component's run (continued by the run that called it). */
+ | "validation_error"
+/** The app version the run ran is gone: start the run over. */
+ | "app_run_version_unavailable"
+/** The app is on another version than the run ran: start over, or send `version` = the run's. */
+ | "app_run_version_changed"
+/** The run's execution ran another workflow, or another version of it (rare). */
+ | "continuation_workflow_mismatch" | "continuation_version_mismatch"
+/** The run did not fail (it completed or was stopped): start it over. */
+ | "continuation_not_failed"
+/** The run is still running, a Retry of it is pending, or it was started again elsewhere. */
+ | "already_running"
+/** Nothing is left to retry: every step completed (409), or the app runs no step (400). */
+ | "continuation_subset_required"
+/** An input the run applied sets a field the app does not let a runner set. */
+ | "locked_field"
+/**
+ * The Retry would stop at a Preview with nobody to review it: retry it from the app page.
+ * (The same refusal arrives under the other preview refusal codes when a review-on use-case
+ * node holds the run; `isPreviewRefusalCode` in `@nodaro/shared/nodes` asks for all of them.)
+ */
+ | "preview_review_required"
+/** Your app credits cannot cover it. */
+ | "insufficient_app_credits"
+/** Your balance cannot cover it. */
+ | "insufficient_credits"
+/** Billing is briefly unavailable for a workspace run (503): try again shortly. */
+ | "billing_unavailable";
+declare class AppsResource {
+    private client;
+    constructor(client: NodaroClientCore);
+    /** List published apps. Public — no auth required for community apps. */
+    list(params?: ListAppsParams): Promise<ListAppsResult>;
+    /** Get one app's metadata + input schema by slug. */
+    get(slug: string): Promise<{
+        data: PublishedAppDetail;
+    }>;
+    /**
+     * Trigger an app run with the given input values. The keys in `inputs` must
+     * match the app's input-schema field names (see `get(slug).inputSchema`).
+     * `opts.inputOverrides` adds raw per-node overrides (see {@link RunAppOptions}).
+     * Returns the execution-id for status polling via client.executions.get().
+     */
+    run(slug: string, inputs?: Record<string, unknown>, opts?: RunAppOptions): Promise<AppRunResult>;
+    /** List past runs for an app (the caller must own the app or the runs). */
+    listRuns(slug: string, params?: ListAppRunsParams): Promise<{
+        data: AppRun[];
+        nextCursor?: string | null;
+    }>;
+    /** Get one app-run by id. */
+    getRun(slug: string, runId: string): Promise<{
+        data: AppRun;
+    }>;
+    /**
+     * Retry a FAILED app run from where it stopped: only the steps it did not
+     * complete run, and only those are charged; every step it completed hands
+     * on its result. It runs the version the run ran, with the inputs the run
+     * applied (it takes none of its own). The run's execution moves to the
+     * Retry's.
+     *
+     * `{ dryRun: true }` answers what the Retry would run and charge
+     * ({@link AppRunResumePlan}) and starts nothing — show it before a Retry.
+     * Refusals are listed in {@link AppRunResumeRefusalCode}; to run with other
+     * inputs or on the app's current version, start over with
+     * `run(slug, inputs)` instead.
+     *
+     * @param slug   The published app's slug.
+     * @param runId  The run's UUID (`AppRunResult.runId`, `AppRun.id`).
+     */
+    resume(slug: string, runId: string, opts: ResumeAppRunOptions & {
+        dryRun: true;
+    }): Promise<{
+        data: AppRunResumePlan;
+    }>;
+    resume(slug: string, runId: string, opts?: ResumeAppRunOptions & {
+        dryRun?: false;
+    }): Promise<AppRunResumeResult>;
+    resume(slug: string, runId: string, opts?: ResumeAppRunOptions): Promise<{
+        data: AppRunResumePlan;
+    } | AppRunResumeResult>;
+    /**
+     * Archive (soft-delete) a published-app run. The run is hidden from the
+     * default run list and can be restored or permanently deleted from the
+     * archive view at https://app.nodaro.ai/archived-runs.
+     *
+     * @param slug   The published app's slug (the last path segment of its URL).
+     * @param runId  The run's UUID.
+     */
+    deleteRun(slug: string, runId: string): Promise<DeleteAppRunResult>;
+}
+
+export { type AppRun, type AppRunResult, type AppRunResumePlan, type AppRunResumeRefusalCode, type AppRunResumeResult, type AppRunResumeStep, AppsResource, type DeleteAppRunResult, type ListAppRunsParams, type ListAppsParams, type ListAppsResult, type PublishedApp, type PublishedAppDetail, type ResumeAppRunOptions, type RunAppOptions };

package/dist/entries/apps.js

@@ -0,0 +1,4 @@
+import '../chunk-3PPSGM5X.js';
+export { AppsResource } from '../chunk-53SXNN3A.js';
+//# sourceMappingURL=apps.js.map
+//# sourceMappingURL=apps.js.map

package/dist/entries/apps.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"apps.js"}

package/dist/entries/audio.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+require('../chunk-CJLLIVSB.cjs');
+var chunkGA4LZZKQ_cjs = require('../chunk-GA4LZZKQ.cjs');
+
+
+
+Object.defineProperty(exports, "AudioResource", {
+  enumerable: true,
+  get: function () { return chunkGA4LZZKQ_cjs.AudioResource; }
+});
+//# sourceMappingURL=audio.cjs.map
+//# sourceMappingURL=audio.cjs.map

package/dist/entries/audio.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"audio.cjs"}

package/dist/entries/audio.d.cts

@@ -0,0 +1,200 @@
+import { AudioFxPreset } from '@nodaro/shared/media';
+import { TranscribeProvider } from '@nodaro/shared/models';
+export { TranscribeProvider } from '@nodaro/shared/models';
+import { Transcript } from '@nodaro/shared/edl';
+import { N as NodaroClientCore } from '../developer-apps-zSQXWmEG.cjs';
+import '@nodaro/shared/apps';
+import '@nodaro/shared/organizations';
+
+/**
+ * One word of a {@link AudioResource.transcribe} result — caption-shaped, in
+ * MILLISECONDS, and structurally the `captions[]` entry `media.addCaptions()`
+ * takes, so a word list can be passed straight through. `speaker` is present
+ * only on a diarized `elevenlabs-stt` run.
+ */
+interface TranscribeWord {
+    text: string;
+    startMs: number;
+    endMs: number;
+    timestampMs?: number | null;
+    confidence?: number | null;
+    speaker?: string;
+}
+/**
+ * A completed transcribe job's `output_data` (read it off `jobs.get(jobId)`).
+ *
+ * Mind the units: `words` and `json.words` are in MILLISECONDS, while the
+ * top-level `segments` are in SECONDS (the raw per-utterance ranges) — present
+ * only on the legacy lanes; `elevenlabs-stt` returns none, so read `words`.
+ */
+interface TranscribeJobOutput {
+    /** The full transcript as one string. */
+    text: string;
+    /** Detected (or requested) language code. */
+    language?: string;
+    /** Per-word timings, ms — present on the word-level lanes. */
+    words?: TranscribeWord[];
+    /** The normalized {@link Transcript} (ms), the shape `edit.*` consumes. */
+    json?: Transcript;
+    /** Per-utterance ranges in SECONDS — not ms, unlike everything above. */
+    segments?: Array<{
+        start: number;
+        end: number;
+        text: string;
+    }>;
+}
+/**
+ * Audio primitives — the building blocks Voice Changer Pro composes internally
+ * (separation, isolation, effect, mix, level) plus speech-to-text, exposed
+ * standalone so a consumer can run any single step or assemble its own
+ * pipeline. Each returns a job id to poll (`jobs.get(jobId)`).
+ */
+declare class AudioResource {
+    private client;
+    constructor(client: NodaroClientCore);
+    /**
+     * Separate an audio track into stems (`POST /v1/audio-separation`, Demucs).
+     * `mode` `"vocal_instrumental"` (default) splits voice from music/SFX;
+     * `"stems"` returns the full drums/bass/other/… breakdown. `quality`
+     * `auto` (default) / `fast` / `best`.
+     */
+    separate(input: {
+        audioUrl: string;
+        mode?: "vocal_instrumental" | "stems";
+        quality?: "auto" | "fast" | "best";
+    }): Promise<{
+        jobId: string;
+    }>;
+    /** Isolate the primary voice and strip background noise (`POST /v1/audio-isolation`, ElevenLabs). */
+    isolate(input: {
+        audioUrl: string;
+    }): Promise<{
+        jobId: string;
+    }>;
+    /**
+     * Apply a reverb / echo / telephone / megaphone effect to an audio track
+     * (`POST /v1/audio-fx`) — the same presets VCP's `voiceFx` uses, standalone.
+     * `mix` (0–100) is the reverb wet/dry; `delayMs` + `decay` drive `echo`/`custom`;
+     * `eqLow`/`eqHigh` (dB) shape telephone/megaphone.
+     */
+    applyFx(input: {
+        audioUrl: string;
+        preset?: AudioFxPreset;
+        mix?: number;
+        delayMs?: number;
+        decay?: number;
+        eqLow?: number;
+        eqHigh?: number;
+    }): Promise<{
+        jobId: string;
+    }>;
+    /**
+     * Layer multiple audio tracks into one (`POST /v1/mix-audio`). `audioUrls`
+     * (2–20) are summed; optional `trackVolumes` (0–200% each, positionally) set
+     * per-track level. `duck` puts a music bed under speech: every track EXCEPT
+     * `duck.under` (the 0-based index of the voice track) dips while that track
+     * is loud and rises back in its pauses (sidechain compression). `amount`
+     * (0–100, default 75) is how hard; `thresholdDb` (-60–0, default -30),
+     * `ratio` (1–20, overrides `amount`), `attackMs` (1–2000, default 20) and
+     * `releaseMs` (10–9000, default 500) are optional fine controls. A ducked mix
+     * sums its tracks rather than averaging them, so the voice keeps its level;
+     * the price is the same with or without a duck. `endAt` (`"longest"`, the
+     * default, or `"voice"`) says where the mix ends: `"voice"` ends it when the
+     * voice (the `duck.under` track) ends (needs `duck`). A video URL is a track
+     * too: its audio is mixed, and a video with no sound is a silent track.
+     */
+    mix(input: {
+        audioUrls: string[];
+        trackVolumes?: number[];
+        duck?: {
+            under: number;
+            amount?: number;
+            thresholdDb?: number;
+            ratio?: number;
+            attackMs?: number;
+            releaseMs?: number;
+        };
+        endAt?: "longest" | "voice";
+    }): Promise<{
+        jobId: string;
+    }>;
+    /**
+     * Adjust an audio (or a video's audio) level (`POST /v1/adjust-volume`):
+     * `volume` % (default 100), `normalize` to loudnorm, and `fadeIn`/`fadeOut`
+     * seconds. Provide `audioUrl` or `videoUrl`.
+     */
+    adjustVolume(input: {
+        audioUrl?: string;
+        videoUrl?: string;
+        volume?: number;
+        normalize?: boolean;
+        fadeIn?: number;
+        fadeOut?: number;
+    }): Promise<{
+        jobId: string;
+    }>;
+    /**
+     * Shift pitch and/or change tempo with Rubber Band (`POST /v1/pitch-tempo`):
+     * `semitones` −12…+12 (default 0), `tempo` 0.5…2 with the pitch kept
+     * (default 1; fixed at 1 for a video), `preserveFormants` (default true).
+     * Provide exactly one of `audioUrl` or `videoUrl` — a video keeps its picture.
+     * Input up to 30 minutes, priced per started minute.
+     */
+    pitchTempo(input: {
+        audioUrl?: string;
+        videoUrl?: string;
+        semitones?: number;
+        tempo?: number;
+        preserveFormants?: boolean;
+    }): Promise<{
+        jobId: string;
+    }>;
+    /**
+     * Concatenate audio segments end-to-end (`POST /v1/combine-audio`). Each
+     * segment is a `url` with an optional `[startTime, endTime]` sub-range.
+     */
+    combine(input: {
+        segments: Array<{
+            url: string;
+            startTime?: number;
+            endTime?: number;
+        }>;
+    }): Promise<{
+        jobId: string;
+    }>;
+    /**
+     * Transcribe an audio (or video) track to text (`POST /v1/transcribe`).
+     *
+     * Three engines are accepted. `elevenlabs-stt` (Scribe) is always word-level,
+     * flag or not, and is the only lane that honours `diarize` (who spoke) and
+     * `tagAudioEvents` (laughter, applause, …); `incredibly-fast-whisper` returns
+     * word timings when you ask for them. `whisper` returns NO word timings at
+     * all — named explicitly or reached by OMITTING `provider`, which still falls
+     * back to it — so asking it for them (`wordTimestamps: true`) is rejected with
+     * a `400 validation_error` at ingress, before any credit is spent. A kinetic
+     * caption render therefore has to name one of the other two.
+     *
+     * Poll `jobs.get(jobId)`; the finished job's `output_data` is a
+     * {@link TranscribeJobOutput}: `text` (the whole transcript), `words`
+     * (caption-shaped, in MILLISECONDS), `json` (the normalized
+     * {@link Transcript}, also ms) — and a top-level `segments` array that is in
+     * SECONDS, not ms.
+     *
+     * `words` is the caption source for a kinetic burn-in: hand it to
+     * `media.addCaptions()` as `captions` with `autoTranscribe: false` and the
+     * render uses those exact words (correct the `text` of an entry in between
+     * and the fix is what burns in).
+     */
+    transcribe(input: {
+        audioUrl: string;
+        provider?: TranscribeProvider;
+        language?: string;
+        diarize?: boolean;
+        tagAudioEvents?: boolean;
+        wordTimestamps?: boolean;
+    }): Promise<{
+        jobId: string;
+    }>;
+}
+
+export { AudioResource, type TranscribeJobOutput, type TranscribeWord };