@fugood/buttress-server 2.26.0-beta.3 → 2.26.0-beta.30

package/lib/protocol-WkPByalT.mjs

@@ -0,0 +1,468 @@
+#!/usr/bin/env node
+const e=256*1024,t=1024*1024,n=16*1024*1024,r=1e5,i=`image expects a non-empty image URL string, an object with image_url, or a raw MCP image block`,a=`(function (bridge, toolsJson, globalsJson, storeJson) {
+	"use strict";
+
+	// Freeze every object reachable from the built-in globals, plus the intrinsics that are only
+	// reachable from instances (iterator and generator prototypes, %TypedArray%).
+	//
+	// Freezing alone breaks ordinary code through the "override mistake": a data property that is
+	// read-only on a prototype cannot be assigned on an instance either, so
+	// this.name = "MyError" in an Error subclass would throw. Commonly overridden properties
+	// become accessors whose setter defines an own property on the instance instead.
+	(function lockdown() {
+		const OVERRIDABLE = new Set(["constructor", "name", "message", "toString", "toLocaleString", "valueOf", "toJSON"]);
+		const seen = new Set([globalThis]);
+		const queue = [];
+		const add = (value) => {
+			if ((typeof value === "object" && value !== null) || typeof value === "function") {
+				if (!seen.has(value)) {
+					seen.add(value);
+					queue.push(value);
+				}
+			}
+		};
+
+		// Accessors from an object literal have no own prototype object, unlike function expressions,
+		// whose prototype.constructor would be converted again without end.
+		function allowOverride(object, key, value, enumerable) {
+			const { get, set } = Object.getOwnPropertyDescriptor(
+				{
+					get accessor() {
+						return value;
+					},
+					set accessor(next) {
+						if (this === object) {
+							throw new TypeError("Cannot assign to read only property '" + String(key) + "' of a built-in");
+						}
+						if ((typeof this !== "object" || this === null) && typeof this !== "function") return;
+						Object.defineProperty(this, key, { value: next, writable: true, enumerable: true, configurable: true });
+					},
+				},
+				"accessor",
+			);
+			Object.defineProperty(object, key, { get, set, enumerable, configurable: false });
+			add(get);
+			add(set);
+		}
+
+		for (const key of Reflect.ownKeys(globalThis)) {
+			const descriptor = Object.getOwnPropertyDescriptor(globalThis, key);
+			add(descriptor.value);
+			add(descriptor.get);
+			add(descriptor.set);
+			if ("value" in descriptor && descriptor.configurable) {
+				Object.defineProperty(globalThis, key, { writable: false, configurable: false });
+			}
+		}
+		add(Object.getPrototypeOf(function* () {}));
+		add(Object.getPrototypeOf(async function () {}));
+		add(Object.getPrototypeOf(async function* () {}));
+		add(Object.getPrototypeOf(Int8Array));
+		add(Object.getPrototypeOf([][Symbol.iterator]()));
+		add(Object.getPrototypeOf(new Map()[Symbol.iterator]()));
+		add(Object.getPrototypeOf(new Set()[Symbol.iterator]()));
+		add(Object.getPrototypeOf(""[Symbol.iterator]()));
+		add(Object.getPrototypeOf(/a/[Symbol.matchAll]("")));
+		if (typeof Iterator === "function") {
+			if (typeof Iterator.prototype.map === "function") add(Object.getPrototypeOf([].values().map((x) => x)));
+			if (typeof Iterator.from === "function") add(Object.getPrototypeOf(Iterator.from({ next() {} })));
+		}
+
+		while (queue.length > 0) {
+			const object = queue.pop();
+			add(Object.getPrototypeOf(object));
+			const descriptors = Object.getOwnPropertyDescriptors(object);
+			for (const key of Reflect.ownKeys(descriptors)) {
+				const descriptor = descriptors[key];
+				if ("value" in descriptor) {
+					add(descriptor.value);
+					if (
+						descriptor.writable &&
+						descriptor.configurable &&
+						(object === Object.prototype || OVERRIDABLE.has(key))
+					) {
+						allowOverride(object, key, descriptor.value, descriptor.enumerable);
+					}
+				} else {
+					add(descriptor.get);
+					add(descriptor.set);
+				}
+			}
+			Object.freeze(object);
+		}
+	})();
+	const stringify = JSON.stringify;
+	const parse = JSON.parse;
+	const promiseThen = Promise.prototype.then;
+	const ErrorCtor = Error;
+	const TypeErrorCtor = TypeError;
+	const RangeErrorCtor = RangeError;
+	const pending = new Map();
+	let nextId = 1;
+	let finished = false;
+	// Thrown by exit() to unwind the script after it already reported success.
+	const EXIT = Object.freeze({});
+
+	function done(ok, payload, writes) {
+		if (finished) return;
+		finished = true;
+		bridge("done", ok, payload, writes);
+	}
+
+	function serialize(value) {
+		return value === undefined ? undefined : stringify(value);
+	}
+
+	// QuickJS stacks list frames only. Prefix "Name: message" like V8 so the
+	// text reads the same as a Node error, and drop this prelude's frames.
+	function errorText(error) {
+		const head = error.message ? error.name + ": " + error.message : String(error.name);
+		const frames =
+			typeof error.stack === "string"
+				? error.stack.split("\\n").filter((line) => line.trim() && !line.includes("codemode-prelude.js"))
+				: [];
+		return [head, ...frames].join("\\n");
+	}
+
+	function format(value) {
+		if (typeof value === "string") return value;
+		if (value instanceof ErrorCtor) return errorText(value);
+		try {
+			const json = stringify(value);
+			return json === undefined ? String(value) : json;
+		} catch {
+			return String(value);
+		}
+	}
+
+	// The host requires string fields. A script can set an error's name or message to anything, so
+	// they are coerced, and a value whose coercion throws gets a placeholder.
+	function describeError(error) {
+		try {
+			if (error instanceof ErrorCtor) {
+				return stringify({ name: String(error.name), message: String(error.message), stack: errorText(error) });
+			}
+			return stringify({ message: String(format(error)) });
+		} catch {
+			return stringify({ message: "The script threw a value that cannot be described" });
+		}
+	}
+
+	function caller(kind, name, spread) {
+		return (...args) =>
+			new Promise((resolve, reject) => {
+				let json;
+				try {
+					json = serialize(spread ? args : args[0]);
+				} catch (error) {
+					reject(error);
+					return;
+				}
+				const id = nextId++;
+				pending.set(id, { resolve, reject });
+				bridge(kind, id, name, json);
+			});
+	}
+
+	const tools = Object.create(null);
+	const allTools = [];
+	for (const { name, jsName, description } of parse(toolsJson)) {
+		const fn = caller("call", name);
+		// The first tool wins when two names normalize to the same identifier.
+		if (!(jsName in tools)) {
+			tools[jsName] = fn;
+			allTools.push(Object.freeze({ name: jsName, description }));
+		}
+		if (!(name in tools)) tools[name] = fn;
+	}
+	Object.freeze(tools);
+	Object.freeze(allTools);
+
+	// Reading a member that does not exist throws an error that names the close matches, instead of
+	// a later "not a function". \`in\` checks still work.
+	const comparable = (name) => name.toLowerCase().replace(/[^a-z0-9]/g, "");
+	function guard(target, label, names, hint) {
+		return new Proxy(target, {
+			get(object, property, receiver) {
+				if (typeof property !== "string" || property in object || property in Object.prototype || property === "then" || property === "toJSON") {
+					return Reflect.get(object, property, receiver);
+				}
+				const wanted = comparable(property);
+				const exact = names.filter((name) => comparable(name) === wanted);
+				const close = exact.length > 0 ? exact : names.filter((name) => wanted && (comparable(name).includes(wanted) || wanted.includes(comparable(name))));
+				let message = label + "." + property + " does not exist.";
+				if (close.length > 0) message += " Did you mean " + close.slice(0, 5).map((name) => label + "." + name).join(", ") + "?";
+				else if (names.length <= 20) message += " Available: " + names.join(", ") + ".";
+				if (hint) message += " " + hint;
+				message += ' Check for a member with "' + property + '" in ' + label + ".";
+				throw new TypeErrorCtor(message);
+			},
+		});
+	}
+	const toolsProxy = guard(
+		tools,
+		"tools",
+		allTools.map((tool) => tool.name),
+		"ALL_TOOLS lists every tool; searchTools(query) finds tools by topic.",
+	);
+
+	const namespaces = new Map();
+	for (const { name, spread } of parse(globalsJson)) {
+		const fn = caller("global", name, spread);
+		const dot = name.indexOf(".");
+		if (dot === -1) {
+			Object.defineProperty(globalThis, name, { value: fn, enumerable: true });
+			continue;
+		}
+		const namespace = name.slice(0, dot);
+		if (!namespaces.has(namespace)) namespaces.set(namespace, Object.create(null));
+		namespaces.get(namespace)[name.slice(dot + 1)] = fn;
+	}
+	for (const [namespace, members] of namespaces) {
+		Object.freeze(members);
+		const value = guard(members, namespace, Object.keys(members));
+		Object.defineProperty(globalThis, namespace, { value, enumerable: true });
+	}
+
+	// key -> JSON text. Sizes count key and JSON characters.
+	const stored = new Map(Object.entries(parse(storeJson)));
+	const writes = new Map();
+	let storedChars = 0;
+	for (const [key, json] of stored) storedChars += key.length + json.length;
+
+	const STORE_HINT =
+		"store() is for small state such as IDs or summaries. Show images with image(), keep large data in variables, or write it to a file with a tool.";
+
+	function checkKey(name, key) {
+		if (typeof key !== "string") throw new TypeError(name + "() key must be a string");
+	}
+
+	function store(key, value) {
+		checkKey("store", key);
+		const previous = stored.has(key) ? key.length + stored.get(key).length : 0;
+		if (value === undefined) {
+			stored.delete(key);
+			storedChars -= previous;
+			writes.set(key, undefined);
+			return;
+		}
+		let json;
+		try {
+			json = stringify(value);
+		} catch (error) {
+			throw new TypeError("store(" + stringify(key) + ") value is not JSON-serializable: " + format(error));
+		}
+		if (json === undefined) {
+			throw new TypeError("store(" + stringify(key) + ") value is not JSON-serializable");
+		}
+		if (json.length > ${e}) {
+			throw new RangeError(
+				"store(" + stringify(key) + ") value has " + json.length + " characters of JSON, more than the limit of ${e}. " +
+					STORE_HINT,
+			);
+		}
+		const next = storedChars - previous + key.length + json.length;
+		if (next > ${t}) {
+			throw new RangeError(
+				"store is full: stored values would exceed ${t} characters of JSON. Delete keys with store(key, undefined). " +
+					STORE_HINT,
+			);
+		}
+		stored.set(key, json);
+		storedChars = next;
+		writes.set(key, json);
+	}
+
+	function load(key) {
+		checkKey("load", key);
+		const json = stored.get(key);
+		return json === undefined ? undefined : parse(json);
+	}
+
+	function serializeWrites() {
+		const entries = [];
+		for (const [key, json] of writes) entries.push(json === undefined ? [key] : [key, json]);
+		return stringify(entries);
+	}
+
+	Object.defineProperty(globalThis, "store", { value: store, enumerable: true });
+	Object.defineProperty(globalThis, "load", { value: load, enumerable: true });
+
+	let outputChars = 0;
+	let outputItems = 0;
+
+	// Past the output limits the script fails: done() reports the error, so catching it does not
+	// resume output, and the host ends the script.
+	function output(kind, data, mimeType) {
+		if (finished) return;
+		outputChars += data.length;
+		outputItems++;
+		if (outputChars > ${n} || outputItems > ${r}) {
+			const error = new RangeErrorCtor(
+				"script output exceeded the limit of ${n} characters or ${r} text(), image(), and console calls. " +
+					"Print a summary instead, or write large data to a file with a tool.",
+			);
+			done(false, describeError(error));
+			throw error;
+		}
+		bridge("output", kind, data, mimeType);
+	}
+
+	// Primitives become their string form, everything else JSON.
+	function outputText(value) {
+		if (value === undefined || value === null || typeof value !== "object" && typeof value !== "function") {
+			return String(value);
+		}
+		const json = stringify(value);
+		return json === undefined ? String(value) : json;
+	}
+
+	function text(value) {
+		let rendered;
+		try {
+			rendered = outputText(value);
+		} catch (error) {
+			throw new TypeErrorCtor(error instanceof ErrorCtor ? error.message : String(error));
+		}
+		output("text", rendered);
+	}
+
+	function imageUrl(value) {
+		if (typeof value === "string") return value;
+		if (typeof value !== "object" || value === null || Array.isArray(value)) {
+			throw new TypeErrorCtor(${JSON.stringify(i)});
+		}
+		if (value.image_url !== undefined) {
+			if (typeof value.image_url !== "string") throw new TypeErrorCtor(${JSON.stringify(i)});
+			return value.image_url;
+		}
+		if (typeof value.type !== "string") throw new TypeErrorCtor(${JSON.stringify(i)});
+		if (value.type !== "image") {
+			throw new TypeErrorCtor('image only accepts MCP image blocks, got "' + value.type + '"');
+		}
+		if (typeof value.data !== "string" || value.data === "") throw new TypeErrorCtor("image expected MCP image data");
+		if (value.data.toLowerCase().startsWith("data:")) return value.data;
+		return "data:;base64," + value.data;
+	}
+
+	// Base64 of the signatures of the formats providers accept inline (PNG, JPEG except
+	// JPEG-LS, GIF, "RIFF....WEBP"). Signatures start at byte 0, so their encodings are prefixes.
+	const IMAGE_SIGNATURES = [
+		["image/png", /^iVBORw0KGg/],
+		["image/jpeg", /^[/]9j[/](?!9)/],
+		["image/gif", /^R0lGOD[dl]h/],
+		["image/webp", /^UklG.{8}RUJQ/],
+	];
+
+	function image(value) {
+		const url = imageUrl(value);
+		if (url === "") throw new TypeErrorCtor(${JSON.stringify(i)});
+		const colon = url.indexOf(":");
+		const scheme = colon === -1 ? "" : url.slice(0, colon).toLowerCase();
+		if (scheme === "http" || scheme === "https") {
+			throw new TypeErrorCtor("remote image URLs are not supported in tool outputs. Pass a base64 data URI instead");
+		}
+		const comma = url.indexOf(",");
+		const header = comma === -1 ? [] : url.slice(colon + 1, comma).split(";");
+		if (scheme !== "data" || comma === -1 || header.slice(1).every((part) => part.toLowerCase() !== "base64")) {
+			throw new TypeErrorCtor("invalid image output. Pass a base64 data URI instead");
+		}
+		// Providers reject the whole request on a bad image, and a persisted image block would be
+		// resent on every later turn. Line breaks from wrapped base64 are dropped. The declared type
+		// is ignored in favor of the detected one, as providers also reject mismatches.
+		const data = url.slice(comma + 1).replace(/\\s+/g, "");
+		if (data.length % 4 !== 0 || !/^[A-Za-z0-9+/]+={0,2}$/.test(data)) {
+			throw new TypeErrorCtor("invalid image output. The image data is not valid base64 (truncated or corrupted?)");
+		}
+		const head = data.slice(0, 16);
+		const signature = IMAGE_SIGNATURES.find(([, pattern]) => pattern.test(head));
+		if (!signature) {
+			throw new TypeErrorCtor("invalid image output. The image data is not a PNG, JPEG, GIF, or WebP image");
+		}
+		output("image", data, signature[0]);
+	}
+
+	function exit() {
+		let writesJson;
+		try {
+			writesJson = serializeWrites();
+		} catch (error) {
+			done(false, describeError(error));
+			throw EXIT;
+		}
+		done(true, undefined, writesJson);
+		throw EXIT;
+	}
+
+	const console = {};
+	for (const level of ["log", "info", "warn", "error", "debug"]) {
+		console[level] = (...args) => {
+			output("console", args.map(format).join(" "));
+		};
+	}
+	Object.freeze(console);
+
+	Object.defineProperty(globalThis, "tools", { value: toolsProxy, enumerable: true });
+	Object.defineProperty(globalThis, "ALL_TOOLS", { value: allTools, enumerable: true });
+	Object.defineProperty(globalThis, "console", { value: console, enumerable: true });
+	Object.defineProperty(globalThis, "text", { value: text, enumerable: true });
+	Object.defineProperty(globalThis, "image", { value: image, enumerable: true });
+	Object.defineProperty(globalThis, "exit", { value: exit, enumerable: true });
+
+	return {
+		settle(id, ok, payload) {
+			const entry = pending.get(id);
+			if (!entry) return;
+			pending.delete(id);
+			if (!ok) {
+				entry.reject(new ErrorCtor(payload));
+				return;
+			}
+			let value;
+			try {
+				value = payload === undefined ? undefined : parse(payload);
+			} catch (error) {
+				entry.reject(error);
+				return;
+			}
+			entry.resolve(value);
+		},
+		run(fn) {
+			let promise;
+			try {
+				promise = fn(toolsProxy, console);
+			} catch (error) {
+				done(false, describeError(error));
+				return;
+			}
+			promiseThen.call(
+				promise,
+				(value) => {
+					let json;
+					try {
+						json = serialize(value);
+					} catch (error) {
+						done(false, describeError(error));
+						return;
+					}
+					done(true, json, serializeWrites());
+				},
+				(error) => {
+					done(false, describeError(error));
+				},
+			);
+		},
+		stalled() {
+			if (finished || pending.size > 0) return false;
+			done(
+				false,
+				stringify({
+					name: "Error",
+					message:
+						"The script is waiting on a promise that can never settle: no tool call is pending, and timers do not exist here.",
+				}),
+			);
+			return true;
+		},
+	};
+})`;function o(e){if(typeof e!=`object`||!e)return!1;let t=e.type;return t===`call`||t===`output`||t===`done`||t===`crash`}function s(e){return typeof e==`object`&&!!e&&e.type===`result`}export{o as n,a as r,s as t};

package/lib/rolldown-runtime-dTnj95Mm.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import{createRequire as e}from"node:module";var t=Object.create,n=Object.defineProperty,r=Object.getOwnPropertyDescriptor,i=Object.getOwnPropertyNames,a=Object.getPrototypeOf,o=Object.prototype.hasOwnProperty,s=(e,t)=>()=>(t||(e((t={exports:{}}).exports,t),e=null),t.exports),c=(e,t)=>{let r={};for(var i in e)n(r,i,{get:e[i],enumerable:!0});return t||n(r,Symbol.toStringTag,{value:`Module`}),r},l=(e,t,a,s)=>{if(t&&typeof t==`object`||typeof t==`function`)for(var c=i(t),l=0,u=c.length,d;l<u;l++)d=c[l],!o.call(e,d)&&d!==a&&n(e,d,{get:(e=>t[e]).bind(null,d),enumerable:!(s=r(t,d))||s.enumerable});return e},u=(e,r,i)=>(i=e==null?{}:t(a(e)),l(r||!e||!e.__esModule?n(i,`default`,{value:e,enumerable:!0}):i,e)),d=e(import.meta.url);export{u as i,c as n,d as r,s as t};

package/lib/routes/agents.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Agent endpoints (EXPERIMENTAL).
+ *
+ *   GET  /agents                          configured agents: names, plus details
+ *                                         (model, tools, MCP server names, limits)
+ *   POST /agents/:name/run                run a prompt; ?stream=1 for SSE events
+ *                                         (first a `session` event with the id,
+ *                                         then `agent` events, then result/error)
+ *   GET  /agents/:name/sessions           newest-first session summaries
+ *   GET  /agents/:name/sessions/:id       full transcript (pi messages)
+ *   POST /agents/:name/sessions/:id/abort abort the active run on a session
+ *
+ * Configured via [[agents]] tables. These endpoints double as the surface the
+ * `bricks-buttress agent` CLI (and future clients) consume.
+ *
+ * Auth mirrors the functions surface, not the open inference endpoints:
+ * agents execute local functions, so an unbound server rejects every call
+ * unless `[agents_options] allow_unauthenticated = true`. A bound server
+ * accepts workspace JWTs. The server's own ephemeral internal token (also
+ * written to the 0600 runtime file for same-host CLIs) is always accepted.
+ */
+import { type AgentDefinition, type AgentsService } from '../agent/types';
+/**
+ * What a client may show about an agent. MCP servers are listed by name only:
+ * their urls, headers, commands and env can hold credentials.
+ */
+export declare const describeAgent: (agent: AgentDefinition) => {
+    name: string;
+    model: string;
+    tools: string[];
+    mcpServers: string[];
+    maxTurns: number;
+    localDevices: boolean;
+    codemode: boolean;
+    decisionModel: string | null;
+};
+export type ToolResultSummary = {
+    text: string | null;
+    images: number;
+    truncated: boolean;
+};
+/**
+ * A tool result for the wire: its text (bounded) and how many images it holds.
+ * Image bytes never go out; the transcript endpoint has the full result.
+ *
+ * pi passes the tool's own return value: normally `{ content: (text | image)[] }`,
+ * but untyped tools may return a bare string or no content at all.
+ */
+export declare const summarizeToolResult: (result: unknown) => ToolResultSummary;
+/**
+ * Slim pi agent events for the wire. `message_update` carries the FULL partial
+ * assistant message on every delta — per-token that would dwarf the payload —
+ * and tool results can be huge (`tool_execution_end` carries a bounded text
+ * summary); clients that want the full transcript fetch it from the sessions
+ * endpoint afterwards.
+ */
+export declare const slimAgentEvent: (event: any) => unknown;
+export declare function streamAgentRun(agents: AgentsService, name: string, body: {
+    prompt: string;
+    sessionId?: string;
+    fork?: boolean;
+}, signal: AbortSignal | undefined): AsyncGenerator<{
+    readonly event: string;
+    readonly data: string;
+}, void, unknown>;
+export default function factory(agents: AgentsService): import("../types").ButtressApp;

package/lib/routes/decision-shared.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Typed decisions on the sessionless paths (local functions, the
+ * TypeSafe-compatible endpoint).
+ *
+ * Mirrors tts-shared: a module-scoped warm-generator cache, reference-counted
+ * by in-flight requests. An unmatched model is an error rather than a
+ * substitution — another decision model would answer with different
+ * calibration, which the caller cannot detect.
+ *
+ * A decision model that is also configured as a `ggml-llm` runs on that
+ * generator's context (see utils/decision-sharing.ts).
+ */
+import type { DecisionRequest, DecisionResult } from '../types';
+/** Configured generators that answer decisions, in config order. */
+export declare const isDecisionGenerator: (generator: any) => boolean;
+/**
+ * Decision model ids configured more than once. Sessions tell such entries
+ * apart (revision, rank pooling, projector), but the sessionless paths select
+ * by id and always resolve to the first, so this is a startup warning only.
+ */
+export declare const findDuplicateDecisionIds: (config: any) => string[];
+/**
+ * Answer typed questions about a state with a warm decision generator,
+ * releasing it afterwards. The backend validates the request.
+ */
+export declare function decideWith(backend: any, config: any, { model, ...request }: DecisionRequest & {
+    model?: string;
+}, logPrefix?: string): Promise<DecisionResult>;

package/lib/routes/generator-cache.d.ts

@@ -31,6 +31,8 @@ export type GeneratorCacheOptions = {
     resolve: (config: any, requestedModel?: string) => ResolvedGeneratorRequest;
     /** Post-start preparation (typically `initContext`). */
     prepare: (backend: any, entry: GeneratorCacheEntry) => Promise<void>;
+    /** Undo `prepare` before an evicted entry is finalized, when finalizing alone does not. */
+    dispose?: (backend: any, entry: GeneratorCacheEntry) => Promise<void>;
 };
 type ConfiguredGeneratorResolverOptions = {
     family: string;
@@ -47,7 +49,7 @@ export declare const configuredGeneratorModelId: (generatorConfig: any) => strin
  * of silently loading different weights or voices.
  */
 export declare const createConfiguredGeneratorResolver: ({ family, types }: ConfiguredGeneratorResolverOptions) => (config: any, requestedModel?: string) => ResolvedGeneratorRequest;
-export declare const createGeneratorCache: ({ max, resolve, prepare }: GeneratorCacheOptions) => {
+export declare const createGeneratorCache: ({ max, resolve, prepare, dispose }: GeneratorCacheOptions) => {
     getOrCreate: (backend: any, config: any, requestedModel: string | undefined, logPrefix: string) => Promise<GeneratorCacheEntry>;
     release: (backend: any, entry: GeneratorCacheEntry | null | undefined, logPrefix: string) => Promise<void>;
 };

package/lib/routes/index.d.ts

@@ -3,4 +3,6 @@ export { default as file } from './file';
 export { default as status } from './status';
 export { default as openaiCompatFactory } from './openai-compat';
 export { default as anthropicMessagesFactory } from './anthropic-messages';
+export { default as typesafeCompatFactory } from './typesafe-compat';
 export { default as functionsFactory } from './functions';
+export { default as agentsFactory } from './agents';

package/lib/routes/llm-shared.d.ts

@@ -9,6 +9,7 @@ import type { GeneratorCacheEntry } from './generator-cache';
 export type { GeneratorCacheEntry };
 export { cancelReaderBestEffort } from './generator-cache';
 export declare const LLM_TYPES: string[];
+export declare const resolveConfiguredLlm: (config: any, requestedModel?: string) => import("./generator-cache").ResolvedGeneratorRequest;
 /**
  * Backend options every `messages`-shaped completion needs.
  *
@@ -47,6 +48,13 @@ export declare function extractTokenCounts(eventData: Record<string, any>): {
     cachedTokens: number;
     completionTokens: number;
 };
+/**
+ * Whether generation stopped because it ran out of room: the max-token budget
+ * or a full context. llama.node reports the budget as `stopped_limit` from
+ * parallel completion (what ggml-llm uses) and `stopped_limited` from a single
+ * completion.
+ */
+export declare function stoppedAtLimit(eventData: Record<string, any>): boolean;
 /**
  * Extract token usage in OpenAI format from backend event data.
  */

package/lib/routes/openai-compat.d.ts

@@ -1,6 +1,7 @@
 /**
- * OpenAI-compatible API endpoints for ggml-llm (EXPERIMENTAL)
- * Provides /oai-compat/v1/chat/completions and /oai-compat/v1/models endpoints
+ * OpenAI-compatible API endpoints for ggml-llm and ggml-decision (EXPERIMENTAL)
+ * Provides /oai-compat/v1/chat/completions, /oai-compat/v1/decisions and
+ * /oai-compat/v1/models endpoints
  *
  * Enable via TOML config: [openai_compat] enabled = true
  *
@@ -14,4 +15,14 @@ import type { EventStream } from '../types';
 export declare function streamChatCompletion(completionStream: ReadableStream<EventStream>, completionId: string, created: number, modelId: string, includeUsage: boolean): AsyncGenerator<{
     readonly data: string;
 }, void, unknown>;
+/**
+ * Model id -> what this server can do with it, from the config alone (no model
+ * load), in the `architecture` shape that llama.cpp server and OpenRouter
+ * publish: `text` output means chat completions, `decisions` means
+ * `/v1/decisions`. Clients should test membership and ignore unknown values.
+ */
+export declare const collectModelArchitectures: (generators: any[]) => Map<string, {
+    input_modalities: string[];
+    output_modalities: string[];
+}>;
 export default function factory(): import("../types").ButtressApp;

package/lib/routes/openai-decisions.check.d.ts

@@ -0,0 +1 @@
+export {};