@gentbajko/slopify 3.25.9 → 4.1.0

package/dist/adapters/tts/inworld.js

@@ -1,7 +1,9 @@
 import { z } from "zod";
 import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
+import { editSettings } from "../../kernel/ports/settings-places.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";
@@ -69,7 +71,7 @@ async function* synthesizeRequest(deps, request, key) {
     if (request.text.trim().length === 0)
         throw providerError({
             kind: "unsupported",
-            message: "Inworld was sent an empty piece of narration. Check the article has text in the Article section of Edit project, then use Try again.",
+            message: `Inworld was sent an empty piece of narration. Check the article has text in ${editSettings.article}, then use Try again.`,
         });
     if ((request.model ?? "inworld-tts-2") === "inworld-tts-2" && request.text.length > 4000) {
         yield* inworldAsync(deps, request, key);
@@ -78,7 +80,7 @@ async function* synthesizeRequest(deps, request, key) {
     if (request.text.length > 4000)
         throw providerError({
             kind: "unsupported",
-            message: "This narration part is longer than the 4,000 characters Inworld's Flash model takes at once. In the Providers section of Edit project, set Chunking to Paragraph or a smaller character count, or switch to the Realtime TTS-2 model.",
+            message: `This narration part is longer than the 4,000 characters Inworld's Flash model takes at once. In ${editSettings.narration}, set Chunking to Paragraph or a smaller character count, or switch to the Realtime TTS-2 voice model.`,
         });
     request.signal.throwIfAborted();
     const response = await deps.fetch("https://api.inworld.ai/tts/v1/voice:stream", {
@@ -97,6 +99,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 +137,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/adapters/tts/system.js

@@ -1,6 +1,7 @@
 import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { providerError } from "../../kernel/ports/model.js";
+import { editSettings } from "../../kernel/ports/settings-places.js";
 import { defaultSpeechVoice, noSpeechFix, primaryLanguage, } from "../../kernel/ports/system-speech.js";
 export const systemVoiceId = "system-voice";
 // Windows speaks through System.Speech. Every input arrives in an environment variable, so no
@@ -48,7 +49,7 @@ export function systemTts(deps) {
             kind: "unavailable",
             message: found.engines.length === 0
                 ? (found.issue ?? `No speech program was found on this computer, ${noSpeechFix}`)
-                : `The speech program "${model}" chosen for this narration isn't on this computer any more. In the Edit tab, choose Edit project and pick another System voice model (${found.engines.map((one) => one.name).join(", ")}) under Providers, then use Continue the run.`,
+                : `The speech program "${model}" chosen for this narration isn't on this computer any more. Pick another voice model (${found.engines.map((one) => one.name).join(", ")}) in ${editSettings.narration}, then use Continue the run.`,
         });
     };
     return {

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 };
+}

package/dist/catalog/propose.js

@@ -0,0 +1,204 @@
+// ceiling: a new OpenRouter model is proposed only from a vendor the list already carries,
+// only when it was published in the last 60 days, and at most 10 a day, so the PR stays
+// reviewable and the list stays curated.
+export const newWithinDays = 60;
+export const newPerRun = 10;
+const source = "https://openrouter.ai/api/v1/models";
+const perMillion = (perToken) => perToken === undefined ? undefined : Math.round(perToken * 1e6 * 1e6) / 1e6;
+function rateNote(today) {
+    return `Public OpenRouter rates read ${today}; routing, long context, reasoning and web search may add charges.`;
+}
+const reasoningThinking = {
+    low: { effort: "low" },
+    medium: { effort: "medium" },
+    high: { effort: "high" },
+};
+function refreshed(row, live, today) {
+    const input = perMillion(live.promptPerToken);
+    const output = perMillion(live.completionPerToken);
+    const cached = perMillion(live.cachedPerToken);
+    const priced = (input !== undefined && input !== row.pricing.inputPerMillionTokens) ||
+        (output !== undefined && output !== row.pricing.outputPerMillionTokens);
+    const pricing = priced
+        ? {
+            ...row.pricing,
+            ...(input === undefined ? {} : { inputPerMillionTokens: input }),
+            ...(output === undefined ? {} : { outputPerMillionTokens: output }),
+            ...(cached === undefined ? {} : { cachedInputPerMillionTokens: cached }),
+            note: rateNote(today),
+        }
+        : row.pricing;
+    const llm = {
+        ...row.llm,
+        ...(live.contextLength === undefined ? {} : { contextTokens: live.contextLength }),
+        ...(live.maxOutputTokens === undefined ? {} : { maxOutputTokens: live.maxOutputTokens }),
+        ...(row.llm.thinking === undefined && live.reasoning === true
+            ? { thinking: reasoningThinking }
+            : {}),
+    };
+    return { row: { ...row, pricing, llm }, priced };
+}
+function proposedRow(live, today) {
+    const input = perMillion(live.promptPerToken);
+    const output = perMillion(live.completionPerToken);
+    return {
+        provider: "openrouter",
+        id: live.id,
+        name: (live.name ?? live.id).slice(0, 120),
+        enabled: true,
+        deprecated: false,
+        source,
+        keywords: ["llm"],
+        pricing: {
+            ...(input === undefined ? {} : { inputPerMillionTokens: input }),
+            ...(output === undefined ? {} : { outputPerMillionTokens: output }),
+            note: rateNote(today),
+        },
+        llm: {
+            webSearch: false,
+            ...(live.contextLength === undefined ? {} : { contextTokens: live.contextLength }),
+            ...(live.maxOutputTokens === undefined ? {} : { maxOutputTokens: live.maxOutputTokens }),
+            ...(live.reasoning === true ? { thinking: reasoningThinking } : {}),
+        },
+    };
+}
+function isNew(live, vendors, today) {
+    if (live.id.includes(":"))
+        return false;
+    const vendor = live.id.split("/")[0] ?? "";
+    if (!vendors.has(vendor))
+        return false;
+    if (!(live.inputs ?? []).includes("text") || !(live.outputs ?? []).includes("text"))
+        return false;
+    if (live.outputs !== undefined && live.outputs.length !== 1)
+        return false;
+    if (live.promptPerToken === undefined || live.completionPerToken === undefined)
+        return false;
+    if (live.created === undefined)
+        return false;
+    const age = (Date.parse(`${today}T00:00:00Z`) - live.created * 1000) / 86_400_000;
+    return age >= 0 && age <= newWithinDays;
+}
+export function proposeCatalogue(current, sources) {
+    const live = new Map(sources.openRouter.map((row) => [row.id, row]));
+    const added = [];
+    const retired = [];
+    const priced = [];
+    // A model past its lifecycle date retires, and its entry has done its job.
+    const expired = current.lifecycle.models.filter((row) => row.retiresOn <= sources.today);
+    const expiredKey = new Set(expired.map((row) => `${row.family}:${row.provider}:${row.id}`));
+    const retire = (family, row, vanished) => {
+        if (row.deprecated)
+            return row;
+        if (!vanished && !expiredKey.has(`${family}:${row.provider}:${row.id}`))
+            return row;
+        retired.push(row.id);
+        return { ...row, deprecated: true };
+    };
+    const llm = current.catalogue.llm.map((row) => {
+        if (row.provider !== "openrouter")
+            return retire("llm", row, false);
+        const found = live.get(row.id);
+        // An empty listing is a failed read, never "everything retired".
+        const vanished = live.size > 0 && found === undefined;
+        const next = retire("llm", row, vanished);
+        if (found === undefined || next.deprecated)
+            return next;
+        const fresh = refreshed(next, found, sources.today);
+        if (fresh.priced)
+            priced.push(row.id);
+        return fresh.row;
+    });
+    const vendors = new Set(current.catalogue.llm
+        .filter((row) => row.provider === "openrouter")
+        .map((row) => row.id.split("/")[0] ?? ""));
+    const known = new Set(current.catalogue.llm.map((row) => `${row.provider}:${row.id}`));
+    const room = Math.max(0, 300 - llm.length);
+    const fresh = sources.openRouter
+        .filter((row) => !known.has(`openrouter:${row.id}`) && isNew(row, vendors, sources.today))
+        .sort((a, b) => (b.created ?? 0) - (a.created ?? 0))
+        .slice(0, Math.min(newPerRun, room))
+        .map((row) => proposedRow(row, sources.today));
+    for (const row of fresh)
+        added.push(row.id);
+    const image = current.catalogue.image.map((row) => retire("image", row, false));
+    const tts = current.catalogue.tts.map((row) => retire("tts", row, false));
+    const changed = added.length + retired.length + priced.length > 0;
+    const catalogue = {
+        ...current.catalogue,
+        updatedAt: changed ? sources.today : current.catalogue.updatedAt,
+        llm: [...llm, ...fresh],
+        image,
+        tts,
+    };
+    // Metadata (context, output limit, thinking) can change without a price change.
+    const metadataChanged = JSON.stringify(catalogue.llm) !== JSON.stringify(current.catalogue.llm);
+    const lifecycle = {
+        ...current.lifecycle,
+        models: current.lifecycle.models.filter((row) => row.retiresOn > sources.today),
+    };
+    return {
+        catalogue: metadataChanged && !changed ? { ...catalogue, updatedAt: sources.today } : catalogue,
+        lifecycle,
+        added,
+        retired,
+        priced,
+        changed: changed || metadataChanged || expired.length > 0,
+    };
+}
+// The PR's title and the script's last line: "Models: 3 new, 1 retired, 2 price changes".
+export function proposalSummary(proposal) {
+    const count = (n, one, many) => `${String(n)} ${n === 1 ? one : many}`;
+    return `Models: ${count(proposal.added.length, "new", "new")}, ${count(proposal.retired.length, "retired", "retired")}, ${count(proposal.priced.length, "price change", "price changes")}`;
+}
+// OpenRouter's full listing, read loosely: a row that does not read cleanly is skipped.
+export function readOpenRouterModels(value) {
+    const data = typeof value === "object" && value !== null ? value.data : undefined;
+    if (!Array.isArray(data))
+        return [];
+    const num = (raw) => {
+        const n = typeof raw === "string" || typeof raw === "number" ? Number(raw) : Number.NaN;
+        return Number.isFinite(n) && n >= 0 ? n : undefined;
+    };
+    const int = (raw) => {
+        const n = num(raw);
+        return n !== undefined && Number.isInteger(n) && n > 0 ? n : undefined;
+    };
+    const strings = (raw) => Array.isArray(raw) ? raw.filter((one) => typeof one === "string") : undefined;
+    const rows = [];
+    for (const raw of data) {
+        if (typeof raw !== "object" || raw === null)
+            continue;
+        const row = raw;
+        if (typeof row.id !== "string" || row.id === "" || row.id.length > 200)
+            continue;
+        const pricing = (typeof row.pricing === "object" && row.pricing !== null ? row.pricing : {});
+        const architecture = (typeof row.architecture === "object" && row.architecture !== null ? row.architecture : {});
+        const top = (typeof row.top_provider === "object" && row.top_provider !== null ? row.top_provider : {});
+        const params = strings(row.supported_parameters) ?? [];
+        rows.push({
+            id: row.id,
+            ...(typeof row.name === "string" && row.name !== "" ? { name: row.name } : {}),
+            ...(int(row.created) === undefined ? {} : { created: int(row.created) }),
+            ...(int(row.context_length) === undefined ? {} : { contextLength: int(row.context_length) }),
+            ...(int(top.max_completion_tokens) === undefined
+                ? {}
+                : { maxOutputTokens: int(top.max_completion_tokens) }),
+            ...(num(pricing.prompt) === undefined ? {} : { promptPerToken: num(pricing.prompt) }),
+            ...(num(pricing.completion) === undefined
+                ? {}
+                : { completionPerToken: num(pricing.completion) }),
+            ...(num(pricing.input_cache_read) === undefined
+                ? {}
+                : { cachedPerToken: num(pricing.input_cache_read) }),
+            ...(strings(architecture.input_modalities) === undefined
+                ? {}
+                : { inputs: strings(architecture.input_modalities) }),
+            ...(strings(architecture.output_modalities) === undefined
+                ? {}
+                : { outputs: strings(architecture.output_modalities) }),
+            reasoning: params.includes("reasoning"),
+        });
+    }
+    return rows;
+}