@gentbajko/slopify 3.25.8 → 4.0.0

package/dist/adapters/tts/elevenlabs.js

@@ -1,8 +1,9 @@
 import { z } from "zod";
 import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
-import { httpFailure, missingKey, noAudio, refreshList, unreadable, voiceFix } from "../explain.js";
-import { retryAfter } from "../retry-after.js";
+import { httpFailure, noAudio, refreshList, unreadable, voiceFix } from "../explain.js";
+import { failureText, httpProviderError, kindOfStatus, requireKey, safeJson, } from "../http-failure.js";
+import { modelAccessOf } from "../model-access.js";
 import { elevenLabsLanguages, lookUp } from "./voice-languages.js";
 // The HTTP gateway adapter for ElevenLabs: the platform's own `fetch` and nothing else. The
 // response body already is the `ReadableStream<Uint8Array>` the port asks for, so an SDK
@@ -99,52 +100,27 @@ export function elevenLabsTts(deps) {
     };
 }
 function keyOf(deps) {
-    const key = deps.key();
-    // `missing_key`, not `auth`, because that rule makes it terminal.
-    if (key === undefined || key === "") {
-        throw providerError({ kind: "missing_key", message: missingKey("ElevenLabs") });
-    }
-    return key;
-}
-// Only the adapter sees the vendor's status code, so only the adapter names the kind.
-function kindOf(status) {
-    if (status === 401 || status === 403) {
-        return "auth";
-    }
-    if (status === 429) {
-        return "rate_limit";
-    }
-    // ceiling: everything else is `other` and is retried, so a text past the character limit
-    // fails the same way four times over. A terminal "this will never work" kind has to reach the
-    // port's error contract first, which is not this adapter's to widen.
-    // The provider's own server failed; the same request may well succeed later.
-    if (status >= 500)
-        return "dropped";
-    return "other";
+    return requireKey(deps.key(), "ElevenLabs");
 }
 async function failure(response, voiceId, next) {
-    const text = await response.text().catch(() => "");
+    const text = await failureText(response);
     // The provider's own words, through the redactor - an error body may quote the key back.
     const message = redact(detailOf(text) || response.statusText);
-    const retryAfterMs = retryAfter(response.headers.get("retry-after"));
-    return providerError({
-        kind: kindOf(response.status),
-        // A rejected voice ID has to be named, and it is the one part of the
-        // request the user chose. It is not secret, unlike everything else on the wire.
-        message: httpFailure({
-            provider: "ElevenLabs",
-            status: response.status,
-            detail: message,
-            next,
-            ...(voiceId === undefined
-                ? {}
-                : {
-                    subject: `narration request for voice "${voiceId}"`,
-                    fix: voiceFix(voiceId),
-                }),
-        }),
-        ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
-    });
+    return httpProviderError(response, kindOfStatus(response.status), 
+    // A rejected voice ID has to be named, and it is the one part of the
+    // request the user chose. It is not secret, unlike everything else on the wire.
+    httpFailure({
+        provider: "ElevenLabs",
+        status: response.status,
+        detail: message,
+        next,
+        ...(voiceId === undefined
+            ? {}
+            : {
+                subject: `narration request for voice "${voiceId}"`,
+                fix: voiceFix(voiceId),
+            }),
+    }), undefined, modelAccessOf(response.status, text));
 }
 function detailOf(text) {
     const parsed = errorBody.safeParse(safeJson(text));
@@ -159,11 +135,3 @@ function detailOf(text) {
     // (`max_character_limit_exceeded`, `voice_not_found`) and the message is the sentence.
     return [detail.status, detail.message].filter((part) => part !== undefined).join(": ");
 }
-function safeJson(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/adapters/tts/gemini.js

@@ -1,8 +1,10 @@
 import { z } from "zod";
+import { internalError } from "../../kernel/errors.js";
 import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
-import { httpFailure, internalError, missingKey, noAudio, providerSaid, refreshList, unreadable, voiceFix, } from "../explain.js";
-import { retryAfter } from "../retry-after.js";
+import { httpFailure, noAudio, providerSaid, refreshList, unreadable, voiceFix, } from "../explain.js";
+import { failureText, httpProviderError, kindOfStatus, requireKey, safeJson, } from "../http-failure.js";
+import { modelAccessOf } from "../model-access.js";
 // The HTTP gateway adapter for Gemini's speech generation (generateContent with an AUDIO
 // response, https://ai.google.dev/gemini-api/docs/speech-generation), billed to a Gemini API
 // key. One voice is `speechConfig.voiceConfig`; a conversation of exactly two voices is
@@ -156,24 +158,10 @@ function streamOf(bytes) {
     });
 }
 function keyOf(deps) {
-    // `missing_key`, not `auth`, because that rule makes it terminal.
-    const key = deps.key();
-    if (key === undefined || key === "") {
-        throw providerError({ kind: "missing_key", message: missingKey("Google") });
-    }
-    return key;
-}
-function kindOf(status) {
-    if (status === 401 || status === 403)
-        return "auth";
-    if (status === 429)
-        return "rate_limit";
-    if (status >= 500)
-        return "dropped";
-    return "other";
+    return requireKey(deps.key(), "Google");
 }
 async function failure(response, voiceId, next) {
-    const text = await response.text().catch(() => "");
+    const text = await failureText(response);
     const parsed = errorBody.safeParse(safeJson(text));
     // Through the redactor: an error body may quote the key back.
     const detail = redact((parsed.success ? parsed.data.error.message : undefined) ??
@@ -181,26 +169,17 @@ async function failure(response, voiceId, next) {
     // Google answers an unknown key with 400 API_KEY_INVALID rather than 401.
     const badKey = response.status === 400 && text.includes("API_KEY_INVALID");
     const status = badKey ? 401 : response.status;
-    const retryAfterMs = retryAfter(response.headers.get("retry-after"));
-    return providerError({
-        kind: badKey ? "auth" : kindOf(response.status),
-        message: httpFailure({
-            provider: "Google",
-            status,
-            detail,
-            next,
-            ...(voiceId === undefined
-                ? {}
-                : { subject: `narration request for voice "${voiceId}"`, fix: voiceFix(voiceId) }),
-        }),
-        ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
-    });
-}
-function safeJson(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return undefined;
-    }
+    return httpProviderError(response, badKey ? "auth" : kindOfStatus(response.status), httpFailure({
+        provider: "Google",
+        status,
+        detail,
+        next,
+        ...(voiceId === undefined
+            ? {}
+            : { subject: `narration request for voice "${voiceId}"`, fix: voiceFix(voiceId) }),
+    }), undefined, 
+    // A narration request goes to the model's own address (models/<id>:generateContent).
+    badKey || voiceId === undefined
+        ? undefined
+        : modelAccessOf(response.status, `${parsed.success ? (parsed.data.error.status ?? "") : ""} ${detail}`, true));
 }

package/dist/adapters/tts/inworld-async.js

@@ -1,7 +1,9 @@
 import { z } from "zod";
+import { internalError } from "../../kernel/errors.js";
 import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
-import { httpFailure, internalError, noAudio, providerSaid, unreadable, voiceFix, } from "../explain.js";
+import { httpFailure, noAudio, providerSaid, unreadable, voiceFix } from "../explain.js";
+import { accessField } from "../model-access.js";
 import { retryAfter } from "../retry-after.js";
 const operationName = /^workspaces\/[A-Za-z0-9_-]+\/ttsAsyncJobs\/[A-Za-z0-9_-]+\/operations\/[A-Za-z0-9_-]+$/;
 const operationSchema = z.object({
@@ -137,6 +139,7 @@ async function check(response, key, voiceId) {
     const detail = clean(await response.text().catch(() => ""), key);
     const retryAfterMs = retryAfter(response.headers.get("retry-after"));
     throw providerError({
+        ...accessField(response.status, detail),
         kind: response.status === 401 || response.status === 403
             ? "auth"
             : response.status === 429

package/dist/adapters/tts/inworld.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
 import { httpFailure, missingKey, noAudio, unreadable, voiceFix } from "../explain.js";
+import { accessField } from "../model-access.js";
 import { retryAfter } from "../retry-after.js";
 import { inworldAsync, streamFailure } from "./inworld-async.js";
 import { inworldLanguages, lookUp } from "./voice-languages.js";
@@ -97,6 +98,7 @@ async function* synthesizeRequest(deps, request, key) {
         const detail = clean(await response.text().catch(() => ""), key);
         const retryAfterMs = retryAfter(response.headers.get("retry-after"));
         throw providerError({
+            ...accessField(response.status, detail),
             kind: response.status === 401 || response.status === 403
                 ? "auth"
                 : response.status === 429
@@ -134,6 +136,7 @@ async function* synthesizeRequest(deps, request, key) {
         if (parsed.data.error) {
             const { code, message } = parsed.data.error;
             throw providerError({
+                ...accessField(code === 5 ? 404 : code === 7 ? 403 : null, message ?? ""),
                 kind: code === 16 || code === 7
                     ? "auth"
                     : code === 8

package/dist/adapters/tts/openai.js

@@ -1,8 +1,9 @@
 import { z } from "zod";
 import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
-import { httpFailure, missingKey, noAudio, refreshList, unreadable, voiceFix } from "../explain.js";
-import { retryAfter } from "../retry-after.js";
+import { httpFailure, noAudio, refreshList, unreadable, voiceFix } from "../explain.js";
+import { failureText, httpProviderError, kindOfStatus, requireKey, safeJson, } from "../http-failure.js";
+import { modelAccessOf } from "../model-access.js";
 // The HTTP gateway adapter for OpenAI's speech endpoint. `fetch` and nothing else; the response
 // body is already the stream the port asks for.
 export const openAiAudioBase = "https://api.openai.com/v1";
@@ -79,58 +80,27 @@ function voiceOf(voiceId) {
     return customVoice.test(voiceId) ? { id: voiceId } : voiceId;
 }
 function keyOf(deps) {
-    const key = deps.key();
-    // An absent key is terminal, so it never becomes a request.
-    if (key === undefined || key === "") {
-        throw providerError({ kind: "missing_key", message: missingKey("OpenAI") });
-    }
-    return key;
-}
-function kindOf(status) {
-    if (status === 401 || status === 403) {
-        return "auth";
-    }
-    if (status === 429) {
-        return "rate_limit";
-    }
-    // ceiling: as in the OpenRouter adapter, a 400 is retried three more times because the
-    // port's error contract has no terminal kind for a request that cannot be repaired.
-    // The provider's own server failed; the same request may well succeed later.
-    if (status >= 500)
-        return "dropped";
-    return "other";
+    return requireKey(deps.key(), "OpenAI");
 }
 async function failure(response, voiceId, next) {
-    const text = await response.text().catch(() => "");
+    const text = await failureText(response);
     const parsed = errorBody.safeParse(safeJson(text));
     // Verbatim, through the same redactor the wrapper uses: OpenAI's own 401 quotes the
     // start of the key back at the caller.
     const message = redact(parsed.success ? parsed.data.error.message : text.trim() || response.statusText);
-    const retryAfterMs = retryAfter(response.headers.get("retry-after"));
-    return providerError({
-        kind: kindOf(response.status),
-        // The voice ID is named, so a rejected voice reads differently from
-        // a rejected key.
-        message: httpFailure({
-            provider: "OpenAI",
-            status: response.status,
-            detail: message,
-            next,
-            ...(voiceId === undefined
-                ? {}
-                : {
-                    subject: `narration request for voice "${voiceId}"`,
-                    fix: voiceFix(voiceId),
-                }),
-        }),
-        ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
-    });
-}
-function safeJson(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return undefined;
-    }
+    return httpProviderError(response, kindOfStatus(response.status), 
+    // The voice ID is named, so a rejected voice reads differently from
+    // a rejected key.
+    httpFailure({
+        provider: "OpenAI",
+        status: response.status,
+        detail: message,
+        next,
+        ...(voiceId === undefined
+            ? {}
+            : {
+                subject: `narration request for voice "${voiceId}"`,
+                fix: voiceFix(voiceId),
+            }),
+    }), undefined, modelAccessOf(response.status, text));
 }

package/dist/assets/models-lifecycle.yaml

@@ -0,0 +1,6 @@
+# When a model in models.yaml is due to retire, and what replaces it. Kept apart from
+# models.yaml on purpose: older Slopify versions read models.yaml with a strict schema, so a new
+# field there would break them. Each entry names a model by family, provider and id;
+# replacement (optional) is the id of a model of the same provider and family.
+schemaVersion: 1
+models: []

package/dist/assistant-wiring.js

@@ -0,0 +1,60 @@
+import { assistantCliRunner } from "./adapters/llm/assistant-cli.js";
+import { assistantClis, } from "./slices/assistant/model.js";
+import { createTurnTokens } from "./slices/assistant/tokens.js";
+import { createAssistant } from "./slices/assistant/turn.js";
+import { cliPathStatus } from "./slices/settings/cli-paths.js";
+import { cliProbeTimeoutMs, readinessFromProbe, } from "./slices/settings/cli-status.js";
+import { providerById } from "./slices/settings/model.js";
+// The in-app assistant wired to this computer's CLIs: which are installed and signed in (asked
+// at most once a minute, so opening the panel never waits on a probe twice), the CLI runner,
+// and this server's own address for `/mcp/assistant`.
+// ceiling: a CLI's state is kept a minute; signing in or installing one shows on the next
+// message after that.
+const statesTtlMs = 60_000;
+export function wireAssistant(deps) {
+    let cached;
+    const stateOf = async (cli) => {
+        const provider = providerById(cli);
+        if (provider.auth !== "cli")
+            return { installed: false, login: "unknown" };
+        const { command } = cliPathStatus(deps.db, cli);
+        const readiness = readinessFromProbe(await deps.probe(command, provider.versionArgs, cliProbeTimeoutMs), provider);
+        if (readiness.kind !== "cli" || !readiness.installed)
+            return { installed: false, login: "unknown" };
+        const login = await deps.readLogin(command, cli, AbortSignal.timeout(cliProbeTimeoutMs));
+        return { installed: true, login, issue: readiness.issue };
+    };
+    const clis = () => {
+        const now = deps.clock.now().valueOf();
+        if (cached === undefined || now - cached.at > statesTtlMs) {
+            const states = Promise.all(assistantClis.map(stateOf)).then(([claude, codex]) => ({
+                "claude-code": claude ?? { installed: false, login: "unknown" },
+                codex: codex ?? { installed: false, login: "unknown" },
+            }));
+            cached = { at: now, states };
+            states.catch(() => {
+                cached = undefined;
+            });
+        }
+        return cached.states;
+    };
+    return createAssistant({
+        db: deps.db,
+        ids: deps.ids,
+        clock: deps.clock,
+        log: deps.log,
+        emit: deps.emit,
+        runCli: assistantCliRunner(deps.spawn),
+        clis,
+        binaryOf: (cli) => cliPathStatus(deps.db, cli).command,
+        selfUrl: deps.selfUrl,
+        container: deps.container,
+        tokens: createTurnTokens(),
+    });
+}
+// The address the CLIs reach this server at: loopback when it listens on every address.
+export function assistantSelfUrl(host, port) {
+    const wildcard = host === "" || host === "0.0.0.0" || host === "::";
+    const reach = wildcard ? "127.0.0.1" : host;
+    return `http://${reach.includes(":") ? `[${reach}]` : reach}:${String(port)}`;
+}

package/dist/autopilot-timers.js

@@ -0,0 +1,59 @@
+import { diskSpaceAt, openRouterKeyLimit } from "./adapters/account-limits.js";
+import { causedBy } from "./kernel/errors.js";
+import { sendWeeklyReport } from "./slices/autopilot/notify.js";
+import { createAutopilotHealth } from "./slices/autopilot/signals.js";
+import { cliPathStatus } from "./slices/settings/cli-paths.js";
+import { keyOf } from "./slices/settings/repo.js";
+// ceiling: the first check waits for the server to settle after a start, then runs hourly; the
+// weekly report is looked at every quarter hour, so Monday 09:00 is met within 15 minutes.
+const firstCheckMs = 30_000;
+const checkEveryMs = 60 * 60_000;
+const weeklyEveryMs = 15 * 60_000;
+// Home's autopilot block reads the hourly check's answers; nothing here blocks a request.
+export function startAutopilot(deps) {
+    const health = createAutopilotHealth({
+        db: deps.db,
+        clock: deps.clock,
+        log: deps.log,
+        template: deps.template,
+        catalogue: deps.catalogue,
+        cliLogin: async (id, signal) => deps.hostCli === undefined
+            ? deps.readLogin(cliPathStatus(deps.db, id).command, id, signal)
+            : (await deps.hostCli.status(id)).login,
+        openRouterKey: async (signal) => {
+            const key = keyOf(deps.db, "openrouter");
+            return key === undefined ? null : openRouterKeyLimit(deps.fetch, key, signal);
+        },
+        disk: () => diskSpaceAt(deps.dataDir),
+    });
+    const check = () => {
+        health.refresh().catch((error) => {
+            deps.log.write("error", "autopilot.check", { detail: causedBy(error) });
+        });
+    };
+    const weekly = () => {
+        sendWeeklyReport({
+            db: deps.db,
+            clock: deps.clock,
+            send: deps.send,
+            log: deps.log,
+            timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        }).catch((error) => {
+            deps.log.write("error", "autopilot.weekly", { detail: causedBy(error) });
+        });
+    };
+    const first = setTimeout(() => {
+        check();
+        weekly();
+    }, firstCheckMs);
+    const checkTimer = setInterval(check, checkEveryMs);
+    const weeklyTimer = setInterval(weekly, weeklyEveryMs);
+    return {
+        latest: health.latest,
+        stop: () => {
+            clearTimeout(first);
+            clearInterval(checkTimer);
+            clearInterval(weeklyTimer);
+        },
+    };
+}

package/dist/catalog/lifecycle.js

@@ -0,0 +1,52 @@
+import { parse } from "yaml";
+import { z } from "zod";
+import { providerFamilies } from "../kernel/ports/model.js";
+// models-lifecycle.yaml: retirement dates and replacements for models in models.yaml. Rows
+// keep unknown keys out rather than refusing them, so a later version may add fields without
+// breaking this one.
+const lifecycleRow = z.object({
+    family: z.enum(providerFamilies),
+    provider: z.string().regex(/^[a-z0-9-]+$/),
+    id: z.string().min(1).max(200),
+    retiresOn: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+    replacement: z.string().min(1).max(200).optional(),
+});
+export const lifecycleSchema = z.object({
+    schemaVersion: z.literal(1),
+    models: z.array(lifecycleRow).max(500),
+});
+export const emptyLifecycle = { schemaVersion: 1, models: [] };
+export const lifecycleSource = "https://raw.githubusercontent.com/GentBajko/slopify/main/packages/app/src/assets/models-lifecycle.yaml";
+export function parseLifecycle(text) {
+    if (Buffer.byteLength(text) > 256 * 1024)
+        throw new Error("Model lifecycle exceeds 256 KB");
+    return lifecycleSchema.parse(parse(text, { maxAliasCount: 20, uniqueKeys: true }) ?? {});
+}
+function liveRow(catalogue, row, id) {
+    return catalogue[row.family].find((model) => model.provider === row.provider && model.id === id && model.enabled && !model.deprecated);
+}
+// A model due to retire, with its replacement when that one is live. A model already retired
+// in the catalogue (deprecated) is past this: the retired-models flow takes over.
+export function retirementOf(lifecycle, catalogue, model) {
+    const row = lifecycle.models.find((one) => one.family === model.family && one.provider === model.provider && one.id === model.model);
+    if (row === undefined)
+        return undefined;
+    const current = catalogue[row.family].find((one) => one.provider === row.provider && one.id === row.id);
+    if (current?.deprecated === true)
+        return undefined;
+    const next = row.replacement === undefined ? undefined : liveRow(catalogue, row, row.replacement);
+    return {
+        on: row.retiresOn,
+        replacement: next === undefined ? null : { id: next.id, name: next.name },
+    };
+}
+// The lifecycle's named replacement for a model, when it is live in the catalogue.
+export function lifecycleReplacement(lifecycle, catalogue, model) {
+    if (lifecycle === undefined)
+        return undefined;
+    const row = lifecycle.models.find((one) => one.family === model.family && one.provider === model.provider && one.id === model.model);
+    if (row?.replacement === undefined)
+        return undefined;
+    const next = liveRow(catalogue, row, row.replacement);
+    return next === undefined ? undefined : { id: next.id, name: next.name };
+}