@gentbajko/slopify 3.25.9 → 4.0.0

package/dist/kernel/runner/attempt.js

@@ -1,3 +1,4 @@
+import { errorText } from "../errors.js";
 import { redact } from "../log.js";
 import { isProviderError, providerError } from "../ports/model.js";
 // The retry policy, in one place. A stage slice is handed the wrapped calls of
@@ -122,6 +123,7 @@ function classify(error, expired, opts, limit) {
             message: redact(error.message),
             ...(error.fault.retryAfterMs === undefined ? {} : { retryAfterMs: error.fault.retryAfterMs }),
             ...(error.fault.planLimit === undefined ? {} : { planLimit: error.fault.planLimit }),
+            ...(error.fault.access === undefined ? {} : { access: error.fault.access }),
         });
     }
     if (unreachable(error)) {
@@ -134,7 +136,7 @@ function classify(error, expired, opts, limit) {
     }
     return providerError({
         kind: "other",
-        message: redact(error instanceof Error ? error.message : String(error)),
+        message: redact(errorText(error)),
     });
 }
 // What the user calls the other end of each kind of call.

package/dist/kernel/runner/audition.js

@@ -1,11 +1,12 @@
 import { attempt } from "./attempt.js";
+import { observed } from "./model-access.js";
 const unrecorded = {
     start: () => "audition",
     end: () => { },
 };
 export function auditionVoice(deps, call, signal) {
     const port = deps.registry.tts(call.provider);
-    return attempt({
+    const spoken = attempt({
         work: {
             projectId: "audition",
             revisionId: "audition",
@@ -33,4 +34,5 @@ export function auditionVoice(deps, call, signal) {
         const bytes = new Uint8Array(await new Response(spoken.audio).arrayBuffer());
         return { bytes, container: spoken.container };
     }, { kind: "tts", streaming: port.capabilities.streams });
+    return observed(deps.access, deps.log, { provider: call.provider, family: "tts", model: call.model ?? "" }, spoken, (result) => result.ok);
 }

package/dist/kernel/runner/checkpoint-authority.js

@@ -1,3 +1,4 @@
+import { errorText } from "../errors.js";
 export function createCheckpointAuthority(deps) {
     return {
         beforeClaim: deps.decide,
@@ -13,7 +14,7 @@ export function createCheckpointAuthority(deps) {
                 catch (error) {
                     deps.log.write("error", "checkpoint.wake", {
                         projectId,
-                        detail: error instanceof Error ? error.message : String(error),
+                        detail: errorText(error),
                     });
                 }
             }

package/dist/kernel/runner/index.js

@@ -1,4 +1,4 @@
-import { causedBy } from "../errors.js";
+import { causedBy, errorText } from "../errors.js";
 import { derive, deps as graph, releases } from "./graph.js";
 import { progressGate } from "./progress.js";
 import { faultOf } from "./retry-policy.js";
@@ -37,7 +37,8 @@ export function createRunner(deps) {
     const retally = () => {
         const projects = new Set();
         for (const entry of inflight.values()) {
-            projects.add(entry.projectId);
+            if (deps.counted?.(entry.projectId) !== false)
+                projects.add(entry.projectId);
         }
         if (projects.size !== count) {
             count = projects.size;
@@ -62,7 +63,7 @@ export function createRunner(deps) {
             deps.log.write("error", "stage.finish", {
                 projectId: stage.projectId,
                 stage: stage.kind,
-                detail: reasonOf(error),
+                detail: errorText(error),
             });
         }
         emitStage(stage, state, reason, { failureKind: kind });
@@ -77,7 +78,7 @@ export function createRunner(deps) {
             deps.log.write("error", "stage.retry", {
                 projectId: stage.projectId,
                 stage: stage.kind,
-                detail: reasonOf(error),
+                detail: errorText(error),
             });
             return false;
         }
@@ -134,14 +135,14 @@ export function createRunner(deps) {
                 return;
             }
             const fault = faultOf(error);
-            if (deferred(stage, fault, reasonOf(error)))
+            if (deferred(stage, fault, errorText(error)))
                 return;
             deps.log.write("error", "stage.failed", {
                 projectId: stage.projectId,
                 stage: stage.kind,
                 detail: causedBy(error),
             });
-            conclude(stage, "failed", reasonOf(error), fault?.kind);
+            conclude(stage, "failed", errorText(error), fault?.kind);
         }
     }
     function start(stage) {
@@ -178,7 +179,7 @@ export function createRunner(deps) {
             deps.log.write("error", "stage.execute", {
                 projectId: stage.projectId,
                 stage: stage.kind,
-                detail: reasonOf(error),
+                detail: errorText(error),
             });
         });
     }
@@ -265,6 +266,3 @@ export function createRunner(deps) {
         },
     };
 }
-function reasonOf(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/dist/kernel/runner/model-access.js

@@ -0,0 +1,40 @@
+import { errorText } from "../errors.js";
+import { isProviderError } from "../ports/model.js";
+// Like metering, recording never fails a call: the answer is already in hand.
+function guarded(log, use, write) {
+    try {
+        write();
+    }
+    catch (error) {
+        log.write("warn", "model-checks.record", {
+            detail: `${use.provider} ${use.model}: ${errorText(error)}`,
+        });
+    }
+}
+export function recordWorked(recorder, log, use) {
+    if (recorder === undefined || use.model.trim() === "")
+        return;
+    guarded(log, use, () => recorder.worked(use));
+}
+// Only a failure whose fault names the model's access teaches anything.
+export function recordFailure(recorder, log, use, error) {
+    if (recorder === undefined || use.model.trim() === "")
+        return;
+    if (!isProviderError(error) || error.fault.access === undefined)
+        return;
+    const sentence = error.message;
+    guarded(log, use, () => recorder.denied({ ...use, sentence }));
+}
+// Observes a call's outcome and hands it back unchanged.
+export function observed(recorder, log, use, call, succeeded = () => true) {
+    if (recorder === undefined)
+        return call;
+    return call.then((value) => {
+        if (succeeded(value))
+            recordWorked(recorder, log, use);
+        return value;
+    }, (error) => {
+        recordFailure(recorder, log, use, error);
+        throw error;
+    });
+}

package/dist/kernel/runner/model-check.js

@@ -0,0 +1,153 @@
+import { errorText } from "../errors.js";
+import { isProviderError, providerError } from "../ports/model.js";
+import { attempt } from "./attempt.js";
+// ceiling: a check that has not answered in a minute is called failed rather than waited for.
+export const checkTimeoutMs = 60_000;
+// The faults a provider reports after it took the request; the others refuse it up front.
+const afterSend = new Set([
+    "timeout",
+    "dropped",
+    "refusal",
+    "other",
+]);
+const unrecorded = { start: () => "model-check", end: () => { } };
+const stageOf = { llm: "article", tts: "audio", image: "images" };
+export async function checkModel(deps, call, signal) {
+    // Filled in by the call, read once the wrapper is done.
+    const seen = { use: null };
+    const started = deps.clock.now().getTime();
+    const run = async (inner, progress) => {
+        const bounded = AbortSignal.any([inner, AbortSignal.timeout(checkTimeoutMs)]);
+        try {
+            seen.use = await answer(deps.registry, call, bounded, progress);
+        }
+        catch (error) {
+            if (inner.aborted)
+                throw error;
+            seen.fault = bounded.aborted
+                ? { kind: "timeout" }
+                : isProviderError(error)
+                    ? error.fault
+                    : { kind: "other" };
+            // Rethrown as final, so the wrapper names and redacts it without trying again.
+            throw providerError({
+                kind: "unsupported",
+                message: bounded.aborted
+                    ? `The model did not answer within ${String(checkTimeoutMs / 1000)} seconds.`
+                    : error instanceof Error
+                        ? error.message
+                        : String(error),
+            });
+        }
+    };
+    const kind = call.kind;
+    try {
+        const result = await attempt({
+            work: {
+                projectId: "model-check",
+                revisionId: "model-check",
+                workId: "model-check",
+                stageId: "model-check",
+                kind: stageOf[call.kind],
+                fingerprint: "model-check",
+            },
+            maySubmit: () => true,
+            clock: deps.clock,
+            log: deps.log,
+            attempts: unrecorded,
+            projectId: "model-check",
+            stage: stageOf[call.kind],
+            stageId: "model-check",
+            signal,
+        }, run, { kind, timeoutMs: checkTimeoutMs + 30_000 });
+        if (!result.ok)
+            return {
+                verdict: "failed",
+                sentence: null,
+                stopProvider: false,
+                use: null,
+                mayHaveBilled: false,
+            };
+    }
+    catch (error) {
+        signal.throwIfAborted();
+        const sentence = errorText(error);
+        const named = seen.fault ?? (isProviderError(error) ? error.fault : { kind: "other" });
+        if (named.access !== undefined)
+            return {
+                verdict: "no-access",
+                sentence,
+                stopProvider: false,
+                use: null,
+                mayHaveBilled: false,
+            };
+        const stopProvider = named.kind === "auth" ||
+            named.kind === "missing_key" ||
+            named.kind === "rate_limit" ||
+            named.planLimit !== undefined;
+        return {
+            verdict: "failed",
+            sentence,
+            stopProvider,
+            use: null,
+            mayHaveBilled: !stopProvider && afterSend.has(named.kind),
+        };
+    }
+    const answered = seen.use;
+    return {
+        verdict: "works",
+        sentence: null,
+        stopProvider: false,
+        mayHaveBilled: false,
+        use: answered === null
+            ? null
+            : { ...answered, wallMs: Math.max(0, deps.clock.now().getTime() - started) },
+    };
+}
+async function answer(registry, call, signal, progress) {
+    const base = { provider: call.provider, model: call.model, wallMs: 0 };
+    if (call.kind === "llm") {
+        let text = "";
+        let usage = null;
+        for await (const event of registry.llm(call.provider).complete({
+            model: call.model,
+            ...(call.thinking === undefined ? {} : { thinking: call.thinking }),
+            messages: [{ role: "user", content: call.prompt }],
+            signal,
+        })) {
+            progress();
+            if (event.type === "delta")
+                text += event.text;
+            else if (event.type === "done")
+                usage = event.usage;
+        }
+        if (text.trim() === "")
+            throw new Error("The model answered with no text.");
+        return {
+            kind: "llm",
+            ...base,
+            ...(usage === null ? {} : { tokensIn: usage.inputTokens, tokensOut: usage.outputTokens }),
+        };
+    }
+    if (call.kind === "tts") {
+        const spoken = await registry.tts(call.provider).synthesize({
+            model: call.model,
+            voiceId: call.voiceId,
+            text: call.text,
+            signal,
+            onActivity: progress,
+        });
+        const bytes = new Uint8Array(await new Response(spoken.audio).arrayBuffer());
+        if (bytes.length === 0)
+            throw new Error("The voice model sent no audio.");
+        return { kind: "tts", ...base, characters: call.text.length };
+    }
+    await registry.image(call.provider).generate({
+        model: call.model,
+        prompt: call.prompt,
+        aspect: call.aspect,
+        ...(call.thinking === undefined ? {} : { thinking: call.thinking }),
+        signal,
+    });
+    return { kind: "image", ...base, images: 1, size: call.aspect };
+}

package/dist/kernel/runner/providers.js

@@ -1,7 +1,9 @@
 import { randomUUID } from "node:crypto";
+import { errorText } from "../errors.js";
 import { isProviderError, providerError } from "../ports/model.js";
 import { planAccountOf } from "../ports/plan-limits.js";
 import { attempt } from "./attempt.js";
+import { observed } from "./model-access.js";
 export function stageProviders(deps, context, pieceId) {
     const ctx = {
         work: context.work,
@@ -49,11 +51,12 @@ export function stageProviders(deps, context, pieceId) {
             deps.log.write("warn", "usage.record", {
                 projectId: context.stage.projectId,
                 stage: context.stage.kind,
-                detail: error instanceof Error ? error.message : String(error),
+                detail: errorText(error),
             });
         }
     };
     const since = (started) => Math.max(0, deps.clock.now().getTime() - started);
+    const learn = (use, call) => observed(deps.access, deps.log, use, call, (result) => result.ok);
     return {
         llm: (call, onEvent) => {
             // Resolved once; the adapter reads the stored key per request, so a key replaced
@@ -72,7 +75,7 @@ export function stageProviders(deps, context, pieceId) {
             });
             const started = deps.clock.now().getTime();
             let limits;
-            const answered = schedule(call.provider, () => attempt(ctx, async (signal, progress) => {
+            const answered = learn({ provider: call.provider, family: "llm", model: call.model }, schedule(call.provider, () => attempt(ctx, async (signal, progress) => {
                 preview("", true);
                 let text = "";
                 // Typed-ahead text the panel shows past the committed answer; the next delta
@@ -83,7 +86,9 @@ export function stageProviders(deps, context, pieceId) {
                 limits = undefined;
                 for await (const event of port.complete({
                     model: call.model,
-                    ...(call.thinkingConfig === undefined ? {} : { thinkingConfig: call.thinkingConfig }),
+                    ...(call.thinkingConfig === undefined
+                        ? {}
+                        : { thinkingConfig: call.thinkingConfig }),
                     ...(call.thinking === undefined ? {} : { thinking: call.thinking }),
                     messages: call.messages,
                     ...(call.documents === undefined ? {} : { documents: call.documents }),
@@ -121,7 +126,7 @@ export function stageProviders(deps, context, pieceId) {
                     throw new Error(unusable);
                 }
                 return answer;
-            }, { kind: "llm", streaming: port.capabilities.streams }));
+            }, { kind: "llm", streaming: port.capabilities.streams })));
             return answered.then((result) => {
                 if (result.ok) {
                     const usage = result.value.usage;
@@ -172,7 +177,7 @@ export function stageProviders(deps, context, pieceId) {
                 }
             };
             const started = deps.clock.now().getTime();
-            const spoken = schedule(call.provider, () => attempt({ ...ctx, continuation }, async (signal, progress) => {
+            const spoken = learn({ provider: call.provider, family: "tts", model: call.model ?? "" }, schedule(call.provider, () => attempt({ ...ctx, continuation }, async (signal, progress) => {
                 notify({ type: "start" });
                 try {
                     if (call.dialogue !== undefined && port.capabilities.dialogue !== true)
@@ -220,7 +225,7 @@ export function stageProviders(deps, context, pieceId) {
                     notify({ type: "interrupted" });
                     throw error;
                 }
-            }, { kind: "tts", streaming: port.capabilities.streams }));
+            }, { kind: "tts", streaming: port.capabilities.streams })));
             return spoken.then((result) => {
                 // Narration is billed by the characters sent, which is the text of this call.
                 if (result.ok)
@@ -250,7 +255,7 @@ export function stageProviders(deps, context, pieceId) {
                 reset: true,
             });
             const started = deps.clock.now().getTime();
-            const drawn = schedule(call.provider, () => attempt(ctx, (signal) => port.generate({
+            const drawn = learn({ provider: call.provider, family: "image", model: call.model }, schedule(call.provider, () => attempt(ctx, (signal) => port.generate({
                 model: call.model,
                 prompt: call.prompt,
                 aspect: call.aspect,
@@ -265,7 +270,7 @@ export function stageProviders(deps, context, pieceId) {
             {
                 kind: "image",
                 ...(port.timeoutMs === undefined ? {} : { timeoutMs: port.timeoutMs }),
-            }));
+            })));
             return drawn.then((result) => {
                 if (result.ok) {
                     const { usage, limits } = result.value;
@@ -301,7 +306,7 @@ export function stageProviders(deps, context, pieceId) {
                     message: `${call.provider} can't turn images into video clips. Choose fal.ai or Replicate as the image provider in Edit project → Providers, or turn Animate images off in Edit project → Inputs → Look.`,
                 }));
             const started = deps.clock.now().getTime();
-            const animated = schedule(call.provider, () => attempt(ctx, (signal) => animate({
+            const animated = learn({ provider: call.provider, family: "image", model: call.model }, schedule(call.provider, () => attempt(ctx, (signal) => animate({
                 model: call.model,
                 prompt: call.prompt,
                 image: call.image,
@@ -310,7 +315,7 @@ export function stageProviders(deps, context, pieceId) {
                 signal,
             }), 
             // Queued and slow: the 900 s runs over the whole call, polling included.
-            { kind: "video" }));
+            { kind: "video" })));
             return animated.then((result) => {
                 if (result.ok)
                     meter({

package/dist/kernel/runner/standalone.js

@@ -1,9 +1,11 @@
+import { errorText } from "../errors.js";
 import { isProviderError } from "../ports/model.js";
 import { attempt } from "./attempt.js";
+import { observed } from "./model-access.js";
 export async function standaloneLlm(deps, call) {
     const port = deps.registry.llm(call.provider);
     const started = deps.clock.now().getTime();
-    const answer = await wrapped(deps, call, async (signal, progress) => {
+    const answer = await observed(deps.access, deps.log, { provider: call.provider, family: "llm", model: call.model }, wrapped(deps, call, async (signal, progress) => {
         let text = "";
         let usage = null;
         let limits;
@@ -24,7 +26,7 @@ export async function standaloneLlm(deps, call) {
             }
         }
         return { text, usage, ...(limits === undefined ? {} : { limits }) };
-    }, { kind: "llm", streaming: port.capabilities.streams });
+    }, { kind: "llm", streaming: port.capabilities.streams }));
     meter(deps, call, {
         kind: "llm",
         provider: call.provider,
@@ -38,12 +40,14 @@ export async function standaloneLlm(deps, call) {
 export async function standaloneImage(deps, call) {
     const port = deps.registry.image(call.provider);
     const started = deps.clock.now().getTime();
-    const image = await wrapped(deps, call, (signal) => port.generate({
+    const image = await observed(deps.access, deps.log, { provider: call.provider, family: "image", model: call.model }, wrapped(deps, call, (signal) => port.generate({
         model: call.model,
         prompt: call.prompt,
         aspect: call.aspect,
+        ...(call.edit === undefined ? {} : { edit: call.edit }),
+        ...(call.cast === undefined ? {} : { cast: call.cast }),
         signal,
-    }), { kind: "image", ...(port.timeoutMs === undefined ? {} : { timeoutMs: port.timeoutMs }) });
+    }), { kind: "image", ...(port.timeoutMs === undefined ? {} : { timeoutMs: port.timeoutMs }) }));
     meter(deps, call, {
         kind: "image",
         provider: call.provider,
@@ -128,7 +132,7 @@ function meter(deps, use, call) {
     }
     catch (error) {
         deps.log.write("warn", "usage.record", {
-            detail: `${use.purpose} for ${use.owner.kind} ${use.owner.id}: ${error instanceof Error ? error.message : String(error)}`,
+            detail: `${use.purpose} for ${use.owner.kind} ${use.owner.id}: ${errorText(error)}`,
         });
     }
 }