@vincemakes/kiso-runtime 0.52.0 → 0.54.0

package/dist/environment.d.ts

@@ -0,0 +1,34 @@
+/**
+ * A Work's added folders (ADR-0058 Amendment 19): one small file per session, `<id>.environment.json`.
+ *
+ * It is apart from `<id>.meta.json` on purpose: the sidecar's writers replace the whole file with no lock, and a rename in one
+ * process could write back a list read a moment earlier. This file has one writer, under its own short lock.
+ *
+ * The file tools read it on every call, so nothing holds a stale copy. It decides what the file tools may reach and nothing else:
+ * what the model has been told is the conversation's business, and authorisation never reads the conversation.
+ *
+ * A damaged file, or one of a version this kiso does not know, honours no added folder: the workspace keeps working.
+ */
+export declare const ENVIRONMENT_NOTE_HEAD = "Environment update from kiso (a fact about this session, not a request from the person)";
+/** The line a host puts before a person's next message after a change, kept out of the bubble and the title. Best effort. */
+export declare const isEnvironmentNote: (text: string) => boolean;
+/** A folder that cannot be added or removed, in words for the person. */
+export declare class EnvironmentRefusedError extends Error {
+    constructor(message: string);
+}
+export declare const environmentFile: (id: string) => string;
+export interface EnvironmentState {
+    readonly added: readonly string[];
+    /** the file is there and cannot be honoured; `added` is empty */
+    readonly damaged: boolean;
+}
+export declare function readEnvironment(root: string, id: string): EnvironmentState;
+/** Add `folder` to the Work. `primary` is where it started; `stops` are folders the new reach never enters. */
+export declare function addFolder(root: string, id: string, options: {
+    readonly primary: string;
+    readonly folder: string;
+    readonly stops: readonly string[];
+}): Promise<readonly string[]>;
+export declare function removeFolder(root: string, id: string, folder: string): Promise<readonly string[]>;
+/** A fork takes the parent's current list. */
+export declare function copyEnvironment(root: string, from: string, to: string): void;

package/dist/environment.js

@@ -0,0 +1,159 @@
+/**
+ * A Work's added folders (ADR-0058 Amendment 19): one small file per session, `<id>.environment.json`.
+ *
+ * It is apart from `<id>.meta.json` on purpose: the sidecar's writers replace the whole file with no lock, and a rename in one
+ * process could write back a list read a moment earlier. This file has one writer, under its own short lock.
+ *
+ * The file tools read it on every call, so nothing holds a stale copy. It decides what the file tools may reach and nothing else:
+ * what the model has been told is the conversation's business, and authorisation never reads the conversation.
+ *
+ * A damaged file, or one of a version this kiso does not know, honours no added folder: the workspace keeps working.
+ */
+import { closeSync, copyFileSync, existsSync, fsyncSync, openSync, readFileSync, realpathSync, renameSync, statSync, writeSync } from "node:fs";
+import { dirname, isAbsolute, join, relative } from "node:path";
+import { LockedError, nativeLockAdapter } from "./lock-adapter.js";
+const VERSION = 1;
+const LOCK_WAIT_MS = 2_000;
+export const ENVIRONMENT_NOTE_HEAD = "Environment update from kiso (a fact about this session, not a request from the person)";
+/** The line a host puts before a person's next message after a change, kept out of the bubble and the title. Best effort. */
+export const isEnvironmentNote = (text) => text.startsWith(ENVIRONMENT_NOTE_HEAD);
+/** A folder that cannot be added or removed, in words for the person. */
+export class EnvironmentRefusedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "EnvironmentRefusedError";
+    }
+}
+export const environmentFile = (id) => `${id}.environment.json`;
+export function readEnvironment(root, id) {
+    let raw;
+    try {
+        raw = readFileSync(join(root, environmentFile(id)), "utf8");
+    }
+    catch (err) {
+        return { added: [], damaged: err.code !== "ENOENT" };
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed.version !== VERSION || !Array.isArray(parsed.added) || !parsed.added.every((p) => typeof p === "string" && isAbsolute(p)))
+            return { added: [], damaged: true };
+        return { added: parsed.added, damaged: false };
+    }
+    catch {
+        return { added: [], damaged: true };
+    }
+}
+const within = (root, target) => {
+    const rel = relative(root, target);
+    return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+};
+/**
+ * The list's own lock: the session store's identity-confirmed link lock (ADR-0050), never taken from a live holder and released
+ * only by its owner. A dead holder is taken over by the adapter's rules; a live one is waited for briefly, then refused in words.
+ */
+async function withLock(path, id, work) {
+    const deadline = Date.now() + LOCK_WAIT_MS;
+    let handle;
+    for (;;) {
+        try {
+            handle = await nativeLockAdapter.acquire(`${path}.lock`, id, () => undefined);
+            break;
+        }
+        catch (err) {
+            if (!(err instanceof LockedError) || Date.now() > deadline) {
+                throw err instanceof LockedError ? new EnvironmentRefusedError("this Work's folders are being changed elsewhere: try again") : err;
+            }
+            await new Promise((r) => setTimeout(r, 20));
+        }
+    }
+    try {
+        if (!handle.verify())
+            throw new EnvironmentRefusedError("this Work's folders are being changed elsewhere: try again");
+        return work();
+    }
+    finally {
+        handle.release();
+    }
+}
+function replace(path, added) {
+    const tmp = `${path}.${process.pid}.tmp`;
+    const fd = openSync(tmp, "w", 0o600);
+    try {
+        writeSync(fd, `${JSON.stringify({ version: VERSION, added })}\n`);
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+    renameSync(tmp, path);
+    // the rename is the commit: from here a failure must not be reported as one. A platform whose directories cannot be opened or
+    // flushed (Windows) keeps the rename.
+    try {
+        const dir = openSync(dirname(path), "r");
+        try {
+            fsyncSync(dir);
+        }
+        finally {
+            closeSync(dir);
+        }
+    }
+    catch {
+        // the change stands
+    }
+}
+function update(root, id, change) {
+    const path = join(root, environmentFile(id));
+    return withLock(path, id, () => {
+        const now = readEnvironment(root, id);
+        if (now.damaged)
+            throw new EnvironmentRefusedError(`this Work's folder list cannot be read: remove ${path} to start it again`);
+        const next = change(now.added);
+        replace(path, next);
+        return next;
+    });
+}
+/** Add `folder` to the Work. `primary` is where it started; `stops` are folders the new reach never enters. */
+export async function addFolder(root, id, options) {
+    let real;
+    try {
+        real = realpathSync(options.folder);
+        if (!statSync(real).isDirectory())
+            throw new Error("not a directory");
+    }
+    catch {
+        throw new EnvironmentRefusedError(`${options.folder} is not a folder on this computer`);
+    }
+    const realOrSelf = (p) => {
+        try {
+            return realpathSync(p);
+        }
+        catch {
+            return p;
+        }
+    };
+    if (options.stops.map(realOrSelf).some((stop) => within(stop, real)))
+        throw new EnvironmentRefusedError(`${real} can't be added: the file tools do not reach this folder`);
+    const primary = realOrSelf(options.primary);
+    if (real === primary)
+        throw new EnvironmentRefusedError("this is already the Work's primary folder");
+    return update(root, id, (added) => {
+        if (added.includes(real))
+            throw new EnvironmentRefusedError("this folder is already in the Work");
+        if ([primary, ...added.map(realOrSelf)].some((r) => within(r, real) || within(real, r)))
+            throw new EnvironmentRefusedError("a folder inside, or containing, another of the Work's folders can't be added");
+        return [...added, real];
+    });
+}
+export async function removeFolder(root, id, folder) {
+    return update(root, id, (added) => {
+        if (!added.includes(folder))
+            throw new EnvironmentRefusedError("this folder is not in the Work");
+        return added.filter((p) => p !== folder);
+    });
+}
+/** A fork takes the parent's current list. */
+export function copyEnvironment(root, from, to) {
+    const source = join(root, environmentFile(from));
+    if (existsSync(source))
+        copyFileSync(source, join(root, environmentFile(to)));
+}

package/dist/fork.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A fork (owner 2026-11-03: one rule for the terminal, the web app and the products that embed kiso): a new session
+ * holding the conversation up to the end of one of the parent's runs, and nothing after it. It is the parent's local
+ * files under a new id: the log's lines up to that run's `terminal`, byte for byte (no line names its session and none
+ * chains to another), and a sidecar with the parent's execution profile, the name "… (fork)" and the fork's origin. Not
+ * carried: the lock and the background tasks, which belong to the parent's process, and the parent's summary, which may
+ * describe runs after the cut. The parent is only read; lines it appends meanwhile are after the cut. The sidecar is
+ * written first: the runtime reads a session's profile before its first event.
+ */
+import { type ForkOrigin } from "./profile.js";
+/** A fork the store will not make, said in words (the caller shows them). */
+export declare class ForkRefusedError extends Error {
+    constructor(message: string);
+}
+/** Fork `parent` in `root` after the run that ended at `afterSeq` (absent: the last finished run). */
+export declare function forkSession(root: string, parent: string, afterSeq?: number): {
+    readonly id: string;
+    readonly origin: ForkOrigin;
+};
+/** Whether a text block is the fork note (the apps show the person's words, never this). */
+export declare const isForkNote: (text: string) => boolean;
+/**
+ * What a fork's model is told, once, with the fork's first input after the copied history (never in the system prompt:
+ * a cache is a prefix, and a note there made the fork's first request read the whole history fresh, 0% against 88%
+ * measured on co, plan fork rev 2): what the conversation it continues does not bring with it.
+ */
+export declare const forkNote: (parentTitle: string) => string;

package/dist/fork.js

@@ -0,0 +1,86 @@
+/**
+ * A fork (owner 2026-11-03: one rule for the terminal, the web app and the products that embed kiso): a new session
+ * holding the conversation up to the end of one of the parent's runs, and nothing after it. It is the parent's local
+ * files under a new id: the log's lines up to that run's `terminal`, byte for byte (no line names its session and none
+ * chains to another), and a sidecar with the parent's execution profile, the name "… (fork)" and the fork's origin. Not
+ * carried: the lock and the background tasks, which belong to the parent's process, and the parent's summary, which may
+ * describe runs after the cut. The parent is only read; lines it appends meanwhile are after the cut. The sidecar is
+ * written first: the runtime reads a session's profile before its first event.
+ */
+import { copyEnvironment } from "./environment.js";
+import { closeSync, fsyncSync, openSync, readFileSync, renameSync, writeSync } from "node:fs";
+import { join } from "node:path";
+import { readSessionName, tenantsOf, writeForkSidecar } from "./profile.js";
+/** A fork the store will not make, said in words (the caller shows them). */
+export class ForkRefusedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ForkRefusedError";
+    }
+}
+/** The id a fork is given: the time to the second and four random characters, the way a session's id is made. */
+const newId = (now = new Date()) => `${now.toISOString().slice(0, 19).replace(/:/g, "-")}-${Math.floor(Math.random() * 0x10000).toString(16).padStart(4, "0")}`;
+/** Write a file whole or not at all: a temp file, its bytes synced, then renamed over the name. */
+function durable(path, bytes) {
+    const tmp = `${path}.fork-${process.pid}`;
+    const fd = openSync(tmp, "w", 0o600);
+    try {
+        writeSync(fd, bytes);
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+    renameSync(tmp, path);
+}
+/** Fork `parent` in `root` after the run that ended at `afterSeq` (absent: the last finished run). */
+export function forkSession(root, parent, afterSeq) {
+    let log;
+    try {
+        log = readFileSync(join(root, `${parent}.jsonl`));
+    }
+    catch {
+        throw new ForkRefusedError(`no session ${parent} to fork`);
+    }
+    // the lines, with where each ends, and the event each holds
+    const lines = [];
+    for (let from = 0; from < log.length;) {
+        const nl = log.indexOf(10, from);
+        if (nl < 0)
+            break; // a line still being written is after any cut
+        const event = JSON.parse(log.subarray(from, nl).toString("utf8")).event;
+        lines.push({ end: nl + 1, seq: event["seq"], type: event["type"], event });
+        from = nl + 1;
+    }
+    const cut = afterSeq === undefined ? [...lines].reverse().find((l) => l.type === "terminal") : lines.find((l) => l.seq === afterSeq);
+    if (cut === undefined)
+        throw new ForkRefusedError(afterSeq === undefined ? "this session has no finished run to fork from yet" : `no event ${afterSeq} in this session`);
+    if (cut.type !== "terminal")
+        throw new ForkRefusedError("a fork starts at the end of a run: pick a reply that finished");
+    const kept = lines.filter((l) => l.end <= cut.end);
+    // an execution still waiting for a verdict belongs to the world the parent ran in: settle it there first
+    const resolved = new Set(kept.filter((l) => l.type === "tool_execution_resolved").map((l) => l.event["executionId"]));
+    if (kept.some((l) => l.type === "uncertain_pending" && !resolved.has(l.event["executionId"])))
+        throw new ForkRefusedError("an action before this point is still waiting for your verdict in the original session: settle it there, then fork");
+    // its name, else its first line (only this log is read)
+    const first = kept.find((l) => l.type === "user_input")?.event;
+    const said = typeof first?.via?.line === "string" ? first.via.line : typeof first?.content === "string" ? first.content : Array.isArray(first?.content) ? first.content.map((p) => (typeof p.text === "string" ? p.text : "")).join(" ") : "";
+    const title = readSessionName(root, parent) ?? said.replace(/\s+/g, " ").trim().slice(0, 60);
+    const id = newId();
+    const origin = { session: parent, afterSeq: cut.seq, at: Date.now(), title };
+    writeForkSidecar(root, id, { profile: tenantsOf(root, parent)["profile"], name: `${(title || "Session").slice(0, 110)} (fork)`, forkedFrom: origin });
+    copyEnvironment(root, parent, id); // before the log: a fork that is listed has its folders
+    durable(join(root, `${id}.jsonl`), log.subarray(0, cut.end));
+    return { id, origin };
+}
+const FORK_NOTE_HEAD = 'This session was forked from the session "';
+/** Whether a text block is the fork note (the apps show the person's words, never this). */
+export const isForkNote = (text) => text.startsWith(FORK_NOTE_HEAD);
+/**
+ * What a fork's model is told, once, with the fork's first input after the copied history (never in the system prompt:
+ * a cache is a prefix, and a note there made the fork's first request read the whole history fresh, 0% against 88%
+ * measured on co, plan fork rev 2): what the conversation it continues does not bring with it.
+ */
+export const forkNote = (parentTitle) => `${FORK_NOTE_HEAD}${parentTitle}" at the end of one of its runs. The conversation above it is copied; two things are not. ` +
+    "Background tasks started there are not running here (a task id from that conversation names nothing in this session). " +
+    "The folder is shared with it: its files are as they are on disk now, not as they were when the run above ended, and the original session may still change them.";

package/dist/index.d.ts

@@ -21,13 +21,17 @@
 export { AgentRuntime, AgentRuntime as Agent, createAgent } from "./agent.js";
 export type { AgentDefinition, PermissionPolicy, PermissionRule } from "./agent.js";
 export { AgentSession, AgentSession as Session } from "./session.js";
-export type { SideQueryOptions } from "./session.js";
+export type { FollowUpOptions, SideQueryOptions } from "./session.js";
 export { PoisonedSessionError, ResumeBlockedError } from "./session.js";
 export type { ApprovalRequest, CompactInfo, ContextPolicy, SessionConfig, SummarizeResult } from "./session.js";
 export { DEFAULT_CHECKPOINT_SECTIONS } from "./summarize.js";
 export type { CheckpointSection } from "./summarize.js";
 export { Run, RunClosedError } from "./run.js";
 export { SessionStore, StaleWriterError, StoreCorruptionError } from "./store.js";
+export { ForkRefusedError } from "./fork.js";
+export { addFolder, EnvironmentRefusedError, isEnvironmentNote, readEnvironment, removeFolder } from "./environment.js";
+export type { EnvironmentState } from "./environment.js";
+export type { ForkOrigin } from "./profile.js";
 export type { Event, SessionMeta, StoreRecord } from "./store.js";
 export { disposeExtensions, loadExtensions, loadProjectExtensions } from "./extensions.js";
 export type { KisoExtension } from "./extensions.js";

package/dist/index.js

@@ -29,6 +29,8 @@ export { DEFAULT_CHECKPOINT_SECTIONS } from "./summarize.js";
 export { Run, RunClosedError } from "./run.js";
 // store
 export { SessionStore, StaleWriterError, StoreCorruptionError } from "./store.js";
+export { ForkRefusedError } from "./fork.js";
+export { addFolder, EnvironmentRefusedError, isEnvironmentNote, readEnvironment, removeFolder } from "./environment.js";
 // extensions
 export { disposeExtensions, loadExtensions, loadProjectExtensions } from "./extensions.js";
 // tasks (ADR-0058): a host that wires background tasks needs the manager

package/dist/internal.d.ts

@@ -29,7 +29,8 @@ export { canonicalizeUsageForModel } from "./usage/canonical.js";
 export { BUILTIN_MANIFESTS, resolveContinuationScope, type ModelRef, type ProviderManifest } from "./provider/manifest.js";
 export * from "./checkpoint.js";
 export * from "./request-budget.js";
-export { readProfile, readSessionName, readSummary, writeSessionName, writeSummary, type ExecutionProfile, type ProfileReadResult } from "./profile.js";
+export { isForkNote } from "./fork.js";
+export { readForkOrigin, readProfile, readSessionName, readSummary, writeSessionName, writeSummary, type ExecutionProfile, type ProfileReadResult } from "./profile.js";
 export { SUMMARY_MIGRATION_MARKER, listSessionSidecars, migrateSummaries, sessionSummary, summarizeEvents, summaryMigrationPending, type SessionListing, type SessionSummary } from "./session-summary.js";
 export * from "./tasks/journal.js";
 export * from "./tasks/manager.js";

package/dist/internal.js

@@ -38,7 +38,8 @@ export { BUILTIN_MANIFESTS, resolveContinuationScope } from "./provider/manifest
 export * from "./checkpoint.js";
 export * from "./request-budget.js";
 // 0.40.0: the listing reads the recorded workspace and profile name.
-export { readProfile, readSessionName, readSummary, writeSessionName, writeSummary } from "./profile.js";
+export { isForkNote } from "./fork.js";
+export { readForkOrigin, readProfile, readSessionName, readSummary, writeSessionName, writeSummary } from "./profile.js";
 export { SUMMARY_MIGRATION_MARKER, listSessionSidecars, migrateSummaries, sessionSummary, summarizeEvents, summaryMigrationPending } from "./session-summary.js";
 // ADR-0058 §6: the task journal and the TaskManager (internal until the
 // public shape is proven by the shell and delegate steps)

package/dist/profile.d.ts

@@ -94,6 +94,25 @@ export declare function readSessionName(root: string, sessionId: string): string
 /** Name the session, or clear its name (`null`). Atomic and fail-closed
  *  like every tenant's write; the others' bytes ride through. */
 export declare function writeSessionName(root: string, sessionId: string, name: string | null): void;
+/** Where a fork came from (SessionStore.fork): the parent session, the seq of the parent's `terminal` it was cut after,
+ *  when, and the parent's title then. The sidecar's fourth tenant; lineage, not authority. */
+export interface ForkOrigin {
+    readonly session: string;
+    readonly afterSeq: number;
+    readonly at: number;
+    readonly title: string;
+}
+/** The fork's origin, or null (not a fork, no sidecar, unreadable). */
+export declare function readForkOrigin(root: string, sessionId: string): ForkOrigin | null;
+/** A new fork's sidecar, whole: the parent's execution profile, the fork's name, and its origin. The parent's summary is
+ *  not carried: it may describe runs after the cut, and the fork writes its own. */
+export declare function writeForkSidecar(root: string, sessionId: string, tenants: {
+    readonly profile?: unknown;
+    readonly name: string;
+    readonly forkedFrom: ForkOrigin;
+}): void;
+/** The parent's tenants, read for a fork. */
+export declare function tenantsOf(root: string, sessionId: string): Record<string, unknown>;
 export type ProfileReadResult = {
     readonly kind: "ok";
     readonly profile: ExecutionProfile;

package/dist/profile.js

@@ -98,6 +98,20 @@ export function writeSessionName(root, sessionId, name) {
     delete tenants.name;
     writeTenants(root, sessionId, name === null ? tenants : { ...tenants, name });
 }
+/** The fork's origin, or null (not a fork, no sidecar, unreadable). */
+export function readForkOrigin(root, sessionId) {
+    const f = currentTenants(root, sessionId).forkedFrom;
+    return f !== undefined && typeof f.session === "string" && typeof f.afterSeq === "number" && typeof f.at === "number" && typeof f.title === "string" ? f : null;
+}
+/** A new fork's sidecar, whole: the parent's execution profile, the fork's name, and its origin. The parent's summary is
+ *  not carried: it may describe runs after the cut, and the fork writes its own. */
+export function writeForkSidecar(root, sessionId, tenants) {
+    writeTenants(root, sessionId, { ...(tenants.profile !== undefined ? { profile: tenants.profile } : {}), name: tenants.name, forkedFrom: tenants.forkedFrom });
+}
+/** The parent's tenants, read for a fork. */
+export function tenantsOf(root, sessionId) {
+    return currentTenants(root, sessionId);
+}
 function writeTenants(root, sessionId, tenants) {
     const path = profilePath(root, sessionId);
     const tmpDir = mkdtempSync(join(root, ".meta-"));

package/dist/provider/metadata.d.ts

@@ -185,6 +185,11 @@ export interface ResolvedContextWindow {
  * facts about a route and stay on lookupModelMetadata.
  */
 export declare function lookupContextWindow(model: string, endpoint?: string, upstream?: string): ResolvedContextWindow | null;
+/**
+ * What a model takes in (owner, 2026-11-11): the table's row for this route when it says, else the release snapshot for the
+ * model's weights (whether a model reads pictures belongs to the weights), else null, unknown. A host decides what unknown means.
+ */
+export declare function lookupInputModalities(model: string, endpoint?: string): readonly string[] | null;
 /**
  * XP-1 §4.2 — native-only resolution. The rules, in order:
  *   default/default → NO wire fields (the byte-identity anchor — a

package/dist/provider/metadata.js

@@ -19,6 +19,7 @@
  * does not move; core is untouched.
  */
 import { OPENROUTER_ROWS } from "./openrouter-rows.js";
+import { MODEL_SNAPSHOT, MODEL_SNAPSHOT_AS_OF } from "./model-snapshot.js";
 /**
  * REG-1 — the OFF-PEAK rates, read from the vendor's pricing table on
  * 2026-09-17. The table carries TWO sets: off-peak and peak, the peak
@@ -632,14 +633,47 @@ export function lookupContextWindow(model, endpoint, upstream) {
     }
     const identity = modelIdentity(model);
     let found = null;
+    let rowed = route !== null;
     for (const entry of ENTRIES) {
         const tokens = entry.capabilities.contextWindow;
-        if (tokens === null || modelIdentity(entry.model) !== identity)
+        if (modelIdentity(entry.model) !== identity)
+            continue;
+        rowed = true;
+        if (tokens === null)
             continue;
         if (found === null || tokens < found.tokens)
             found = { tokens, source: "model", from: entry.model };
     }
-    return found;
+    if (found !== null || rowed)
+        return found; // a row that states no window lends none (CW-1): the snapshot does not overrule it
+    // last, for a model the table has no row for at all: the release's snapshot (kiso.work), by the same identity
+    const snap = snapshotOf(model);
+    return snap?.window != null ? { tokens: snap.window, source: "model", from: `${snap.key} (kiso.work, ${MODEL_SNAPSHOT_AS_OF})` } : null;
+}
+let dashed = null;
+/** The release snapshot's row for a model: by its folded name, by the weights it names (an alias), by a name that names the
+ *  same weights, and with dots and dashes read alike (`claude-fable-5.2` is the vendor's `claude-fable-5-2`). */
+function snapshotOf(model) {
+    const folded = model.slice(model.lastIndexOf("/") + 1).toLowerCase();
+    const identity = modelIdentity(model);
+    const names = [folded, identity, ...Object.entries(MODEL_ALIASES).filter(([, a]) => a.is === identity).map(([n]) => n)];
+    for (const n of names)
+        if (MODEL_SNAPSHOT[n] !== undefined)
+            return { key: n, ...MODEL_SNAPSHOT[n] };
+    dashed ??= new Map(Object.keys(MODEL_SNAPSHOT).map((k) => [k.replace(/\./g, "-"), k]));
+    for (const n of names) {
+        const k = dashed.get(n.replace(/\./g, "-"));
+        if (k !== undefined)
+            return { key: k, ...MODEL_SNAPSHOT[k] };
+    }
+    return null;
+}
+/**
+ * What a model takes in (owner, 2026-11-11): the table's row for this route when it says, else the release snapshot for the
+ * model's weights (whether a model reads pictures belongs to the weights), else null, unknown. A host decides what unknown means.
+ */
+export function lookupInputModalities(model, endpoint) {
+    return lookupModelMetadata(model, endpoint)?.capabilities.inputModalities ?? snapshotOf(model)?.input ?? null;
 }
 function originOf(endpoint) {
     try {

package/dist/provider/model-snapshot.d.ts

@@ -0,0 +1,11 @@
+/**
+ * GENERATED by scripts/model-snapshot.mjs from https://kiso.work/models/all.json (as of 2026-11-11).
+ * Do not edit by hand: a release runs the script and commits the diff.
+ */
+export declare const MODEL_SNAPSHOT_AS_OF = "2026-11-11";
+export declare const MODEL_SNAPSHOT_SOURCE = "https://kiso.work/models/all.json";
+/** Keyed by the model's name with its vendor prefix off, in lower case. */
+export declare const MODEL_SNAPSHOT: Readonly<Record<string, {
+    readonly input: readonly string[] | null;
+    readonly window: number | null;
+}>>;