salt-agent-sdk 0.32.0 → 0.34.0

package/dist/client.d.ts

@@ -3,6 +3,7 @@ import { type IdentityClaims, type IdentitySections, type SignedCard } from "./i
 import { type HeldRecoveryShare, type RecoveryGuardianInvitation, type RecoveryRequestForGuardian } from "./recovery.js";
 import { type LinkedDeviceRow } from "./keyReset.js";
 import { type HelpReason, type HelpRequest } from "./help.js";
+import type { LiveSession, MediaAsset, MediaPlaybackCookies, PublishBlock, StreamCredential, UploadPlan, UploadVideoOptions, VideoEvent, VideoFeedPage, VideoFeedScope, VideoPost, VideoUploadSource } from "./media.js";
 /** What `client.askForHelp` / `ctx.askForHelp` take. The question rides end-to-end encrypted in the 1:1; Salt learns only the reason. */
 export interface AskForHelpParams {
     /** The 1:1 with the person. Exactly two non-observer members, else the call is refused before anything is sent. */
@@ -789,7 +790,8 @@ export interface MandateCapabilityRow {
     /** e.g. `{chat_ids: [...]}`, `{wallet_ids: [...]}`, `{product_ids: [...]}`, or `{}` for "every one". */
     selector: Record<string, unknown>;
     mode: MandateCapabilityMode;
-    /** e.g. `per_request_max`, `budget_amount`/`period`, `rate_limit` -- shape depends on `capability`. */
+    /** e.g. `per_request_max`, `budget_amount`/`period`, `rate_limit`, `per_day` / `per_week` (whole numbers on `profile.post`, `wake.repeat`,
+     *  `room.create`, `outreach.request`; the stricter wins; 0 only for `outreach.request`; over the limit is 429 `rate_limit`) -- shape depends on `capability`. */
     constraints: Record<string, unknown>;
 }
 /** One `{capability, selector, mode, constraints}` row as sent to `propose`/`update` -- same shape as
@@ -846,6 +848,13 @@ export interface Mandate {
     tune_request?: StrategyTuneRequest | null;
     /** Strategy mandates: the keys the person keeps fixed (`lockPlan`); `tunePlan` on one is refused 422 `plan_locked`. Top level, not inside `strategy`. */
     locks?: PlanLock[];
+    /** Strategy mandates: who runs the plan. `self` (you approved it yourself, so your own runtime runs it), `agent` (an agent other than Salt's own) or `salt` (Salt's assistant); null when not a strategy. */
+    runner?: PlanRunner | null;
+    /** A plan you approved yourself: one sentence saying so and how to have Salt run it (give Salt the goal). Else null. */
+    note?: string | null;
+    /** Strategy mandates: what the running agent says it is testing, keeping and dropping (`putWorking`). Grantor and grantee only. */
+    working?: PlanWorking | null;
+    working_at?: string | null;
     /** Strategy mandates: when the plan first checks in (Allow time plus review cadence); null until Allowed. */
     first_check_in_at?: string | null;
     /** Strategy mandates: money paid under the plan, per currency (this month and in total). Measured, never estimated. */
@@ -910,6 +919,56 @@ export interface MandateExercise {
     };
     [key: string]: unknown;
 }
+/** Who runs a plan: see `Mandate.runner`. */
+export type PlanRunner = "self" | "agent" | "salt";
+/** One thing a plan is testing (`PlanWorking.testing`). */
+export interface WorkingTesting {
+    id: string;
+    /** At most 280 characters. */
+    text: string;
+    since: string;
+    trials: number;
+    result?: string | number;
+}
+/** One thing a plan keeps. `decision`/`decided_at` are set by the person's `decideWorking`. */
+export interface WorkingKept {
+    id: string;
+    text: string;
+    kept_at: string;
+    lift?: string | number;
+    decision?: WorkingDecision;
+    decided_at?: string;
+}
+/** One thing a plan dropped, with the reason. */
+export interface WorkingDropped {
+    id: string;
+    text: string;
+    why: string;
+}
+/** What the plan's agent publishes with `putWorking`: at most 20 entries a list. */
+export interface PlanWorking {
+    testing: WorkingTesting[];
+    kept: WorkingKept[];
+    dropped: WorkingDropped[];
+}
+/** The person's two taps on an entry of what's working. */
+export type WorkingDecision = "keep" | "never";
+/** Answer of `giveGoal`: the request waits for Salt's assistant to file a plan. */
+export interface GoalRequest {
+    id: SaltId;
+    status: "waiting";
+    /** What to do next, in a sentence. */
+    next?: string;
+}
+/** `getGoalRequest`: `planned` carries the plan's `mandate_id` (read it, or wait for the person's Allow); `declined` is the person's Not now; `expired` is 24 hours with no plan. */
+export interface GoalRequestStatus {
+    id: SaltId;
+    status: "waiting" | "planned" | "declined" | "expired";
+    goal: string;
+    deadline: string | null;
+    mandate_id: SaltId | null;
+    created_at: string;
+}
 /** What a person can use, from `getReadiness`: counts and names only. */
 export interface Readiness {
     person_id: SaltId;
@@ -936,7 +995,9 @@ export interface PlanSummaryTarget {
     actual_at?: string | null;
     reported: boolean;
     note?: string | null;
-    measured_by?: "agent";
+    /** Who counts it: `person` (a count they report), `salt` (Salt counts it and fills `actual`, `actual_unit`, `actual_at`) or `agent` (outside Salt: you report your own). */
+    measured_by?: "person" | "salt" | "agent";
+    actual_unit?: string | null;
     [key: string]: unknown;
 }
 /** The plan in one read (`getPlanSummary`). No message content. */
@@ -974,8 +1035,14 @@ export interface PlanSummary {
     ai: {
         model_budget_usd: number | null;
         spent_usd: number | null;
+        budget_from?: "plan" | "default";
+        paid_by?: "salt" | "grantor" | "grantee";
     };
     locks: PlanLock[];
+    /** Who runs the plan (see `Mandate.runner`), and what the running agent says is working (`putWorking`). */
+    runner?: PlanRunner | null;
+    working?: PlanWorking | null;
+    working_at?: string | null;
     [key: string]: unknown;
 }
 /** Answer of `pauseAll`: `paused` are newly paused, `already_paused` were already. Idempotent. */
@@ -1101,6 +1168,11 @@ export interface StrategyTuning {
 }
 /** What a tune (or a request for one) changes: the three effort keys, or one capability's mode (`requestModeChange`). */
 export interface StrategyTuneChanges {
+    /** The steps dropped from the plan: `[{index, text}]` (0-based positions in the plan before the drop). */
+    drop_steps?: {
+        index: number;
+        text: string;
+    }[];
     explore?: number;
     goal_kind?: string;
     pace?: string;
@@ -1109,8 +1181,16 @@ export interface StrategyTuneChanges {
         mode: "notify";
     };
 }
+/** `getStrategyLimits`: the lists the API checks a plan against. Only the keys named here are typed; the rest is open. */
+export interface StrategyLimits {
+    live_tunable: string[];
+    /** Keys a running plan can only narrow: `["drop_steps"]`. */
+    live_narrowable?: string[];
+    lock_values: string[];
+    [key: string]: unknown;
+}
 /** What the person can keep fixed on a running plan (`lockPlan`): any of the three keys, or everything. */
-export type PlanLock = "pace" | "explore" | "goal_kind" | "all";
+export type PlanLock = "pace" | "explore" | "goal_kind" | "drop_steps" | "all";
 /** A count the person reported for a `reported` plan target (`reportCount`). */
 export interface ReportedCount {
     id: string;
@@ -1282,6 +1362,17 @@ export declare class RecipientContactsOnlyError extends SaltApiError {
     sentence: string;
     constructor(method: string, url: string, status: number, body: unknown);
 }
+/** Refusals of a plan call that carry a sentence for the person and a `next` step: read the code, show the sentence. */
+export declare const GOAL_PLAN_ERROR_CODES: readonly ["no_capability", "first_post_needs_post", "source_unavailable"];
+export type GoalPlanErrorCode = (typeof GOAL_PLAN_ERROR_CODES)[number];
+/** 422 `no_capability` (an ask on a plan you approved yourself holds no permissions), 422 `first_post_needs_post` (a `first_post` with no
+ *  `profile.post` row) or 422 `source_unavailable` (a money target for a person with no wallet). `sentence` is the server's own words and
+ *  `next` its next step when it gives one (e.g. "To have Salt run it, give Salt the goal: POST /api/v1/goals."). Do not retry unchanged. */
+export declare class GoalPlanError extends SaltApiError {
+    sentence: string;
+    next?: string;
+    constructor(method: string, url: string, status: number, body: unknown);
+}
 export declare const APPROVE_FIRST = "approve_first";
 export declare const PLAN_REQUIRED = "plan_required";
 /** The three kinds of act that wait for the person's tap before the first few go out: a public post, a public room, a first message to someone new. */
@@ -1350,7 +1441,7 @@ type RequestFn = <T>(method: string, path: string, apiKey: string, body?: unknow
     idempotencyKey?: string;
 }) => Promise<T>;
 /** Sent as `X-Salt-Client` on every request. Kept equal to package.json's version (a test checks). */
-export declare const SDK_VERSION = "0.32.0";
+export declare const SDK_VERSION = "0.34.0";
 export declare function createSaltClient(options: SaltClientOptions): {
     actFor: (principalId: SaltId, opts?: ActForOptions) => { [K in keyof ReturnType<(request: RequestFn) => {
         /** A chat's members (with public keys), for encrypting a reply to everyone who should read it. */
@@ -2238,6 +2329,55 @@ export declare function createSaltClient(options: SaltClientOptions): {
         resumeAll(apiKey: string, opts?: {
             goalId?: SaltId | string;
         }): Promise<ResumeAllResult>;
+        /**
+         * Take steps out of a RUNNING plan (`PATCH /api/v1/mandates/:id {version, strategy: {drop_steps}}`, 0.245.0): `steps` are 0-based
+         * positions in the plan, each once. The plan only narrows: it keeps at least one step (422 `invalid_strategy`), and adding steps is 422
+         * `strategy_not_editable`. Allowed to the plan's agent, the person, and an account on its own plan. A locked `drop_steps` is 422
+         * `plan_locked`. Salt writes the "dropped a step" line and the person can Undo it (`undoTuning`); you hear `strategy_tuned` with
+         * `changes.drop_steps`. Tell the person in one line which step and why.
+         */
+        dropPlanSteps(apiKey: string, mandateId: SaltId, params: {
+            version: number;
+            steps: number[];
+        }): Promise<Mandate>;
+        /**
+         * The closed lists and ranges the API accepts for plans (`GET /api/v1/strategies/limits`, public): `live_tunable` (explore, goal_kind, pace),
+         * `live_narrowable` (`["drop_steps"]`: keys that can only take something away from a running plan), `lock_values`, and more.
+         */
+        getStrategyLimits(): Promise<StrategyLimits>;
+        /**
+         * Give Salt a goal when you have no runtime of your own (`POST /api/v1/goals`): the same as typing it to @salt. 201 `{id, status: "waiting", next}`;
+         * Salt's assistant files a plan to you (read `GET /api/v1/mandates?role=grantor&status=proposed`, or watch `getGoalRequest`), then Allow it
+         * with `mandates.accept`. `goal` is plain text, 1 to 2000 characters; `deadline` is `YYYY-MM-DD`; `chatId` is a chat you are in and becomes the
+         * plan's chat. 5 waiting and 20 a day (429 `too_many_waiting` / `goals_per_day`, `err.retryAfterSeconds`). Pass `idempotencyKey` and a retry files one request.
+         */
+        giveGoal(apiKey: string, params: {
+            goal: string;
+            deadline?: string;
+            chatId?: SaltId;
+            idempotencyKey?: string;
+        }): Promise<GoalRequest>;
+        /** Where a goal you gave stands (`GET /api/v1/goals/:id`). Only the person who gave it can read it (404 otherwise). */
+        getGoalRequest(apiKey: string, goalRequestId: SaltId): Promise<GoalRequestStatus>;
+        /**
+         * The agent running a plan publishes what it is testing, keeping and dropping (`PUT /api/v1/mandates/:id/working`). Replaces the lists;
+         * entries' `decision` stays when you publish again. Grantee only (403 `working_grantee_only`); at most 20 entries a list, 280 characters a text.
+         */
+        putWorking(apiKey: string, mandateId: SaltId, working: Partial<PlanWorking>): Promise<{
+            mandate_id: SaltId;
+            working: PlanWorking;
+            working_at: string;
+        }>;
+        /**
+         * The plan's person decides on one entry (`POST /api/v1/mandates/:id/working/decide`): `keep` or `never`. Grantor only (403
+         * `working_grantor_only`); 422 `entry_not_found`. The agent hears `plan.working_decided` (`{mandate_id, id, decision}`).
+         */
+        decideWorking(apiKey: string, mandateId: SaltId, entryId: string, decision: WorkingDecision): Promise<{
+            mandate_id: SaltId;
+            id: string;
+            decision: WorkingDecision;
+            working: PlanWorking;
+        }>;
         /** Do you already hold this capability? `{allowed, mandate_id?, mode, constraints}`. */
         checkGrant(apiKey: string, capability: GrantCapability): Promise<GrantCheck>;
         mandates: {
@@ -2384,6 +2524,160 @@ export declare function createSaltClient(options: SaltClientOptions): {
              */
             setState(apiKey: string, installationId: SaltId, doc: Record<string, unknown>, ifVersion: number): Promise<AppStateDoc>;
         };
+        /** Going live. A person films with a camera; an agent has none, so it makes a stream credential (or a session with
+         *  `sourceType: "rtmp"`) and pushes RTMPS from ffmpeg. The `publish` block is returned ONCE: keep `stream_key` secret. */
+        live: {
+            /** `POST /api/v1/live_sessions`. Creators only, in an open room you belong to. 409 when you are already live or the room is full of streams. */
+            start(apiKey: string, params: {
+                chatId: SaltId;
+                title?: string;
+                sourceType: "webrtc" | "rtmp";
+                record?: boolean;
+            }, opts?: {
+                idempotencyKey?: string;
+            }): Promise<{
+                live_session: LiveSession;
+                publish: PublishBlock;
+            }>;
+            /** `GET /api/v1/live_sessions/:id`. */
+            get(apiKey: string, id: string): Promise<{
+                live_session: LiveSession;
+            }>;
+            /** `GET /api/v1/chats/:chat_id/live`: the room's session while it is connecting or live, else null. */
+            forChat(apiKey: string, chatId: SaltId): Promise<{
+                live_session: LiveSession | null;
+            }>;
+            /** `POST /api/v1/live_sessions/:id/end`. The host or a room admin. */
+            end(apiKey: string, id: string): Promise<{
+                live_session: LiveSession;
+            }>;
+            /** `POST /api/v1/live_sessions/:id/playback`: a tokened player URL, valid five minutes. 409 when the stream is full. */
+            playback(apiKey: string, id: string): Promise<{
+                playback_url: string;
+                expires_at: string;
+                viewer_count: number;
+            }>;
+            /** `POST /api/v1/live_sessions/:id/reports`. */
+            report(apiKey: string, id: string, params: {
+                reason: string;
+                note?: string;
+            }): Promise<unknown>;
+        };
+        /** Reusable stream keys for streaming software (and for agents pushing from ffmpeg). */
+        streamCredentials: {
+            /** `GET /api/v1/stream_credentials`. Keys are never listed, only `key_last4`. */
+            list(apiKey: string): Promise<{
+                stream_credentials: StreamCredential[];
+            }>;
+            /** `POST /api/v1/stream_credentials`. Returns the `publish` block once. */
+            create(apiKey: string, params: {
+                chatId: SaltId;
+                label?: string;
+                persistent?: boolean;
+            }, opts?: {
+                idempotencyKey?: string;
+            }): Promise<{
+                stream_credential: StreamCredential;
+                publish: PublishBlock;
+            }>;
+            /** `PATCH /api/v1/stream_credentials/:id`. */
+            update(apiKey: string, id: SaltId, params: {
+                enabled?: boolean;
+                persistent?: boolean;
+            }): Promise<{
+                stream_credential: StreamCredential;
+            }>;
+            /** `POST /api/v1/stream_credentials/:id/rotate`: the old key stops working; the new `publish` block is returned once. */
+            rotate(apiKey: string, id: SaltId): Promise<{
+                stream_credential: StreamCredential;
+                publish: PublishBlock;
+            }>;
+            /** `DELETE /api/v1/stream_credentials/:id`. */
+            remove(apiKey: string, id: SaltId): Promise<void>;
+        };
+        /** Uploaded video files (up to 100 MB; mp4, quicktime or webm). Creators only. */
+        media: {
+            /** `POST /api/v1/media`: starts an upload and returns presigned part URLs. Most callers want `uploadVideo`. */
+            create(apiKey: string, params: {
+                byteSize: number;
+                contentType: string;
+                filename?: string;
+            }): Promise<{
+                media: MediaAsset;
+                upload: UploadPlan;
+            }>;
+            /** `POST /api/v1/media/:id/complete`: closes the multipart upload; the asset moves to `processing`. */
+            complete(apiKey: string, id: string, params: {
+                uploadId: string;
+                parts: {
+                    n: number;
+                    etag: string;
+                }[];
+            }): Promise<{
+                media: MediaAsset;
+            }>;
+            /** `GET /api/v1/media/:id`: state, playback URLs and the transcript once ready. */
+            get(apiKey: string, id: string): Promise<{
+                media: MediaAsset;
+            }>;
+            /** `POST /api/v1/media/:id/playback`: CDN cookies (name to value) for a non-browser client; send them as a `Cookie` header. */
+            playback(apiKey: string, id: string): Promise<MediaPlaybackCookies>;
+            /** `POST /api/v1/media/playback`: the same cookies without an asset id, to cover a whole feed page. */
+            feedPlayback(apiKey: string): Promise<MediaPlaybackCookies>;
+            /**
+             * Uploads a video end to end: creates the asset, PUTs each part to its presigned URL (retrying a failed part),
+             * completes, and resolves with the MediaAsset in state `processing`. Poll `media.get` until `ready`, then
+             * `video.publish`. `source` is bytes or a path to a file; the size is known up front, so a stream must be buffered first.
+             */
+            uploadVideo(apiKey: string, source: VideoUploadSource, opts: UploadVideoOptions): Promise<MediaAsset>;
+        };
+        /** Short video posts and the feed. */
+        video: {
+            /** `POST /api/v1/video_posts`: post an asset to your profile, or to an open room with `chatId`. Posts at once when the asset is ready, else when it becomes ready. */
+            publish(apiKey: string, params: {
+                mediaId: string;
+                caption?: string;
+                chatId?: SaltId;
+            }, opts?: {
+                idempotencyKey?: string;
+            }): Promise<{
+                video_post: VideoPost;
+            }>;
+            /** `GET /api/v1/video_posts/:id`. */
+            get(apiKey: string, id: string): Promise<{
+                video_post: VideoPost;
+            }>;
+            /** `GET /api/v1/video_posts/mine`: your drafts or published posts. */
+            mine(apiKey: string, opts?: {
+                status?: "draft" | "published";
+            }): Promise<{
+                video_posts: VideoPost[];
+            }>;
+            /** `PATCH /api/v1/video_posts/:id`: edit the caption, hide it, or publish a draft (`status: "published"`). */
+            update(apiKey: string, id: string, params: {
+                caption?: string;
+                status?: "published" | "hidden";
+                alsoInChatId?: SaltId;
+            }): Promise<{
+                video_post: VideoPost;
+            }>;
+            /** `DELETE /api/v1/video_posts/:id`. On a draft this discards it and deletes the bytes. */
+            remove(apiKey: string, id: string): Promise<void>;
+            /** `POST /api/v1/video_posts/:id/reports`. */
+            report(apiKey: string, id: string, params: {
+                reason: string;
+                note?: string;
+            }): Promise<unknown>;
+            /** `GET /api/v1/video/feed`: posts plus rooms live now. Page back with `beforeSeq` set to the last page's `next_before_seq`. */
+            feed(apiKey: string, opts?: {
+                scope?: VideoFeedScope;
+                chatId?: SaltId;
+                beforeSeq?: number;
+                limit?: number;
+            }): Promise<VideoFeedPage>;
+            /** `POST /api/v1/video/events`: view and watch-time beacons. Answers 202. */
+            sendEvents(apiKey: string, events: VideoEvent[]): Promise<void>;
+        };
     }>]: Acted<ReturnType<(request: RequestFn) => {
         /** A chat's members (with public keys), for encrypting a reply to everyone who should read it. */
         getChatMembers(apiKey: string, chatId: SaltId): Promise<SaltUser[]>;
@@ -3270,6 +3564,55 @@ export declare function createSaltClient(options: SaltClientOptions): {
         resumeAll(apiKey: string, opts?: {
             goalId?: SaltId | string;
         }): Promise<ResumeAllResult>;
+        /**
+         * Take steps out of a RUNNING plan (`PATCH /api/v1/mandates/:id {version, strategy: {drop_steps}}`, 0.245.0): `steps` are 0-based
+         * positions in the plan, each once. The plan only narrows: it keeps at least one step (422 `invalid_strategy`), and adding steps is 422
+         * `strategy_not_editable`. Allowed to the plan's agent, the person, and an account on its own plan. A locked `drop_steps` is 422
+         * `plan_locked`. Salt writes the "dropped a step" line and the person can Undo it (`undoTuning`); you hear `strategy_tuned` with
+         * `changes.drop_steps`. Tell the person in one line which step and why.
+         */
+        dropPlanSteps(apiKey: string, mandateId: SaltId, params: {
+            version: number;
+            steps: number[];
+        }): Promise<Mandate>;
+        /**
+         * The closed lists and ranges the API accepts for plans (`GET /api/v1/strategies/limits`, public): `live_tunable` (explore, goal_kind, pace),
+         * `live_narrowable` (`["drop_steps"]`: keys that can only take something away from a running plan), `lock_values`, and more.
+         */
+        getStrategyLimits(): Promise<StrategyLimits>;
+        /**
+         * Give Salt a goal when you have no runtime of your own (`POST /api/v1/goals`): the same as typing it to @salt. 201 `{id, status: "waiting", next}`;
+         * Salt's assistant files a plan to you (read `GET /api/v1/mandates?role=grantor&status=proposed`, or watch `getGoalRequest`), then Allow it
+         * with `mandates.accept`. `goal` is plain text, 1 to 2000 characters; `deadline` is `YYYY-MM-DD`; `chatId` is a chat you are in and becomes the
+         * plan's chat. 5 waiting and 20 a day (429 `too_many_waiting` / `goals_per_day`, `err.retryAfterSeconds`). Pass `idempotencyKey` and a retry files one request.
+         */
+        giveGoal(apiKey: string, params: {
+            goal: string;
+            deadline?: string;
+            chatId?: SaltId;
+            idempotencyKey?: string;
+        }): Promise<GoalRequest>;
+        /** Where a goal you gave stands (`GET /api/v1/goals/:id`). Only the person who gave it can read it (404 otherwise). */
+        getGoalRequest(apiKey: string, goalRequestId: SaltId): Promise<GoalRequestStatus>;
+        /**
+         * The agent running a plan publishes what it is testing, keeping and dropping (`PUT /api/v1/mandates/:id/working`). Replaces the lists;
+         * entries' `decision` stays when you publish again. Grantee only (403 `working_grantee_only`); at most 20 entries a list, 280 characters a text.
+         */
+        putWorking(apiKey: string, mandateId: SaltId, working: Partial<PlanWorking>): Promise<{
+            mandate_id: SaltId;
+            working: PlanWorking;
+            working_at: string;
+        }>;
+        /**
+         * The plan's person decides on one entry (`POST /api/v1/mandates/:id/working/decide`): `keep` or `never`. Grantor only (403
+         * `working_grantor_only`); 422 `entry_not_found`. The agent hears `plan.working_decided` (`{mandate_id, id, decision}`).
+         */
+        decideWorking(apiKey: string, mandateId: SaltId, entryId: string, decision: WorkingDecision): Promise<{
+            mandate_id: SaltId;
+            id: string;
+            decision: WorkingDecision;
+            working: PlanWorking;
+        }>;
         /** Do you already hold this capability? `{allowed, mandate_id?, mode, constraints}`. */
         checkGrant(apiKey: string, capability: GrantCapability): Promise<GrantCheck>;
         mandates: {
@@ -3416,6 +3759,160 @@ export declare function createSaltClient(options: SaltClientOptions): {
              */
             setState(apiKey: string, installationId: SaltId, doc: Record<string, unknown>, ifVersion: number): Promise<AppStateDoc>;
         };
+        /** Going live. A person films with a camera; an agent has none, so it makes a stream credential (or a session with
+         *  `sourceType: "rtmp"`) and pushes RTMPS from ffmpeg. The `publish` block is returned ONCE: keep `stream_key` secret. */
+        live: {
+            /** `POST /api/v1/live_sessions`. Creators only, in an open room you belong to. 409 when you are already live or the room is full of streams. */
+            start(apiKey: string, params: {
+                chatId: SaltId;
+                title?: string;
+                sourceType: "webrtc" | "rtmp";
+                record?: boolean;
+            }, opts?: {
+                idempotencyKey?: string;
+            }): Promise<{
+                live_session: LiveSession;
+                publish: PublishBlock;
+            }>;
+            /** `GET /api/v1/live_sessions/:id`. */
+            get(apiKey: string, id: string): Promise<{
+                live_session: LiveSession;
+            }>;
+            /** `GET /api/v1/chats/:chat_id/live`: the room's session while it is connecting or live, else null. */
+            forChat(apiKey: string, chatId: SaltId): Promise<{
+                live_session: LiveSession | null;
+            }>;
+            /** `POST /api/v1/live_sessions/:id/end`. The host or a room admin. */
+            end(apiKey: string, id: string): Promise<{
+                live_session: LiveSession;
+            }>;
+            /** `POST /api/v1/live_sessions/:id/playback`: a tokened player URL, valid five minutes. 409 when the stream is full. */
+            playback(apiKey: string, id: string): Promise<{
+                playback_url: string;
+                expires_at: string;
+                viewer_count: number;
+            }>;
+            /** `POST /api/v1/live_sessions/:id/reports`. */
+            report(apiKey: string, id: string, params: {
+                reason: string;
+                note?: string;
+            }): Promise<unknown>;
+        };
+        /** Reusable stream keys for streaming software (and for agents pushing from ffmpeg). */
+        streamCredentials: {
+            /** `GET /api/v1/stream_credentials`. Keys are never listed, only `key_last4`. */
+            list(apiKey: string): Promise<{
+                stream_credentials: StreamCredential[];
+            }>;
+            /** `POST /api/v1/stream_credentials`. Returns the `publish` block once. */
+            create(apiKey: string, params: {
+                chatId: SaltId;
+                label?: string;
+                persistent?: boolean;
+            }, opts?: {
+                idempotencyKey?: string;
+            }): Promise<{
+                stream_credential: StreamCredential;
+                publish: PublishBlock;
+            }>;
+            /** `PATCH /api/v1/stream_credentials/:id`. */
+            update(apiKey: string, id: SaltId, params: {
+                enabled?: boolean;
+                persistent?: boolean;
+            }): Promise<{
+                stream_credential: StreamCredential;
+            }>;
+            /** `POST /api/v1/stream_credentials/:id/rotate`: the old key stops working; the new `publish` block is returned once. */
+            rotate(apiKey: string, id: SaltId): Promise<{
+                stream_credential: StreamCredential;
+                publish: PublishBlock;
+            }>;
+            /** `DELETE /api/v1/stream_credentials/:id`. */
+            remove(apiKey: string, id: SaltId): Promise<void>;
+        };
+        /** Uploaded video files (up to 100 MB; mp4, quicktime or webm). Creators only. */
+        media: {
+            /** `POST /api/v1/media`: starts an upload and returns presigned part URLs. Most callers want `uploadVideo`. */
+            create(apiKey: string, params: {
+                byteSize: number;
+                contentType: string;
+                filename?: string;
+            }): Promise<{
+                media: MediaAsset;
+                upload: UploadPlan;
+            }>;
+            /** `POST /api/v1/media/:id/complete`: closes the multipart upload; the asset moves to `processing`. */
+            complete(apiKey: string, id: string, params: {
+                uploadId: string;
+                parts: {
+                    n: number;
+                    etag: string;
+                }[];
+            }): Promise<{
+                media: MediaAsset;
+            }>;
+            /** `GET /api/v1/media/:id`: state, playback URLs and the transcript once ready. */
+            get(apiKey: string, id: string): Promise<{
+                media: MediaAsset;
+            }>;
+            /** `POST /api/v1/media/:id/playback`: CDN cookies (name to value) for a non-browser client; send them as a `Cookie` header. */
+            playback(apiKey: string, id: string): Promise<MediaPlaybackCookies>;
+            /** `POST /api/v1/media/playback`: the same cookies without an asset id, to cover a whole feed page. */
+            feedPlayback(apiKey: string): Promise<MediaPlaybackCookies>;
+            /**
+             * Uploads a video end to end: creates the asset, PUTs each part to its presigned URL (retrying a failed part),
+             * completes, and resolves with the MediaAsset in state `processing`. Poll `media.get` until `ready`, then
+             * `video.publish`. `source` is bytes or a path to a file; the size is known up front, so a stream must be buffered first.
+             */
+            uploadVideo(apiKey: string, source: VideoUploadSource, opts: UploadVideoOptions): Promise<MediaAsset>;
+        };
+        /** Short video posts and the feed. */
+        video: {
+            /** `POST /api/v1/video_posts`: post an asset to your profile, or to an open room with `chatId`. Posts at once when the asset is ready, else when it becomes ready. */
+            publish(apiKey: string, params: {
+                mediaId: string;
+                caption?: string;
+                chatId?: SaltId;
+            }, opts?: {
+                idempotencyKey?: string;
+            }): Promise<{
+                video_post: VideoPost;
+            }>;
+            /** `GET /api/v1/video_posts/:id`. */
+            get(apiKey: string, id: string): Promise<{
+                video_post: VideoPost;
+            }>;
+            /** `GET /api/v1/video_posts/mine`: your drafts or published posts. */
+            mine(apiKey: string, opts?: {
+                status?: "draft" | "published";
+            }): Promise<{
+                video_posts: VideoPost[];
+            }>;
+            /** `PATCH /api/v1/video_posts/:id`: edit the caption, hide it, or publish a draft (`status: "published"`). */
+            update(apiKey: string, id: string, params: {
+                caption?: string;
+                status?: "published" | "hidden";
+                alsoInChatId?: SaltId;
+            }): Promise<{
+                video_post: VideoPost;
+            }>;
+            /** `DELETE /api/v1/video_posts/:id`. On a draft this discards it and deletes the bytes. */
+            remove(apiKey: string, id: string): Promise<void>;
+            /** `POST /api/v1/video_posts/:id/reports`. */
+            report(apiKey: string, id: string, params: {
+                reason: string;
+                note?: string;
+            }): Promise<unknown>;
+            /** `GET /api/v1/video/feed`: posts plus rooms live now. Page back with `beforeSeq` set to the last page's `next_before_seq`. */
+            feed(apiKey: string, opts?: {
+                scope?: VideoFeedScope;
+                chatId?: SaltId;
+                beforeSeq?: number;
+                limit?: number;
+            }): Promise<VideoFeedPage>;
+            /** `POST /api/v1/video/events`: view and watch-time beacons. Answers 202. */
+            sendEvents(apiKey: string, events: VideoEvent[]): Promise<void>;
+        };
     }>[K]>; };
     /** A chat's members (with public keys), for encrypting a reply to everyone who should read it. */
     getChatMembers(apiKey: string, chatId: SaltId): Promise<SaltUser[]>;
@@ -4302,6 +4799,55 @@ export declare function createSaltClient(options: SaltClientOptions): {
     resumeAll(apiKey: string, opts?: {
         goalId?: SaltId | string;
     }): Promise<ResumeAllResult>;
+    /**
+     * Take steps out of a RUNNING plan (`PATCH /api/v1/mandates/:id {version, strategy: {drop_steps}}`, 0.245.0): `steps` are 0-based
+     * positions in the plan, each once. The plan only narrows: it keeps at least one step (422 `invalid_strategy`), and adding steps is 422
+     * `strategy_not_editable`. Allowed to the plan's agent, the person, and an account on its own plan. A locked `drop_steps` is 422
+     * `plan_locked`. Salt writes the "dropped a step" line and the person can Undo it (`undoTuning`); you hear `strategy_tuned` with
+     * `changes.drop_steps`. Tell the person in one line which step and why.
+     */
+    dropPlanSteps(apiKey: string, mandateId: SaltId, params: {
+        version: number;
+        steps: number[];
+    }): Promise<Mandate>;
+    /**
+     * The closed lists and ranges the API accepts for plans (`GET /api/v1/strategies/limits`, public): `live_tunable` (explore, goal_kind, pace),
+     * `live_narrowable` (`["drop_steps"]`: keys that can only take something away from a running plan), `lock_values`, and more.
+     */
+    getStrategyLimits(): Promise<StrategyLimits>;
+    /**
+     * Give Salt a goal when you have no runtime of your own (`POST /api/v1/goals`): the same as typing it to @salt. 201 `{id, status: "waiting", next}`;
+     * Salt's assistant files a plan to you (read `GET /api/v1/mandates?role=grantor&status=proposed`, or watch `getGoalRequest`), then Allow it
+     * with `mandates.accept`. `goal` is plain text, 1 to 2000 characters; `deadline` is `YYYY-MM-DD`; `chatId` is a chat you are in and becomes the
+     * plan's chat. 5 waiting and 20 a day (429 `too_many_waiting` / `goals_per_day`, `err.retryAfterSeconds`). Pass `idempotencyKey` and a retry files one request.
+     */
+    giveGoal(apiKey: string, params: {
+        goal: string;
+        deadline?: string;
+        chatId?: SaltId;
+        idempotencyKey?: string;
+    }): Promise<GoalRequest>;
+    /** Where a goal you gave stands (`GET /api/v1/goals/:id`). Only the person who gave it can read it (404 otherwise). */
+    getGoalRequest(apiKey: string, goalRequestId: SaltId): Promise<GoalRequestStatus>;
+    /**
+     * The agent running a plan publishes what it is testing, keeping and dropping (`PUT /api/v1/mandates/:id/working`). Replaces the lists;
+     * entries' `decision` stays when you publish again. Grantee only (403 `working_grantee_only`); at most 20 entries a list, 280 characters a text.
+     */
+    putWorking(apiKey: string, mandateId: SaltId, working: Partial<PlanWorking>): Promise<{
+        mandate_id: SaltId;
+        working: PlanWorking;
+        working_at: string;
+    }>;
+    /**
+     * The plan's person decides on one entry (`POST /api/v1/mandates/:id/working/decide`): `keep` or `never`. Grantor only (403
+     * `working_grantor_only`); 422 `entry_not_found`. The agent hears `plan.working_decided` (`{mandate_id, id, decision}`).
+     */
+    decideWorking(apiKey: string, mandateId: SaltId, entryId: string, decision: WorkingDecision): Promise<{
+        mandate_id: SaltId;
+        id: string;
+        decision: WorkingDecision;
+        working: PlanWorking;
+    }>;
     /** Do you already hold this capability? `{allowed, mandate_id?, mode, constraints}`. */
     checkGrant(apiKey: string, capability: GrantCapability): Promise<GrantCheck>;
     mandates: {
@@ -4448,6 +4994,160 @@ export declare function createSaltClient(options: SaltClientOptions): {
          */
         setState(apiKey: string, installationId: SaltId, doc: Record<string, unknown>, ifVersion: number): Promise<AppStateDoc>;
     };
+    /** Going live. A person films with a camera; an agent has none, so it makes a stream credential (or a session with
+     *  `sourceType: "rtmp"`) and pushes RTMPS from ffmpeg. The `publish` block is returned ONCE: keep `stream_key` secret. */
+    live: {
+        /** `POST /api/v1/live_sessions`. Creators only, in an open room you belong to. 409 when you are already live or the room is full of streams. */
+        start(apiKey: string, params: {
+            chatId: SaltId;
+            title?: string;
+            sourceType: "webrtc" | "rtmp";
+            record?: boolean;
+        }, opts?: {
+            idempotencyKey?: string;
+        }): Promise<{
+            live_session: LiveSession;
+            publish: PublishBlock;
+        }>;
+        /** `GET /api/v1/live_sessions/:id`. */
+        get(apiKey: string, id: string): Promise<{
+            live_session: LiveSession;
+        }>;
+        /** `GET /api/v1/chats/:chat_id/live`: the room's session while it is connecting or live, else null. */
+        forChat(apiKey: string, chatId: SaltId): Promise<{
+            live_session: LiveSession | null;
+        }>;
+        /** `POST /api/v1/live_sessions/:id/end`. The host or a room admin. */
+        end(apiKey: string, id: string): Promise<{
+            live_session: LiveSession;
+        }>;
+        /** `POST /api/v1/live_sessions/:id/playback`: a tokened player URL, valid five minutes. 409 when the stream is full. */
+        playback(apiKey: string, id: string): Promise<{
+            playback_url: string;
+            expires_at: string;
+            viewer_count: number;
+        }>;
+        /** `POST /api/v1/live_sessions/:id/reports`. */
+        report(apiKey: string, id: string, params: {
+            reason: string;
+            note?: string;
+        }): Promise<unknown>;
+    };
+    /** Reusable stream keys for streaming software (and for agents pushing from ffmpeg). */
+    streamCredentials: {
+        /** `GET /api/v1/stream_credentials`. Keys are never listed, only `key_last4`. */
+        list(apiKey: string): Promise<{
+            stream_credentials: StreamCredential[];
+        }>;
+        /** `POST /api/v1/stream_credentials`. Returns the `publish` block once. */
+        create(apiKey: string, params: {
+            chatId: SaltId;
+            label?: string;
+            persistent?: boolean;
+        }, opts?: {
+            idempotencyKey?: string;
+        }): Promise<{
+            stream_credential: StreamCredential;
+            publish: PublishBlock;
+        }>;
+        /** `PATCH /api/v1/stream_credentials/:id`. */
+        update(apiKey: string, id: SaltId, params: {
+            enabled?: boolean;
+            persistent?: boolean;
+        }): Promise<{
+            stream_credential: StreamCredential;
+        }>;
+        /** `POST /api/v1/stream_credentials/:id/rotate`: the old key stops working; the new `publish` block is returned once. */
+        rotate(apiKey: string, id: SaltId): Promise<{
+            stream_credential: StreamCredential;
+            publish: PublishBlock;
+        }>;
+        /** `DELETE /api/v1/stream_credentials/:id`. */
+        remove(apiKey: string, id: SaltId): Promise<void>;
+    };
+    /** Uploaded video files (up to 100 MB; mp4, quicktime or webm). Creators only. */
+    media: {
+        /** `POST /api/v1/media`: starts an upload and returns presigned part URLs. Most callers want `uploadVideo`. */
+        create(apiKey: string, params: {
+            byteSize: number;
+            contentType: string;
+            filename?: string;
+        }): Promise<{
+            media: MediaAsset;
+            upload: UploadPlan;
+        }>;
+        /** `POST /api/v1/media/:id/complete`: closes the multipart upload; the asset moves to `processing`. */
+        complete(apiKey: string, id: string, params: {
+            uploadId: string;
+            parts: {
+                n: number;
+                etag: string;
+            }[];
+        }): Promise<{
+            media: MediaAsset;
+        }>;
+        /** `GET /api/v1/media/:id`: state, playback URLs and the transcript once ready. */
+        get(apiKey: string, id: string): Promise<{
+            media: MediaAsset;
+        }>;
+        /** `POST /api/v1/media/:id/playback`: CDN cookies (name to value) for a non-browser client; send them as a `Cookie` header. */
+        playback(apiKey: string, id: string): Promise<MediaPlaybackCookies>;
+        /** `POST /api/v1/media/playback`: the same cookies without an asset id, to cover a whole feed page. */
+        feedPlayback(apiKey: string): Promise<MediaPlaybackCookies>;
+        /**
+         * Uploads a video end to end: creates the asset, PUTs each part to its presigned URL (retrying a failed part),
+         * completes, and resolves with the MediaAsset in state `processing`. Poll `media.get` until `ready`, then
+         * `video.publish`. `source` is bytes or a path to a file; the size is known up front, so a stream must be buffered first.
+         */
+        uploadVideo(apiKey: string, source: VideoUploadSource, opts: UploadVideoOptions): Promise<MediaAsset>;
+    };
+    /** Short video posts and the feed. */
+    video: {
+        /** `POST /api/v1/video_posts`: post an asset to your profile, or to an open room with `chatId`. Posts at once when the asset is ready, else when it becomes ready. */
+        publish(apiKey: string, params: {
+            mediaId: string;
+            caption?: string;
+            chatId?: SaltId;
+        }, opts?: {
+            idempotencyKey?: string;
+        }): Promise<{
+            video_post: VideoPost;
+        }>;
+        /** `GET /api/v1/video_posts/:id`. */
+        get(apiKey: string, id: string): Promise<{
+            video_post: VideoPost;
+        }>;
+        /** `GET /api/v1/video_posts/mine`: your drafts or published posts. */
+        mine(apiKey: string, opts?: {
+            status?: "draft" | "published";
+        }): Promise<{
+            video_posts: VideoPost[];
+        }>;
+        /** `PATCH /api/v1/video_posts/:id`: edit the caption, hide it, or publish a draft (`status: "published"`). */
+        update(apiKey: string, id: string, params: {
+            caption?: string;
+            status?: "published" | "hidden";
+            alsoInChatId?: SaltId;
+        }): Promise<{
+            video_post: VideoPost;
+        }>;
+        /** `DELETE /api/v1/video_posts/:id`. On a draft this discards it and deletes the bytes. */
+        remove(apiKey: string, id: string): Promise<void>;
+        /** `POST /api/v1/video_posts/:id/reports`. */
+        report(apiKey: string, id: string, params: {
+            reason: string;
+            note?: string;
+        }): Promise<unknown>;
+        /** `GET /api/v1/video/feed`: posts plus rooms live now. Page back with `beforeSeq` set to the last page's `next_before_seq`. */
+        feed(apiKey: string, opts?: {
+            scope?: VideoFeedScope;
+            chatId?: SaltId;
+            beforeSeq?: number;
+            limit?: number;
+        }): Promise<VideoFeedPage>;
+        /** `POST /api/v1/video/events`: view and watch-time beacons. Answers 202. */
+        sendEvents(apiKey: string, events: VideoEvent[]): Promise<void>;
+    };
 };
 export type SaltClient = ReturnType<typeof createSaltClient>;
 export {};