@fugood/buttress-server 2.26.0-beta.2 → 2.26.0-beta.21

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

@@ -0,0 +1,97 @@
+/**
+ * OpenAI Decisions API (`POST /v1/decisions`) <-> native decision requests.
+ *
+ * Spec: https://developers.openai.com/api/docs/guides/decisions
+ *
+ * The native request follows the TypeSafe `/v1/systemone` contract, so the
+ * question types map one to one: `predicate` -> `noul`, `choice` -> `choice`,
+ * `score` -> `score`. What differs is the shape: OpenAI sends an ordered array
+ * of optionally named questions with typed choice values and returns an
+ * ordered array of answers; native keys questions and options by string.
+ * The local models never refuse, so no `refusal` answer is produced.
+ */
+import type { DecisionRequest, DecisionResult } from '../types';
+type ChoiceValue = string | boolean;
+type QuestionPlan = {
+    id: string;
+    name: string | null;
+    type: 'predicate';
+} | {
+    id: string;
+    name: string | null;
+    type: 'choice';
+    options: {
+        key: string;
+        value: ChoiceValue;
+    }[];
+} | {
+    id: string;
+    name: string | null;
+    type: 'score';
+    labels: string[];
+};
+export type DecisionPlan = {
+    questions: QuestionPlan[];
+};
+export declare class DecisionRequestError extends Error {
+    param: string | null;
+    constructor(param: string | null, message: string);
+}
+/**
+ * Validate an OpenAI decision request and convert it to the native one.
+ * Throws a DecisionRequestError naming the offending field.
+ */
+export declare const toNativeDecisionRequest: (body: unknown) => {
+    model: string;
+    request: DecisionRequest;
+    plan: DecisionPlan;
+};
+/** Convert a native result to an OpenAI `Decision` object, answers in request order. */
+export declare const toOpenAIDecision: (result: DecisionResult, plan: DecisionPlan, model: string) => {
+    model: string;
+    answers: ({
+        type: string;
+        name: string | null;
+        probability: number;
+        choice?: undefined;
+        score?: undefined;
+        probabilities?: undefined;
+        confidence?: undefined;
+    } | {
+        probability?: undefined;
+        type: string;
+        name: string | null;
+        choice: any;
+        probabilities: {
+            value: ChoiceValue;
+            probability: number;
+        }[];
+        confidence: number;
+        score?: undefined;
+    } | {
+        probability?: undefined;
+        choice?: undefined;
+        type: string;
+        name: string | null;
+        score: number;
+        probabilities: {
+            value: number;
+            label: string;
+            probability: number;
+        }[];
+        confidence: number;
+    })[];
+    usage: {
+        input_tokens: number;
+        input_tokens_details: {
+            cached_tokens: number;
+            cache_write_tokens: number;
+        };
+        output_tokens: number;
+        output_tokens_details: {
+            reasoning_tokens: number;
+        };
+        total_tokens: number;
+    };
+};
+export {};

package/lib/routes/status.d.ts

@@ -1,4 +1,5 @@
+import type { State } from '../types';
 declare const _default: import("elysia").default<any, import("elysia").SingletonBase & {
-    store: import("../types").State;
+    store: State;
 }, any, any, any, any, any>;
 export default _default;

package/lib/routes/typesafe-compat.check.d.ts

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

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

@@ -0,0 +1,30 @@
+/**
+ * TypeSafe-compatible System One API (EXPERIMENTAL)
+ *
+ * Serves `/typesafe-compat/v1/systemone` and `/typesafe-compat/v1/models` in
+ * the shape of the hosted TypeSafe API (https://docs.typesafe.ai/api), so the
+ * TypeSafe SDKs reach this server's decision generators with
+ * `TYPESAFE_BASE_URL=http://<host>:<port>/typesafe-compat` — the same way
+ * they reach OpenRouter's System One API under its own path.
+ *
+ * Enable via TOML config: [typesafe_compat] enabled = true
+ *
+ * `model` selects a configured decision generator by its published id. An
+ * unknown model is rejected, never substituted: another model answers with
+ * different calibration, which the caller cannot detect.
+ */
+type ValidationIssue = {
+    loc: (string | number)[];
+    msg: string;
+    type: string;
+};
+/**
+ * Structural checks with the hosted API's limits. llama.node validates the
+ * questions again and has the final word; these catch what it reports less
+ * precisely, with the field location the SDKs print.
+ */
+export declare const validateSystemOneRequest: (body: any) => ValidationIssue[];
+/** Published ids of the configured decision generators, in config order. */
+export declare const decisionModelIds: (config: any) => string[];
+export default function factory(): import("../types").ButtressApp;
+export {};

package/lib/services/ggml-decision.d.ts

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+import type { ReadableStream } from 'node:stream/web';
+import type { DecisionResult, ServiceContext, EventStream, Expand } from '../types';
+export declare const decideProperty: z.ZodObject<{
+    request: z.ZodObject<{
+        state: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnknown, "many">, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+        questions: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        images: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        state: string | unknown[] | Record<string, unknown>;
+        questions: Record<string, Record<string, unknown>>;
+        images?: string[] | undefined;
+    }, {
+        state: string | unknown[] | Record<string, unknown>;
+        questions: Record<string, Record<string, unknown>>;
+        images?: string[] | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    request: {
+        state: string | unknown[] | Record<string, unknown>;
+        questions: Record<string, Record<string, unknown>>;
+        images?: string[] | undefined;
+    };
+}, {
+    request: {
+        state: string | unknown[] | Record<string, unknown>;
+        questions: Record<string, Record<string, unknown>>;
+        images?: string[] | undefined;
+    };
+}>;
+export declare const schemas: {
+    initContext: z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>], null>;
+    decide: z.ZodTuple<[z.ZodString, z.ZodObject<{
+        request: z.ZodObject<{
+            state: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnknown, "many">, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+            questions: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            images: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            state: string | unknown[] | Record<string, unknown>;
+            questions: Record<string, Record<string, unknown>>;
+            images?: string[] | undefined;
+        }, {
+            state: string | unknown[] | Record<string, unknown>;
+            questions: Record<string, Record<string, unknown>>;
+            images?: string[] | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        request: {
+            state: string | unknown[] | Record<string, unknown>;
+            questions: Record<string, Record<string, unknown>>;
+            images?: string[] | undefined;
+        };
+    }, {
+        request: {
+            state: string | unknown[] | Record<string, unknown>;
+            questions: Record<string, Record<string, unknown>>;
+            images?: string[] | undefined;
+        };
+    }>], null>;
+    releaseContext: z.ZodTuple<[z.ZodString], null>;
+};
+export interface Service {
+    initContext: (ctx: ServiceContext, ...args: z.infer<typeof schemas.initContext>) => ReadableStream<Expand<EventStream>>;
+    decide: (ctx: ServiceContext, ...args: z.infer<typeof schemas.decide>) => Promise<DecisionResult>;
+    releaseContext: (ctx: ServiceContext, ...args: z.infer<typeof schemas.releaseContext>) => Promise<{
+        released: boolean;
+        alreadyReleased?: boolean;
+    }>;
+}
+/**
+ * Clients upload local images first (like STT audio) and send their names;
+ * data URLs pass through.
+ */
+export declare const resolveDecisionImages: (session: ServiceContext['session'], request: z.infer<typeof decideProperty>['request']) => {
+    state: string | unknown[] | Record<string, unknown>;
+    questions: Record<string, Record<string, unknown>>;
+    images: string[] | undefined;
+};
+declare const _default: Service;
+export default _default;

package/lib/services/ggml-llm.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { type Service as LlmService } from './create-llm-service';
-import type { ServiceContext } from '../types';
+import type { DecisionResult, ServiceContext } from '../types';
 export declare const schemas: {
     initContext: z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodAny>], null>;
     completion: z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodAny>], null>;
@@ -9,9 +9,37 @@ export declare const schemas: {
     applyChatTemplate: z.ZodTuple<[z.ZodString, z.ZodAny], null>;
     releaseContext: z.ZodTuple<[z.ZodString], null>;
     embedding: z.ZodTuple<[z.ZodString, z.ZodAny], null>;
+    decide: z.ZodTuple<[z.ZodString, z.ZodObject<{
+        request: z.ZodObject<{
+            state: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnknown, "many">, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+            questions: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            images: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            state: string | unknown[] | Record<string, unknown>;
+            questions: Record<string, Record<string, unknown>>;
+            images?: string[] | undefined;
+        }, {
+            state: string | unknown[] | Record<string, unknown>;
+            questions: Record<string, Record<string, unknown>>;
+            images?: string[] | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        request: {
+            state: string | unknown[] | Record<string, unknown>;
+            questions: Record<string, Record<string, unknown>>;
+            images?: string[] | undefined;
+        };
+    }, {
+        request: {
+            state: string | unknown[] | Record<string, unknown>;
+            questions: Record<string, Record<string, unknown>>;
+            images?: string[] | undefined;
+        };
+    }>], null>;
 };
 export interface Service extends LlmService {
     embedding: (ctx: ServiceContext, ...args: z.infer<typeof schemas.embedding>) => Promise<any>;
+    decide: (ctx: ServiceContext, ...args: z.infer<typeof schemas.decide>) => Promise<DecisionResult>;
 }
 declare const _default: Service;
 export default _default;

package/lib/services/index.d.ts

@@ -3,6 +3,7 @@ import type { Service as CommonService } from './common';
 import type { Service as GgmlLlmService } from './ggml-llm';
 import type { Service as GgmlSttService } from './ggml-stt';
 import type { Service as GgmlTtsService } from './ggml-tts';
+import type { Service as GgmlDecisionService } from './ggml-decision';
 import type { Service as MlxLlmService } from './mlx-llm';
 import type { Service as OnnxSttService } from './onnx-stt';
 import type { Service as OnnxTtsService } from './onnx-tts';
@@ -21,6 +22,7 @@ declare const services: {
         releaseContext: ({ backend, session }: ServiceContext, id: any, force: any) => Promise<any>;
     };
     ggmlTts: GgmlTtsService;
+    ggmlDecision: GgmlDecisionService;
     mlxLlm: MlxLlmService;
     onnxStt: OnnxSttService;
     onnxTts: OnnxTtsService;
@@ -35,6 +37,7 @@ export type Services = {
     ggmlLlm: ClientService<GgmlLlmService>;
     ggmlStt: ClientService<GgmlSttService>;
     ggmlTts: ClientService<GgmlTtsService>;
+    ggmlDecision: ClientService<GgmlDecisionService>;
     mlxLlm: ClientService<MlxLlmService>;
     onnxStt: ClientService<OnnxSttService>;
     onnxTts: ClientService<OnnxTtsService>;

package/lib/tui-ClNupsCH.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import{a as e,t}from"./client-qqI-HCOj.mjs";import{Container as n,Editor as r,Loader as i,Markdown as a,ProcessTerminal as o,Text as s,TuiMainScreen as c}from"@earendil-works/pi-tui";const l=e=>t=>`\x1b[${e}m${t}\x1b[0m`,u=l(`2`),d=l(`1`),f=l(`36`),p=l(`33`),m=l(`31`),h=l(`32`),g=l(`35`),_={heading:e=>d(f(e)),link:f,linkUrl:e=>u(f(e)),code:p,codeBlock:p,codeBlockBorder:u,quote:u,quoteBorder:u,hr:u,listBullet:f,bold:d,italic:l(`3`),strikethrough:l(`9`),underline:l(`4`)},v={borderColor:u,selectList:{selectedPrefix:f,selectedText:d,description:u,scrollInfo:u,noMatch:u}},y=(e,t)=>e.length>t?`${e.slice(0,t)}…`:e;var b=class{tui;chat;thinking=null;thinkingBuffer=``;answer=null;answerBuffer=``;constructor(e,t){this.tui=e,this.chat=t}touch(){this.tui.requestRender()}appendThinking(e){this.thinking||(this.thinking=new s(``,0,0),this.chat.addChild(this.thinking)),this.thinkingBuffer+=e,this.thinking.setText(u(this.thinkingBuffer.trimEnd())),this.touch()}appendAnswer(e){this.answer||(this.answer=new a(``,0,0,_),this.chat.addChild(this.answer)),this.answerBuffer+=e,this.answer.setText(this.answerBuffer),this.touch()}addLine(e){this.answer=null,this.answerBuffer=``,this.chat.addChild(new s(e,0,0)),this.touch()}};const x=async({connection:a,agentName:l,sessionId:_,fork:x})=>{let S=new o,C=new c(S);S.setTitle(`buttress agent · ${l}`);let w=new n,T=new s(``,0,0),E=new r(C,v);C.addChild(w),C.addChild(T),C.addChild(E),C.setFocus(E);let D=_,O=x,k=null,A=null,j=e=>{T.setText(e),C.requestRender()},M=()=>{A||(A=new i(C,f,u,`thinking…`),w.addChild(A),C.requestRender())},N=()=>{A&&(w.removeChild(A),A=null,C.requestRender())},P=`${d(l)} ${u(`@ ${a.baseUrl}`)}`+(D?` ${u(`(${O?`forking`:`continuing`} ${D})`)}`:``);w.addChild(new s(P,0,0)),j(u(`Enter to send · /new fresh session · /exit or Ctrl+C to quit`));let F=async()=>{C.stop(),await S.drainInput().catch(()=>{}),process.exit(0)};C.addInputListener(e=>{if(e===``)return k?(k.abort(),k=null,{consume:!0}):(F(),{consume:!0})});let I=async n=>{w.addChild(new s(`${f(`>`)} ${n}`,0,0));let r=new b(C,w),i=D;k=new AbortController,M(),j(u(`running · Ctrl+C aborts this turn`));let o;try{o=await e(a,l,{prompt:n,sessionId:D??void 0,fork:O},{signal:k.signal,onFrame:({event:e,payload:t})=>{if(e===`session`&&t?.sessionId){t.sessionId!==D&&(D=t.sessionId,w.addChild(new s(u(`session ${D}`),0,0)));return}if(e!==`agent`)return;N();let n=t?.event;if(t?.type===`message_update`&&n)n.type===`thinking_delta`?r.appendThinking(n.delta??``):n.type===`text_delta`&&r.appendAnswer(n.delta??``);else if(t?.type===`tool_execution_start`){let e=JSON.stringify(t.args??{});r.addLine(`${p(`⚙ ${t.toolName}`)}${u(`(${y(e,120)})`)}`)}else t?.type===`tool_execution_end`?r.addLine(t.isError?m(`✗ ${t.toolName} failed`):u(`✓ ${t.toolName}`)):t?.type===`tool_emit`&&r.addLine(u(`  ${t.toolName} → ${t.event}`))}})}catch(e){o={kind:`error`,message:e?.message||String(e),sessionId:D}}if(N(),k=null,o.kind===`result`){let{result:e}=o;D=e.sessionId??D;let t=e.usage||{};w.addChild(new s(u(`— ${e.stopReason} · ${t.totalTurns??`?`} turn(s) · ${t.input??0} in / ${t.output??0} out · session ${D}`),0,0))}else o.kind===`aborted`?(D=o.sessionId??D,w.addChild(new s(p(`(aborted — session is continuable)`),0,0))):o.kind===`error`?(D=o.sessionId??D,w.addChild(new s(m(`Run failed: ${o.message}`),0,0))):w.addChild(new s(m(`Connection lost mid-run.`),0,0));t(i,D)&&(O=!1),j(u(`Enter to send · /new fresh session · /exit or Ctrl+C to quit`)),C.requestRender()};E.onSubmit=e=>{let t=e.trim();if(E.setText(``),t){if(k){j(p(`A turn is still running — Ctrl+C aborts it.`));return}if(t===`/exit`||t===`/quit`){F();return}if(t===`/new`){D=null,O=!1,w.addChild(new s(`${h(`•`)} ${u(`started a fresh session`)}`,0,0)),C.requestRender();return}if(t===`/session`){w.addChild(new s(u(D?`session ${D}`:`no session yet`),0,0)),C.requestRender();return}I(t)}},w.addChild(new s(u(g(`ready`)),0,0)),C.start(),await new Promise(()=>{})};export{x as runAgentTui};

package/lib/types.d.ts

@@ -1,6 +1,7 @@
 import type { Elysia, SingletonBase } from 'elysia';
 import type { ReadableStream } from 'node:stream/web';
-import type { Backend } from './index';
+import type * as backendCore from '@fugood/buttress-backend-core';
+export type Backend = typeof backendCore;
 export type HumanReadableUnit = number | string;
 type NormalizeKeys = 'max_body_size' | 'session_timeout' | 'max_size_bytes';
 export type DeepNormalize<T> = T extends object ? {
@@ -25,7 +26,25 @@ export type RuntimeConfig = {
     huggingface_token?: string;
     session_cache?: SessionCacheConfig;
 } & Record<string, any>;
-export type GeneratorType = 'ggml-llm' | 'ggml-stt' | 'ggml-tts' | 'mlx-llm' | 'onnx-stt' | 'onnx-tts';
+export type GeneratorType = 'ggml-llm' | 'ggml-stt' | 'ggml-tts' | 'ggml-decision' | 'mlx-llm' | 'onnx-stt' | 'onnx-tts';
+/** A TypeSafe `/v1/systemone` request, answered by a `ggml-decision` generator. */
+export type DecisionRequest = {
+    /** A string, or any JSON object/array (given to the model as JSON text). */
+    state: unknown;
+    /** Question id → `{ type: 'choice' | 'score' | 'noul', instructions, criteria }`. */
+    questions: Record<string, Record<string, any>>;
+    /** Local file paths or data URLs; needs a model with an mmproj configured. */
+    images?: string[];
+};
+export type DecisionResult = {
+    model: string;
+    /** Question id → the answer for its type (`choice`, `score` or `noul`). */
+    answers: Record<string, any>;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+};
 export type GeneratorConfig = {
     type: GeneratorType;
 } & Record<string, any>;
@@ -39,6 +58,10 @@ export type GlobalConfig = {
         enabled?: boolean;
         cors_allowed_origins?: string | string[];
     };
+    typesafe_compat?: {
+        enabled?: boolean;
+        cors_allowed_origins?: string | string[];
+    };
     functions?: {
         enabled?: boolean;
         /** Directory holding local function files, relative to the config file. */
@@ -53,6 +76,10 @@ export type GlobalConfig = {
         config?: Record<string, any>;
         cors_allowed_origins?: string | string[];
     };
+    /** `[[agents]]` tables; validated by `agent/config.ts` at startup. */
+    agents?: Record<string, any>[];
+    /** `[agents_options]`: sessions_dir, retention, max_depth, allow_unauthenticated. */
+    agents_options?: Record<string, any>;
 } & Record<string, any>;
 export type AutodiscoverConfig = {
     udp: {
@@ -135,6 +162,11 @@ export type ServerInfo = {
         enabled: boolean;
         count: number;
     };
+    /** Agent surface: a flag and a count, for the same ANNOUNCE-size reason. */
+    agents?: {
+        enabled: boolean;
+        count: number;
+    };
 };
 export type EventStream = {
     event: string;
@@ -161,6 +193,20 @@ export type State = {
     config: Config;
     sessions: Map<string, Session>;
     workspaceState: import('./utils/workspaceState').WorkspaceState;
+    /** Epoch ms when `createServer` began, reported on `/buttress/status`. */
+    startedAt: number;
+    /** The compatibility endpoints this process serves (env var or config flag). */
+    endpoints: {
+        openaiCompat: boolean;
+        anthropicMessages: boolean;
+        typesafeCompat: boolean;
+    };
+    /** Local functions; null when the feature is off or failed to start. */
+    functionsService: import('./functions').FunctionsService | null;
+    /** Config-defined agents; null when none are configured or they failed to start. */
+    agentsService: import('./agent/types').AgentsService | null;
+    /** This machine, read once at startup for `/buttress/status`. */
+    host: import('./utils/hostFacts').HostFacts;
 };
 type ButtressSingleton = SingletonBase & {
     store: State;

package/lib/ui/command.d.ts

@@ -0,0 +1,2 @@
+/** `bricks-buttress ui …`. Exits the process: 0 after the window closes, 1 on any failure. */
+export declare const runUiCommand: (argv: string[]) => Promise<void>;

package/lib/ui/host.d.ts

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

package/lib/ui/window-module.d.ts

@@ -0,0 +1,6 @@
+import type { LaunchButtressUi } from '@fugood/buttress-ui/src/host';
+export declare const UI_PACKAGE = "@fugood/buttress-ui";
+export type WindowModule = {
+    launchButtressUi: LaunchButtressUi;
+};
+export declare const importWindowModule: () => Promise<WindowModule>;

package/lib/utils/config.d.ts

@@ -1,5 +1,4 @@
-import type { Config, AutodiscoverConfig, HumanReadableConfig } from '../types';
-import type { Backend } from '../index';
+import type { Backend, Config, AutodiscoverConfig, HumanReadableConfig } from '../types';
 export declare const deepMerge: (target?: Record<string, any>, source?: Record<string, any>) => Record<string, any>;
 export declare const normalizeConfigInput: (input: any) => null | Record<string, any>;
 export declare const mergeGeneratorConfig: (base: any, override: any) => Record<string, any>;
@@ -16,6 +15,7 @@ export declare const resolveSupportedGenerators: (config: Config, defaultTypes:
 }[];
 /**
  * Process raw user config (HumanReadableConfig) into Config.
- * Handles: device defaults, value normalization (bytes/ms), structure splitting.
+ * Handles: device defaults, value normalization (bytes/ms), structure splitting,
+ * and dropping generators with `enabled = false`.
  */
 export declare const processConfig: (input: HumanReadableConfig | null) => Config;

package/lib/utils/cors.d.ts

@@ -56,6 +56,7 @@ export type CorsPolicy = {
 export declare const buildCorsPolicies: (config: Config, enabled?: {
     openaiCompat?: boolean;
     anthropicMessages?: boolean;
+    typesafeCompat?: boolean;
     functions?: boolean;
 }) => CorsPolicy[];
 /**

package/lib/utils/decision-sharing.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Decision models that share an LLM generator's context.
+ *
+ * A model that both generates and answers typed decisions (Jevling, for one)
+ * is often configured twice: as a `ggml-llm` and as a `ggml-decision`. With
+ * `[generators.backend] share_llm_context = true` on the decision entry, and
+ * both entries naming the same weights, decisions run on the LLM's context
+ * (`parallel.decide()` on a slot beside its completions) instead of loading
+ * the weights a second time. The LLM config always loads the model, so the
+ * result does not depend on which generator starts first.
+ *
+ * It is opt-in because it trades throughput for memory: a decision takes one
+ * of the LLM's `n_parallel` slots, and its forward passes run in the slot
+ * loop between two shared batches, so concurrent completions stop generating
+ * while it runs (a 128-token completion took 2x as long beside six decisions,
+ * unchanged with a separate decision context). Results are not affected: the
+ * slot's sequence and prompt cache are cleared after each decision.
+ *
+ * Sharing is skipped when the decision needs a context the LLM cannot give:
+ * rank pooling (an embedding context), or a different projector.
+ */
+/**
+ * The configured `ggml-llm` generator whose context serves this configured
+ * decision generator, or null. For a client's request use
+ * `findSharedLlmForClient`: the opt-in must come from the server config.
+ */
+export declare const findSharedLlmGenerator: (config: any, decisionConfig: any) => any | null;
+/**
+ * The shared LLM for a decision generator a client starts over RPC, or null.
+ * Sharing needs a configured `ggml-decision` entry with the same weights that
+ * opted in; the client's own `share_llm_context` is ignored, since it would
+ * let a client put its decisions on the LLM's slots. The client's merged
+ * model (rank pooling, projector) still decides whether the LLM can serve it.
+ */
+export declare const findSharedLlmForClient: (config: any, clientModel: any) => any | null;
+/** Startup report: which decision generators share an LLM, and why others do not. */
+export declare const describeDecisionSharing: (config: any) => string[];

package/lib/utils/downloadStatus.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Model pre-downloads (`download = true`) for `/buttress/status`: the ones in
+ * flight plus a short newest-first history.
+ *
+ * The backends report progress as a 0–1 fraction only, so byte counts stay
+ * unknown (`receivedBytes` 0, `totalBytes` / `bytesPerSecond` null) and the
+ * fraction is exposed as `progress`. Downloads a session starts on demand go
+ * through backend-core's download manager, which tracks no metadata, so they
+ * are not listed here.
+ *
+ * A module-scoped singleton like the other status trackers: the CLI records
+ * into it and the status route snapshots it.
+ */
+import type { GeneratorType } from '../types';
+export type ActiveDownload = {
+    type: GeneratorType;
+    repoId: string;
+    filename: string | null;
+    receivedBytes: number;
+    totalBytes: number | null;
+    bytesPerSecond: number | null;
+    startedAt: string;
+    /** 0–1 as reported by the backend; null before the first report. */
+    progress: number | null;
+};
+export type FinishedDownload = {
+    type: GeneratorType;
+    repoId: string;
+    filename: string | null;
+    totalBytes: number | null;
+    durationMs: number;
+    finishedAt: string;
+    success: boolean;
+    error?: string;
+};
+export type DownloadsSnapshot = {
+    active: ActiveDownload[];
+    recent: FinishedDownload[];
+};
+/** Feeds one download's callbacks into the tracker. Calls after the first ending are no-ops. */
+export type DownloadHandle = {
+    progress(fraction: number): void;
+    /** Replaces the repo named at `begin` with the one the backend resolved. */
+    setRepoId(repoId: string): void;
+    complete(): void;
+    fail(error: unknown): void;
+    /** Ends the entry without history: nothing was downloaded (already cached, or joined another download). */
+    discard(): void;
+};
+export declare const downloadStatus: {
+    begin(download: {
+        type: GeneratorType;
+        repoId: string;
+        filename?: string | null;
+    }): DownloadHandle;
+    snapshot(): DownloadsSnapshot;
+};

package/lib/utils/hostFacts.d.ts

@@ -0,0 +1,13 @@
+/**
+ * This machine, as `/buttress/status` and the settings window describe it. Same shape as
+ * `HostInfo` in @fugood/buttress-ui, kept local so the emitted types do not need that package.
+ */
+export type HostFacts = {
+    cpuModel: string;
+    cpuCores: number;
+    totalMemoryBytes: number;
+    /** Unified memory: the GPU shares `totalMemoryBytes`. */
+    appleSilicon: boolean;
+    gpuName?: string;
+};
+export declare const readHostFacts: () => HostFacts;

package/lib/utils/workspaceState.d.ts

@@ -19,10 +19,18 @@ export interface BankBinding {
     keyName?: string;
     issuedAt?: string;
 }
+export interface DevtoolsBinding {
+    token: string;
+    workspaceId: string;
+    expiresAt: string;
+    jti?: string;
+}
 export interface WorkspaceState {
     workspace: WorkspaceBinding | null;
     serverKeyPair: ServerKeyPair | null;
     bank: BankBinding | null;
+    /** Optional for state files written before device credential provisioning. */
+    devtools?: DevtoolsBinding | null;
 }
 export declare const resolveStateDir: () => string;
 export declare const resolveStatePath: () => string;