@mindscraft/branch-video-agent-cli 0.4.6 → 0.5.0

package/dist/lib/http.js

@@ -17,6 +17,21 @@ function extractRequestId(response, parsed) {
         || response.headers.get('x-ai-gateway-request-id')
         || (typeof parsed?.requestId === 'string' ? parsed.requestId : null);
 }
+function parseResponseError(parsed, response) {
+    const error = typeof parsed === 'object' && parsed ? parsed?.error : undefined;
+    const nested = typeof error === 'object' && error ? error : undefined;
+    const message = typeof nested?.message === 'string'
+        ? nested.message
+        : typeof error === 'string'
+            ? error
+            : response.statusText || 'Request failed';
+    const code = typeof nested?.code === 'string'
+        ? nested.code
+        : typeof parsed?.code === 'string'
+            ? String(parsed.code)
+            : `HTTP_${response.status}`;
+    return { message, code };
+}
 export class CliHttpClient {
     baseUrl;
     token;
@@ -61,13 +76,8 @@ export class CliHttpClient {
             : null;
         const requestId = extractRequestId(response, parsed);
         if (!response.ok) {
-            const errorMessage = typeof parsed === 'object' && parsed && typeof parsed.error === 'string'
-                ? String(parsed.error)
-                : response.statusText || 'Request failed';
-            const errorCode = typeof parsed === 'object' && parsed && typeof parsed.code === 'string'
-                ? String(parsed.code)
-                : `HTTP_${response.status}`;
-            throw new CliCommandError(errorMessage, errorCode, parsed, requestId, response.status);
+            const error = parseResponseError(parsed, response);
+            throw new CliCommandError(error.message, error.code, parsed, requestId, response.status);
         }
         return {
             data: parsed,
@@ -75,4 +85,68 @@ export class CliHttpClient {
             requestId,
         };
     }
+    async requestStream(path, options) {
+        let response;
+        try {
+            response = await this.fetchImpl(buildUrl(this.baseUrl, path), {
+                method: options.method,
+                headers: {
+                    Authorization: `Bearer ${this.token}`,
+                    'content-type': options.contentType,
+                },
+                body: options.body,
+                duplex: 'half',
+                // A redirect to another origin must never receive the bearer token.
+                redirect: 'error',
+                signal: options.timeoutMs ? AbortSignal.timeout(options.timeoutMs) : undefined,
+            });
+        }
+        catch (error) {
+            throw new CliCommandError(error?.message || 'Network request failed', 'NETWORK_ERROR');
+        }
+        const text = await response.text();
+        const parsed = text
+            ? (() => {
+                try {
+                    return JSON.parse(text);
+                }
+                catch {
+                    return text;
+                }
+            })()
+            : null;
+        const requestId = extractRequestId(response, parsed);
+        if (!response.ok) {
+            const error = parseResponseError(parsed, response);
+            throw new CliCommandError(error.message, error.code, parsed, requestId, response.status);
+        }
+        return { data: parsed, status: response.status, requestId };
+    }
+    async requestBinary(path, options) {
+        let response;
+        try {
+            response = await this.fetchImpl(buildUrl(this.baseUrl, path), {
+                method: options.method,
+                headers: { Authorization: `Bearer ${this.token}` },
+                redirect: 'error',
+                signal: options.timeoutMs ? AbortSignal.timeout(options.timeoutMs) : undefined,
+            });
+        }
+        catch (error) {
+            throw new CliCommandError(error?.message || 'Network request failed', 'NETWORK_ERROR');
+        }
+        const bytes = new Uint8Array(await response.arrayBuffer());
+        const requestId = response.headers.get('x-request-id') || response.headers.get('x-correlation-id');
+        if (!response.ok) {
+            const text = new TextDecoder().decode(bytes);
+            let parsed = text;
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch { /* preserve plain error body */ }
+            const error = parseResponseError(parsed, response);
+            throw new CliCommandError(error.message, error.code, parsed, requestId, response.status);
+        }
+        return { data: bytes, status: response.status, requestId, contentType: response.headers.get('content-type') };
+    }
 }

package/dist/playtest/graph.js

@@ -99,6 +99,40 @@ function closedChoiceDefault(interaction) {
         && interactive.options.every((option) => typeof option.id === 'string'
             && (interaction.branches || []).some((branch) => branch.when === option.id && branch.then));
 }
+// Deliberately narrow: the image timer pauses at the first tick and every
+// settlement result leaves this node. Ordinary resumable interactions do not qualify.
+function settlementBlocksImageCompletion(nodeId, node, nodes) {
+    if (node.type !== 'image' || node.branchConfig || node.branches || node.events
+        || node.config?.events || node.config?.messageHandlers
+        || (node.config?.loop !== undefined && node.config.loop !== false)
+        || !Array.isArray(node.config?.slides) || node.config.slides.length !== 1
+        || !Array.isArray(node.interactions) || node.interactions.length !== 1)
+        return false;
+    const slide = node.config.slides[0];
+    if (!slide || typeof slide.id !== 'string' || !slide.id.trim()
+        || typeof slide.assetRef !== 'string' || !slide.assetRef.trim()
+        || (slide.duration !== undefined && (!Number.isFinite(slide.duration) || slide.duration < 0))
+        || (slide.duration || 3) <= 0.1)
+        return false;
+    const interaction = node.interactions[0];
+    if (!interaction || interaction.interactive?.type !== 'score_settlement'
+        || interaction.branchConfig || interaction.events
+        || (interaction.timeLimit !== undefined && (!Number.isFinite(interaction.timeLimit) || interaction.timeLimit > 0))
+        || !(interaction.trigger?.type === 'time' && interaction.trigger.value === 0
+            || interaction.trigger?.type === 'slide' && interaction.trigger.index === 0 && interaction.trigger.offsetSec === 0)
+        || !Array.isArray(interaction.branches))
+        return false;
+    const outcomes = settlementConditions(interaction.interactive);
+    if (!outcomes)
+        return false;
+    const leavesNode = (action) => action?.type === 'end'
+        || action?.type === 'goto' && typeof action.target === 'string'
+            && Boolean(nodes[action.target.trim()]) && action.target.trim() !== nodeId;
+    if (interaction.branches.some((branch) => !branch || branch.condition || !leavesNode(branch.then))
+        || [interaction.fallback?.onDefault, interaction.fallback?.onTimeout].some(action => action && !leavesNode(action)))
+        return false;
+    return [...outcomes.keys()].every(result => interaction.branches.some((branch) => (typeof branch.when === 'string' && branch.when.trim().toLowerCase() === result)));
+}
 export function extractPlaytestEdges(script) {
     const graph = script?.graph;
     const nodes = graph?.nodes || {};
@@ -108,14 +142,21 @@ export function extractPlaytestEdges(script) {
         if (node.type === 'start')
             addEdge(edges, nodeId, 'node', nodeId, { type: 'enter' }, node.config?.next);
         const avgCompletionInteraction = node.type === 'avg' && (node.interactions || []).some((interaction) => interaction.trigger?.type === 'complete');
-        if (node.type === 'video' || node.type === 'image' || (node.type === 'avg' && !node.branchConfig && !avgCompletionInteraction)) {
+        const mediaCompletion = node.type === 'video' || node.type === 'image' || node.type === 'avg';
+        if (mediaCompletion && !node.branchConfig && !avgCompletionInteraction) {
             addEdge(edges, nodeId, 'node', nodeId, { type: 'complete' }, node.config?.onComplete);
+            if (settlementBlocksImageCompletion(nodeId, node, nodes)) {
+                const completion = edges.at(-1);
+                if (completion?.from === nodeId && completion.owner === 'node' && completion.trigger.type === 'complete') {
+                    completion.unreachableReason = 'Immediate image settlement pauses completion and every result leaves the node';
+                }
+            }
         }
         // Completion interactions preempt completion routing, not enter/message rules.
         const nodeBranchConfig = avgCompletionInteraction && node.branchConfig
             ? { ...node.branchConfig, rules: (node.branchConfig.rules || []).filter((rule) => rule.trigger?.type !== 'complete'), defaultAction: undefined }
             : node.branchConfig;
-        addBranchConfigEdges(edges, nodeId, 'node', nodeId, nodeBranchConfig, node.type === 'avg' ? 'complete' : 'default');
+        addBranchConfigEdges(edges, nodeId, 'node', nodeId, nodeBranchConfig, mediaCompletion ? 'complete' : 'default');
         for (const handler of node.config?.messageHandlers || []) {
             addEdge(edges, nodeId, 'node', nodeId, handler.when || { type: 'message' }, handler.then, false, {
                 variableActions: handler.variableActions,

package/dist/playtest/runner.d.ts

@@ -1,5 +1,5 @@
-import { type Frame } from 'playwright';
-import type { PlaytestContract, PlaytestLimits, PlaytestScenario, PlaytestScenarioResult } from './types.js';
+import { type ElementHandle, type Frame } from 'playwright';
+import type { PlaytestContract, PlaytestEdge, PlaytestLimits, PlaytestScenario, PlaytestScenarioResult } from './types.js';
 type ScriptRecord = Record<string, any>;
 interface RunnerOptions {
     script: ScriptRecord;
@@ -15,8 +15,17 @@ interface RunnerOptions {
         height: number;
     };
 }
+interface VerifiedMedia {
+    element: ElementHandle;
+    source: string;
+    nodeId: string;
+}
 export declare function startPlayback(frame: Frame, entryNodeId: string, entryNodeType: string, timeout: number): Promise<void>;
+export declare function assertNodeMedia(frame: Frame, node: ScriptRecord, deadline: number): Promise<VerifiedMedia | undefined>;
+export declare function driveVerifiedVideo(media: VerifiedMedia | undefined, trigger: 'time' | 'complete' | 'complete-interaction', time?: number): Promise<void>;
+export declare function executeWebEdge(frame: Frame, node: ScriptRecord, edge: PlaytestEdge, contract: PlaytestContract, deadline: number): Promise<void>;
 export declare function completeAvgPlayback(frame: Frame, nodeId: string, deadline: number): Promise<void>;
+export declare function executeEdge(frame: Frame, edge: PlaytestEdge, options: RunnerOptions, deadline: number): Promise<void>;
 export declare function runPlaytestScenarios(options: RunnerOptions): Promise<PlaytestScenarioResult[]>;
 export declare function createDraftPlayerUrl(baseUrl: string): {
     playerUrl: string;