@slatesvideo/shared 0.4.5 → 0.4.7

package/dist/operations/index.d.ts

@@ -25,7 +25,9 @@ export declare const getWorkspaceState: Operation<{
 }>;
 export declare const getMe: Operation<Record<string, never>>;
 export declare const getCreditBalance: Operation<Record<string, never>>;
-export declare const listAvailableModels: Operation<Record<string, never>>;
+export declare const listAvailableModels: Operation<{
+    filter?: string;
+}>;
 export declare const estimateGenerationCost: Operation<{
     model: string;
     quantity?: number;
@@ -39,6 +41,9 @@ export declare const getProject: Operation<{
 }>;
 export declare const listAssets: Operation<{
     projectId: string;
+    type?: 'image' | 'video' | 'audio';
+    search?: string;
+    limit?: number;
 }>;
 export declare const getAssetImage: Operation<{
     id: string;
@@ -166,7 +171,7 @@ export declare function videoCostKey(input: {
 }): string;
 export declare const generateVideo: Operation<{
     prompt: string;
-    model: VideoModel;
+    model: string;
     projectId?: string;
     aspectRatio?: '1:1' | '16:9' | '9:16' | '4:3' | '3:4' | '21:9' | '9:21' | '4:5' | '5:4' | '2:3' | '3:2';
     duration?: number;
@@ -216,6 +221,7 @@ export declare const generateMotionTransfer: Operation<{
 }>;
 export declare const getGenerationStatus: Operation<{
     generationId: string;
+    waitSeconds?: number;
 }>;
 export declare const listGenerations: Operation<{
     projectId?: string;

package/dist/operations/index.js

@@ -22,7 +22,9 @@ export function defaultContext() {
 // ── Helpers ─────────────────────────────────────────────────────
 function ok(data, text) {
     return {
-        text: text ?? JSON.stringify(data, null, 2),
+        // Compact JSON — pretty-printing (indent 2) cost ~10-15% extra tokens
+        // on every tool result the calling LLM reads.
+        text: text ?? JSON.stringify(data),
         data,
     };
 }
@@ -77,11 +79,27 @@ export const getCreditBalance = {
 };
 export const listAvailableModels = {
     id: 'slates_list_available_models',
-    description: 'Full registry of generation models with their per-call credit cost. Use this for cost estimation.',
-    input: z.object({}).strict(),
-    async run(_input, ctx) {
+    description: 'Registry of generation model cost keys with per-call credit cost in cents, as a compact "key cents" table. Optional `filter` substring (e.g. "kling" or "nano-banana") keeps the result small — prefer it. For a single known model, slates_estimate_generation_cost is cheaper still.',
+    input: z.object({
+        filter: z.string().optional().describe('Substring match on the model key, e.g. "kling-v3" or "seedance"'),
+    }),
+    async run(input, ctx) {
         const r = await ctx.cloud().get('/api/agent/models');
-        return ok(r);
+        let models = r.models;
+        if (input.filter) {
+            const q = input.filter.toLowerCase();
+            models = models.filter((m) => m.model.toLowerCase().includes(q));
+        }
+        // Compact text table — "key cents" lines are ~5x denser than the raw
+        // JSON registry (the full pretty-printed dump was an ~8k-token leak).
+        const table = models.map((m) => `${m.model} ${m.cost_cents}`).join('\n');
+        return {
+            text: `${models.length} COST keys (cents per generation)${input.filter ? ` matching "${input.filter}"` : ''}. ` +
+                `NOTE: these are billing keys for cost lookup ONLY — the \`model\` param on slates_generate_video takes a BASE id ` +
+                `(kling-v3.0-std | kling-v3.0-pro | kling-v3.0-omni | seedance-2 | veo-3.1-fast | veo-3.1-standard) with duration/videoResolution as separate params:\n` +
+                table,
+            data: { count: models.length, credit_markup: r.credit_markup },
+        };
     },
 };
 export const estimateGenerationCost = {
@@ -138,15 +156,56 @@ export const getProject = {
     },
 };
 // ── Assets ──────────────────────────────────────────────────────
+/** Compact projection of a raw asset row — the full row (prompt, settings,
+ * paths, thumbnails) is 20-50x heavier and was the single biggest context
+ * leak in early agent sessions (494 assets ≈ 130KB ≈ 33k tokens in ONE
+ * tool result). Every op that embeds asset lists uses this. */
+function compactAsset(a) {
+    const r = a;
+    const prompt = typeof r.prompt === 'string' ? r.prompt : '';
+    return {
+        id: r.id,
+        code: r.code ?? null,
+        label: r.label ?? (prompt ? prompt.slice(0, 40) : null),
+        type: r.type,
+        created_at: r.createdAt ?? r.created_at ?? undefined,
+    };
+}
 export const listAssets = {
     id: 'slates_list_assets',
-    description: 'List all assets (images + videos) in a Slates project. Each asset carries its short code (IMG-A12 / VID-V3 / AUD-S1 — the badge the user sees on the gallery card) and label. When the user names an asset by code ("use IMG-A36 as the reference"), call this and match on the code field to resolve the assetId. Always speak about assets by code + label, never by UUID.',
-    input: z.object({ projectId: z.string().uuid() }),
+    description: 'List assets in a Slates project as COMPACT rows (id, code, label, type) — newest first, default limit 50. Each asset carries its short code (IMG-A12 / VID-V3 / AUD-S1 — the badge the user sees on the gallery card) and label. When the user names an asset by code ("use IMG-A36 as the reference"), pass it as `search` to resolve the assetId. Always speak about assets by code + label, never by UUID. NOTE: generate_* results already return the new asset ids — do NOT call this to find an asset you just created.',
+    input: z.object({
+        projectId: z.string().uuid(),
+        type: z.enum(['image', 'video', 'audio']).optional().describe('Only this asset type'),
+        search: z.string().optional().describe('Case-insensitive match on code or label (e.g. "IMG-A36" or "sunset")'),
+        limit: z.number().int().min(1).max(500).optional().describe('Max rows (default 50, newest first)'),
+    }),
     async run(input, ctx) {
         const r = await ctx.desktop().get('/agent/assets', {
             projectId: input.projectId,
         });
-        return ok(r);
+        const all = (r.assets ?? []).map(compactAsset);
+        let rows = all;
+        if (input.type)
+            rows = rows.filter((a) => a.type === input.type);
+        if (input.search) {
+            const q = input.search.toLowerCase();
+            rows = rows.filter((a) => String(a.code ?? '').toLowerCase().includes(q) ||
+                String(a.label ?? '').toLowerCase().includes(q));
+        }
+        // Newest first, then cap. (created_at is ISO — lexicographic sort works.)
+        rows = rows
+            .slice()
+            .sort((a, b) => String(b.created_at ?? '').localeCompare(String(a.created_at ?? '')));
+        const limit = input.limit ?? 50;
+        const truncated = rows.length > limit;
+        rows = rows.slice(0, limit);
+        return ok({
+            total_matching: truncated ? undefined : rows.length,
+            total_in_project: all.length,
+            truncated,
+            assets: rows.map(({ created_at: _drop, ...rest }) => rest),
+        });
     },
 };
 export const getAssetImage = {
@@ -760,7 +819,10 @@ export const generateImage = {
                     resolution,
                     cost_cents: totalCents,
                     cost_dollars: (totalCents / 100).toFixed(2),
-                    assets: assetList,
+                    // Compact refs only — the full rows (prompt/settings/paths) were a
+                    // multi-KB leak per generation and everything needed downstream is
+                    // the id/code/label.
+                    assets: assetList.map(compactAsset),
                     generationIds: result.generationIds ?? (result.generationId ? [result.generationId] : []),
                     ...(partialFailure
                         ? { partial: true, error: result.error ?? 'unknown error', requested_count: requestedCount }
@@ -1010,6 +1072,60 @@ export function videoCostKey(input) {
     }
     throw new Error(`Unknown video model: ${input.model}`);
 }
+/**
+ * Forgiving model-id resolver. Agents routinely paste registry COST keys
+ * ("kling-v3-standard-8s", "seedance-2-1080p-8s") into the `model` param —
+ * an observed 15-turn error-retry spiral in a live session. Instead of
+ * rejecting, extract the intent: base model + any duration / resolution /
+ * audio the key encodes. Returns null only when nothing matches.
+ */
+function resolveVideoModel(raw) {
+    let s = raw.trim().toLowerCase();
+    const out = { model: 'kling-v3.0-std' };
+    const dur = /-(\d+)s\b/.exec(s);
+    if (dur) {
+        out.duration = parseInt(dur[1], 10);
+        s = s.replace(/-(\d+)s\b/, '');
+    }
+    const res = /-(480p|720p|1080p|4k)\b/.exec(s);
+    if (res) {
+        out.videoResolution = res[1];
+        s = s.replace(/-(480p|720p|1080p|4k)\b/, '');
+    }
+    if (/-audio\b/.test(s)) {
+        out.sound = true;
+        s = s.replace(/-audio\b/, '');
+    }
+    if (/-(realface|face)\b/.test(s)) {
+        out.seedanceFace = true;
+        s = s.replace(/-(realface|face)\b/, '');
+    }
+    const direct = VIDEO_MODELS.find((m) => m === s);
+    if (direct) {
+        out.model = direct;
+        return out;
+    }
+    const aliases = {
+        'kling-v3-standard': 'kling-v3.0-std',
+        'kling-v3-std': 'kling-v3.0-std',
+        'kling-v3.0-standard': 'kling-v3.0-std',
+        'kling-v3': 'kling-v3.0-std',
+        'kling-v3-pro': 'kling-v3.0-pro',
+        'kling-v3-omni': 'kling-v3.0-omni',
+        'kling-v3-omni-pro': 'kling-v3.0-omni',
+        'kling-v3.0-omni-pro': 'kling-v3.0-omni',
+        'seedance-2.0': 'seedance-2',
+        'seedance-2-0': 'seedance-2',
+        seedance: 'seedance-2',
+        'veo-3.1': 'veo-3.1-fast',
+        'veo-3': 'veo-3.1-fast',
+    };
+    if (aliases[s]) {
+        out.model = aliases[s];
+        return out;
+    }
+    return null;
+}
 // Maps a video model id to its bundled prompting skill (frontmatter `name:`),
 // so guidance text points at a skill that actually exists. Deriving the name
 // via model.split('-')[0] produced 'slates-prompting-kling' / '...-veo', which
@@ -1028,7 +1144,7 @@ export const generateVideo = {
     description: 'Generate video via Slates credits. REQUIRED before calling: read slates-model-selection (routing: Kling = default, Seedance = premium/physics, Veo = audio-only niche), the slates-cost-discipline skill, plus the per-model prompting skill (slates-prompting-seedance / slates-prompting-kling-v3 / slates-prompting-veo-3) — video models prompt very differently. Also read slates-content-policy when the scene involves conflict, creatures, crowds, destruction, weapons, or young characters (build it safe-by-construction so the filter doesn\'t reject or degrade it). projectId is REQUIRED for UI integration (the user sees a progress card and the asset lands in the project — without it the call fails). aspectRatio + duration are required (server returns requires_clarification when missing). Cost > $0.50 returns requires_confirm — pass confirm=true after explicit user OK. Veo locks to 16:9 and to 4/6/8s durations (4K only at 8s). Image-to-video via firstFrameAssetId. Frames-to-video via firstFrameAssetId + lastFrameAssetId (Veo / Seedance only). Ingredients via ingredientAssetIds (Kling Omni / Seedance). No skill files installed? Call slates_get_prompting_guide with the per-model guide (\'slates-prompting-veo-3\' / \'slates-prompting-kling-v3\' / \'slates-prompting-seedance\') and \'slates-cost-discipline\' before first use.',
     input: z.object({
         prompt: z.string().min(1).max(4000),
-        model: z.enum(VIDEO_MODELS).describe('Route per the slates-model-selection skill. DEFAULT = Kling V3.0 std (general-purpose, cost-effective, strong start-frame adherence; pro = higher polish; omni = multi-char dialogue + audio). Seedance 2 = the PREMIUM tier — pick it whenever physics/effects/scale remotely matter or for hero shots; audio included, first+last frame + up to 9 reference images, full 480p–4K ladder (native 4K) via videoResolution. Veo 3.1 = niche, never the default — only when native synced audio must generate WITH the video in one gen; locks 16:9, 4/6/8s. For exact per-call credit cost, call slates_estimate_generation_cost or slates_list_available_models — never quote prices from memory (they change).'),
+        model: z.string().describe('One of: kling-v3.0-std | kling-v3.0-pro | kling-v3.0-omni | seedance-2 | veo-3.1-fast | veo-3.1-standard. Pass the BASE id — duration and videoResolution are separate params (registry entries like "kling-v3-standard-8s" are COST keys, not model ids; if you pass one it is auto-resolved). Route per the slates-model-selection skill. DEFAULT = Kling V3.0 std (general-purpose, cost-effective, strong start-frame adherence; pro = higher polish; omni = multi-char dialogue + audio). Seedance 2 = the PREMIUM tier — pick it whenever physics/effects/scale remotely matter or for hero shots; audio included, first+last frame + up to 9 reference images, full 480p–4K ladder (native 4K) via videoResolution. Veo 3.1 = niche, never the default — only when native synced audio must generate WITH the video in one gen; locks 16:9, 4/6/8s. For exact per-call credit cost, call slates_estimate_generation_cost — never quote prices from memory (they change).'),
         projectId: z.string().uuid().optional().describe('Save into this Slates project. Strongly recommended — the desktop UI shows a progress card live and the asset appears when complete.'),
         aspectRatio: z.enum(['1:1', '16:9', '9:16', '4:3', '3:4', '21:9', '9:21', '4:5', '5:4', '2:3', '3:2']).optional().describe('Veo locks to 16:9 — passing anything else will be ignored or fail. Kling/Seedance support all.'),
         duration: z.number().int().min(4).max(15).optional().describe('Seconds. Kling: 5-15. Veo: 4, 6, or 8 only (4K only at 8s). Seedance: 4-15. Default 5 if omitted but always be explicit (cost scales linearly).'),
@@ -1051,6 +1167,25 @@ export const generateVideo = {
         confirm: z.boolean().optional().describe('Set true after explicit user OK to bypass the >$0.50 cost confirm gate (which fires for almost every video gen since they\'re expensive).'),
     }),
     async run(input, ctx) {
+        // Resolve the model FIRST — forgiving normalization (cost keys, alias
+        // spellings) with a teaching error, so a wrong id never costs the agent
+        // a retry spiral. Anything the key encoded (duration/res/audio) fills
+        // params the caller left blank; explicit params always win.
+        const resolved = resolveVideoModel(input.model);
+        if (!resolved) {
+            throw new Error(`Unknown video model "${input.model}". Valid model ids: ${VIDEO_MODELS.join(' | ')}. ` +
+                `Registry entries like "kling-v3-standard-8s" or "seedance-2-1080p-8s" are COST keys, not model ids — ` +
+                `pass the base id and set duration / videoResolution as separate params.`);
+        }
+        input.model = resolved.model;
+        if (input.duration == null && resolved.duration != null)
+            input.duration = resolved.duration;
+        if (input.videoResolution == null && resolved.videoResolution != null)
+            input.videoResolution = resolved.videoResolution;
+        if (input.sound == null && resolved.sound != null)
+            input.sound = resolved.sound;
+        if (input.seedanceFace == null && resolved.seedanceFace != null)
+            input.seedanceFace = resolved.seedanceFace;
         // projectId is required for video — without it there's no UI feedback,
         // no asset to reference later, and a failed gen leaves the user with
         // nothing. The MCP-only headless path that exists for image gen is
@@ -1455,12 +1590,45 @@ export const generateMotionTransfer = {
 // ── Generation status (background mode) ─────────────────────────
 export const getGenerationStatus = {
     id: 'slates_get_generation_status',
-    description: 'Poll one generation by id. Returns status (pending/processing/completed/failed/cancelled), the error message on failure, and the finished asset record (with id, code, filePath) on completion. Use after submitting any generate_* op with background=true; poll every 5-15s — video generations commonly take 1-5 minutes. Generations survive app restarts (the desktop resumes in-flight provider jobs on boot).',
-    input: z.object({ generationId: z.string().uuid() }),
+    description: 'Poll one generation by id. Returns status (pending/processing/completed/failed/cancelled), the error message on failure, and the finished asset record (with id, code, filePath) on completion. Use after submitting any generate_* op with background=true. ALWAYS pass waitSeconds (use 45) — the call long-polls internally and returns early the moment the generation reaches a terminal state, so ONE call replaces a dozen rapid polls (each poll turn re-reads your whole context; rapid polling is the #1 orchestration-cost leak). Video generations commonly take 1-5 minutes: expect 1-4 long-poll calls, never a tight loop. Generations survive app restarts (the desktop resumes in-flight provider jobs on boot).',
+    input: z.object({
+        generationId: z.string().uuid(),
+        waitSeconds: z
+            .number()
+            .int()
+            .min(0)
+            .max(50)
+            .optional()
+            .describe('Long-poll: block up to N seconds, returning early on completion/failure. Use 45.'),
+    }),
     async run(input, ctx) {
         const desktop = ctx.desktop();
         await desktop.requireCapability('background-generation', 'background generation');
-        return ok(await desktop.get('/agent/generation/status', { id: input.generationId }));
+        const deadline = Date.now() + Math.min(Math.max(input.waitSeconds ?? 0, 0), 50) * 1000;
+        for (;;) {
+            const r = await desktop.get('/agent/generation/status', { id: input.generationId });
+            const g = r.generation;
+            const status = g?.status ?? r.status;
+            const terminal = status === 'completed' || status === 'failed' || status === 'cancelled';
+            if (terminal || Date.now() >= deadline) {
+                if (!g)
+                    return ok(r);
+                // Slim the payload: the raw generation row (full prompt/settings)
+                // and full asset row are context bloat — return the fields the
+                // agent acts on, with the EXACT billed cost front and center.
+                return ok({
+                    status,
+                    cost_cents: g.cost ?? null,
+                    error: g.error ?? null,
+                    model: g.model,
+                    completed_at: g.completedAt ?? null,
+                    asset: r.asset
+                        ? { ...compactAsset(r.asset), file_path: r.asset.filePath }
+                        : null,
+                });
+            }
+            await new Promise((resolve) => setTimeout(resolve, Math.min(3000, deadline - Date.now())));
+        }
     },
 };
 export const listGenerations = {
@@ -1477,7 +1645,8 @@ export const listGenerations = {
         return ok(await desktop.get('/agent/generation/list', {
             projectId: input.projectId,
             status: input.status,
-            limit: input.limit,
+            // Default cap — an unbounded history dump is a context leak.
+            limit: input.limit ?? 20,
         }));
     },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slatesvideo/shared",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "description": "Shared operations layer for the Slates MCP server and CLI: auth, cloud/desktop clients, and the single tool surface both consume. Most users want @slatesvideo/mcp-server or @slatesvideo/cli instead.",
   "license": "MIT",
   "type": "module",