@qvac/harness 1.0.0-rc.0 → 1.0.0-rc.2

package/dist-lib/lib/machine/index.d.ts

@@ -1,20 +1,463 @@
-export { completionMachineDefinition, runEngine, type CompletionSnapshot as EngineSnapshot, type EngineResult, type EngineRun, type EngineBoundaryOptions, type EngineOperationPort } from './engine.ts';
-export type { MachineDefinitionNode, MachineTransitionDefinition } from './engine.ts';
-export { contextFromBoot, requestFromBoot } from '../run-log/protocol.ts';
-export { brandCapturedRecord, isCapturedJson } from '../run-log/protocol.ts';
-export type { EngineBoot, EngineStep, MachineTransitionTrace, HistoryReference } from '../run-log/protocol.ts';
-export { emptyCompletionContext } from './completion/context.ts';
-export { createCompletionMachine } from './completion/machine.ts';
-export { replayRun, ReplayDivergence, ReplayTraceDivergence } from '../run-log/replay.ts';
-export { createInvokeTracker } from './completion/ports.ts';
-export type { EnginePorts, Invocation, InvokeTracker } from './completion/ports.ts';
-export type { CompletionContext as CompletionMachineContext, CompletionActorOutput, CompletionActorOutputs, CompletionHistoryEntry, FailureResultReference, FailureResultValue, SettledCall, StoredFailureResult, Message, RunBackendUse, RunBudget, RunLifecycleEvent, RunOutcome, ToolCallDisplay, ToolExecutionOutcome, TrustedOrigin, TrustedSource, TrustedSourceFacts, ToolEffect, ToolDecision, ToolActivityEvent, ResourceDescriptor, ResolvedCallSnapshot, ToolPreflight, ToolExecutionSnapshot, ToolDonePayload, HookRejection, DirectToolOutput, SearchingOutput, PreparingOutput, InspectingOutput, SkillLoadOutput, SkillPreloadState, PreloadInspectionOutput, ResolvingOutput, ApprovalGate, ToolPreflightFacts, ToolPolicyRejection, RoundDonePayload, ToolRejectedPayload, DirectToolRejectedPayload, PreparingPayload, SkillReadyPayload, SkillFailedPayload, AnsweredPayload, ToolsResolvedPayload, ToolStartedPayload } from './completion/types.ts';
-export type { EngineError, Operation } from './errors.ts';
-export { AbortedError, RecoveryRequired, ToolPolicyChanged, didDrainTimeOut, raceDrain, rehydrateError, tagError } from './errors.ts';
-export { stableStringify } from './stable-stringify.ts';
-export { MAX_BLOCKED_REPEATS, MAX_CAPPED_ROUNDS, MAX_MUTE_ROUNDS, MAX_TOOL_ROUNDS, TOOL_CONTINUATION_NUDGE, foldMetrics, failureResultRef, isFailureResultReference, readFailureResult, storeFailureResult, spliceFrom, toolCallKey, TOOL_DENIED_MESSAGE, toolDeniedResult } from './completion/rules.ts';
-export type { MetricsState } from './completion/rules.ts';
-export { MACHINE_VERSION, RUN_LOG_VERSION, XSTATE_VERSION, RunIncompatible, readRunLog, copy, safeForkLength, unresolvedWriteIds, unsettledRedactedIds, forkRepeatsSettledWrite, recoveryAdvice } from '../run-log/run-journal.ts';
-export type { ToolRejection } from './completion/types.ts';
-export type { MachineLog } from '../run-log/persisted-actor.ts';
-export type { ForkSegment, RecoveryResolution, Operation as RecoveryOperation, RunRecord } from '../run-log/run-journal.ts';
+import { emptyCompletionContext } from './completion/context.ts';
+import { runsUnasked } from './completion/rules.ts';
+import { completionMachineDefinition, transitionName } from './definition.ts';
+export declare class CompletionMachine {
+    static VERSION: number;
+    static PLAN_MODE_REFUSAL: string;
+    static create: (context?: import("./index.ts").CompletionContext, now?: () => number) => import("xstate").StateMachine<import("./index.ts").CompletionContext, {
+        type: 'START';
+    } | {
+        type: 'PAUSE';
+    } | {
+        type: 'RESUME';
+        pausedMs?: number;
+    } | {
+        type: 'RECOVERY_REQUIRED';
+        operation: import("../contract/run.ts").Operation;
+    } | {
+        type: 'FACTS';
+        value: import("./completion/types.ts").EngineFacts;
+    } | {
+        type: 'FAIL';
+        value: {
+            error: string;
+        } | Extract<import("../helpers/engine-error.ts").EngineError, {
+            tag: 'failed';
+        }>;
+    } | {
+        type: `xstate.error.actor.${string}`;
+        error: import("../helpers/engine-error.ts").EngineError;
+    } | {
+        type: `xstate.done.actor.${string}`;
+        output: import("./index.ts").CompletionActorOutput;
+    } | {
+        type: 'OUTPUT';
+        event: import("./index.ts").EngineEvent;
+    } | {
+        type: 'INPUT';
+        mode: 'steer' | 'follow-up';
+        id?: string;
+        text: string;
+    }, {
+        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<void, import("./index.ts").InvocationInput> | import("xstate").PromiseActorLogic<import("./completion/types.ts").AnsweredPayload, import("./index.ts").InvocationInput> | import("xstate").PromiseActorLogic<import("./completion/types.ts").BatchDonePayload, import("./index.ts").InvocationInput> | import("xstate").PromiseActorLogic<import("./completion/types.ts").InspectingOutput, import("./index.ts").InvocationInput> | import("xstate").PromiseActorLogic<import("./completion/types.ts").PrepareInspectionOutput, import("./index.ts").InvocationInput> | import("xstate").PromiseActorLogic<import("./completion/types.ts").PreparingOutput, import("./index.ts").InvocationInput> | import("xstate").PromiseActorLogic<import("./completion/types.ts").RetrievingOutput, import("./index.ts").InvocationInput> | import("xstate").PromiseActorLogic<import("./completion/types.ts").RoundDonePayload, import("./index.ts").InvocationInput> | import("xstate").PromiseActorLogic<import("./completion/types.ts").SearchingOutput, import("./index.ts").InvocationInput> | import("xstate").PromiseActorLogic<import("./completion/types.ts").ToolDonePayload, import("./index.ts").InvocationInput> | import("xstate").PromiseActorLogic<{
+            approved: boolean;
+        }, import("./index.ts").InvocationInput> | import("xstate").PromiseActorLogic<import("./completion/types.ts").PrepareRunOutput, import("./index.ts").InvocationInput> | import("xstate").PromiseActorLogic<import("./completion/types.ts").ResolvingOutput, import("./index.ts").InvocationInput> | import("xstate").PromiseActorLogic<import("./completion/types.ts").RoundDonePayload & {
+            response: string;
+        }, import("./index.ts").InvocationInput>> | undefined;
+    }, {
+        src: "answering";
+        logic: import("xstate").PromiseActorLogic<import("./completion/types.ts").AnsweredPayload, import("./index.ts").InvocationInput>;
+        id: string | undefined;
+    } | {
+        src: "approving";
+        logic: import("xstate").PromiseActorLogic<{
+            approved: boolean;
+        }, import("./index.ts").InvocationInput>;
+        id: string | undefined;
+    } | {
+        src: "batching";
+        logic: import("xstate").PromiseActorLogic<import("./completion/types.ts").BatchDonePayload, import("./index.ts").InvocationInput>;
+        id: string | undefined;
+    } | {
+        src: "cleanup";
+        logic: import("xstate").PromiseActorLogic<void, import("./index.ts").InvocationInput>;
+        id: string | undefined;
+    } | {
+        src: "executing";
+        logic: import("xstate").PromiseActorLogic<import("./completion/types.ts").ToolDonePayload, import("./index.ts").InvocationInput>;
+        id: string | undefined;
+    } | {
+        src: "finishing";
+        logic: import("xstate").PromiseActorLogic<void, import("./index.ts").InvocationInput>;
+        id: string | undefined;
+    } | {
+        src: "generating";
+        logic: import("xstate").PromiseActorLogic<import("./completion/types.ts").RoundDonePayload, import("./index.ts").InvocationInput>;
+        id: string | undefined;
+    } | {
+        src: "inspectPrepare";
+        logic: import("xstate").PromiseActorLogic<import("./completion/types.ts").PrepareInspectionOutput, import("./index.ts").InvocationInput>;
+        id: string | undefined;
+    } | {
+        src: "inspecting";
+        logic: import("xstate").PromiseActorLogic<import("./completion/types.ts").InspectingOutput, import("./index.ts").InvocationInput>;
+        id: string | undefined;
+    } | {
+        src: "preparing";
+        logic: import("xstate").PromiseActorLogic<import("./completion/types.ts").PreparingOutput, import("./index.ts").InvocationInput>;
+        id: string | undefined;
+    } | {
+        src: "rejecting";
+        logic: import("xstate").PromiseActorLogic<import("./completion/types.ts").ToolDonePayload, import("./index.ts").InvocationInput>;
+        id: string | undefined;
+    } | {
+        src: "resolving";
+        logic: import("xstate").PromiseActorLogic<import("./completion/types.ts").ResolvingOutput, import("./index.ts").InvocationInput>;
+        id: string | undefined;
+    } | {
+        src: "resume";
+        logic: import("xstate").PromiseActorLogic<void, import("./index.ts").InvocationInput>;
+        id: string | undefined;
+    } | {
+        src: "retrieving";
+        logic: import("xstate").PromiseActorLogic<import("./completion/types.ts").RetrievingOutput, import("./index.ts").InvocationInput>;
+        id: string | undefined;
+    } | {
+        src: "runPrepare";
+        logic: import("xstate").PromiseActorLogic<import("./completion/types.ts").PrepareRunOutput, import("./index.ts").InvocationInput>;
+        id: string | undefined;
+    } | {
+        src: "searching";
+        logic: import("xstate").PromiseActorLogic<import("./completion/types.ts").SearchingOutput, import("./index.ts").InvocationInput>;
+        id: string | undefined;
+    } | {
+        src: "wrapping";
+        logic: import("xstate").PromiseActorLogic<import("./completion/types.ts").RoundDonePayload & {
+            response: string;
+        }, import("./index.ts").InvocationInput>;
+        id: string | undefined;
+    }, {
+        type: "ackInput";
+        params: undefined;
+    } | {
+        type: "ackSteering";
+        params: import("./completion/implementations.ts").RoundParams;
+    } | {
+        type: "addKnowledge";
+        params: import("./completion/types.ts").RetrievingOutput;
+    } | {
+        type: "answerCompletion";
+        params: import("./completion/types.ts").AnsweredPayload;
+    } | {
+        type: "approveCompletion";
+        params: undefined;
+    } | {
+        type: "authorizePrepare";
+        params: import("./completion/types.ts").PrepareInspectionOutput;
+    } | {
+        type: "continueGoal";
+        params: undefined;
+    } | {
+        type: "continueStop";
+        params: import("./completion/types.ts").AnsweredPayload;
+    } | {
+        type: "continueWithInput";
+        params: undefined;
+    } | {
+        type: "endRunOnTool";
+        params: import("./completion/types.ts").ToolDonePayload;
+    } | {
+        type: "failCompletion";
+        params: import("./completion/actions/completion.ts").CompletionFailureMessage | {
+            tag: 'failed';
+            message: string;
+            name: string;
+            code?: string;
+            stack?: string;
+            cause?: import("../helpers/engine-error.ts").ErrorCause;
+        };
+    } | {
+        type: "finishBatch";
+        params: import("./completion/types.ts").BatchDonePayload;
+    } | {
+        type: "finishDirectTool";
+        params: import("./completion/types.ts").ToolDonePayload;
+    } | {
+        type: "finishRound";
+        params: import("./completion/types.ts").RoundDonePayload;
+    } | {
+        type: "finishTool";
+        params: import("./completion/types.ts").ToolDonePayload;
+    } | {
+        type: "finishWrapRound";
+        params: import("./completion/types.ts").RoundDonePayload;
+    } | {
+        type: "markTimeUp";
+        params: undefined;
+    } | {
+        type: "queueDirectSearch";
+        params: import("./completion/types.ts").PreparingOutput;
+    } | {
+        type: "queueInput";
+        params: undefined;
+    } | {
+        type: "recordFacts";
+        params: undefined;
+    } | {
+        type: "recordPause";
+        params: undefined;
+    } | {
+        type: "recordRecovery";
+        params: undefined;
+    } | {
+        type: "rejectCutOffTool";
+        params: import("./completion/types.ts").ResolvedCallSnapshot;
+    } | {
+        type: "rejectDeniedApproval";
+        params: import("./completion/types.ts").RejectDeniedApprovalParams;
+    } | {
+        type: "rejectPlanModeWrite";
+        params: import("./completion/actions/tools.ts").RejectPlanModeWriteParams;
+    } | {
+        type: "rejectRepeatedTool";
+        params: import("./completion/types.ts").RepeatOfFailedCallParams;
+    } | {
+        type: "rejectTool";
+        params: import("./completion/actions/tools.ts").RejectToolParams;
+    } | {
+        type: "requestApproval";
+        params: import("./completion/types.ts").ApprovalCall;
+    } | {
+        type: "requestPrepare";
+        params: import("./completion/actions/prepare.ts").RequestPrepareParams;
+    } | {
+        type: "resolveTools";
+        params: import("./completion/types.ts").ToolsResolvedPayload;
+    } | {
+        type: "resumeRun";
+        params: undefined;
+    } | {
+        type: "retryCappedSearch";
+        params: undefined;
+    } | {
+        type: "retryMalformedRound";
+        params: import("./completion/types.ts").AnsweredPayload;
+    } | {
+        type: "retryMuteRound";
+        params: undefined;
+    } | {
+        type: "retryNarratedRound";
+        params: import("./completion/types.ts").AnsweredPayload;
+    } | {
+        type: "selectNextTool";
+        params: import("./completion/types.ts").ResolvedCallSnapshot;
+    } | {
+        type: "settleGoal";
+        params: undefined;
+    } | {
+        type: "settlePrepare";
+        params: import("./completion/types.ts").PrepareResult;
+    } | {
+        type: "settlePrepareFailure";
+        params: import("./completion/types.ts").PrepareInspectionOutput | import("./completion/types.ts").PrepareRunOutput;
+    } | {
+        type: "startDirectTool";
+        params: import("./completion/types.ts").DirectToolOutput;
+    } | {
+        type: "startInitialRound";
+        params: import("./completion/types.ts").PreparingPayload;
+    } | {
+        type: "startNextRound";
+        params: undefined;
+    } | {
+        type: "startTool";
+        params: import("./completion/types.ts").ToolExecutionSnapshot & {
+            gate: import("./completion/types.ts").ApprovalGate;
+        };
+    } | {
+        type: "wrapCompletion";
+        params: import("../contract/run.ts").RunOutcome;
+    } | {
+        type: "wrapDeliveredCompletion";
+        params: undefined;
+    } | {
+        type: "wrapExhaustedCompletion";
+        params: undefined;
+    } | {
+        type: "wrapMuteCompletion";
+        params: undefined;
+    } | {
+        type: "wrapSearchCappedCompletion";
+        params: undefined;
+    }, {
+        type: "allResolvedToolsCapped";
+        params: unknown;
+    } | {
+        type: "approved";
+        params: unknown;
+    } | {
+        type: "batchRan";
+        params: unknown;
+    } | {
+        type: "canMuteRetry";
+        params: unknown;
+    } | {
+        type: "canRetrySearchCap";
+        params: unknown;
+    } | {
+        type: "deliveredBefore";
+        params: unknown;
+    } | {
+        type: "directAutoRuns";
+        params: unknown;
+    } | {
+        type: "directExecution";
+        params: unknown;
+    } | {
+        type: "directNeedsApproval";
+        params: unknown;
+    } | {
+        type: "directRejected";
+        params: unknown;
+    } | {
+        type: "directSearchNeeded";
+        params: unknown;
+    } | {
+        type: "errorInActiveOrResumingAndInterrupted";
+        params: unknown;
+    } | {
+        type: "errorInActiveOrResumingAndRecoveryRequired";
+        params: unknown;
+    } | {
+        type: "errorInFinishing";
+        params: import("xstate").NonReducibleUnknown;
+    } | {
+        type: "errorInPausing";
+        params: unknown;
+    } | {
+        type: "errorInRoutableState";
+        params: unknown;
+    } | {
+        type: "failInFinishing";
+        params: import("xstate").NonReducibleUnknown;
+    } | {
+        type: "failedOutcome";
+        params: unknown;
+    } | {
+        type: "goalTokensLeft";
+        params: unknown;
+    } | {
+        type: "goalUnmet";
+        params: unknown;
+    } | {
+        type: "hasAnswer";
+        params: unknown;
+    } | {
+        type: "hasInput";
+        params: unknown;
+    } | {
+        type: "hasQueuedTool";
+        params: unknown;
+    } | {
+        type: "hasRoundsLeft";
+        params: unknown;
+    } | {
+        type: "interrupted";
+        params: unknown;
+    } | {
+        type: "malformedToolCall";
+        params: unknown;
+    } | {
+        type: "narratedIntent";
+        params: unknown;
+    } | {
+        type: "needsApproval";
+        params: import("./completion/types.ts").ToolExecutionSnapshot | null | undefined;
+    } | {
+        type: "needsRecovery";
+        params: unknown;
+    } | {
+        type: "noDirectTool";
+        params: unknown;
+    } | {
+        type: "planModeWrite";
+        params: unknown;
+    } | {
+        type: "prepareFailed";
+        params: unknown;
+    } | {
+        type: "prepareNeeded";
+        params: unknown;
+    } | {
+        type: "readBatchQueued";
+        params: unknown;
+    } | {
+        type: "repeatOfFailed";
+        params: unknown;
+    } | {
+        type: "repeatsBlocked";
+        params: unknown;
+    } | {
+        type: "roundCutOff";
+        params: unknown;
+    } | {
+        type: "roundHasToolCalls";
+        params: unknown;
+    } | {
+        type: "searchPending";
+        params: unknown;
+    } | {
+        type: "stopContinues";
+        params: unknown;
+    } | {
+        type: "timeUp";
+        params: unknown;
+    } | {
+        type: "toolAnswered";
+        params: unknown;
+    } | {
+        type: "toolAutoRuns";
+        params: unknown;
+    } | {
+        type: "toolEndedRun";
+        params: unknown;
+    } | {
+        type: "toolRejected";
+        params: unknown;
+    }, "deadline", "done" | "failed" | "paused" | "pausing" | "resuming" | {
+        active: "answering" | "finishing" | "generating" | "idle" | "prepareChecking" | "prepareRunning" | "preparing" | "resolving" | "retrieving" | "round" | "searching" | "wrapping" | {
+            tools: "approving" | "batching" | "executing" | "inspecting" | "rejecting" | "selecting";
+        };
+    }, string, import("./index.ts").CompletionContext, {
+        status: 'success';
+        response: string;
+        metrics: import("./index.ts").CompletionContext['metrics'];
+    } | {
+        status: 'failure';
+        error: string;
+    }, import("./index.ts").EngineEvent, import("xstate").MetaObject, {
+        id: "completion";
+        states: {
+            readonly active: {
+                states: {
+                    readonly history: {};
+                    readonly idle: {};
+                    readonly preparing: {};
+                    readonly prepareChecking: {};
+                    readonly prepareRunning: {};
+                    readonly searching: {};
+                    readonly round: {};
+                    readonly generating: {};
+                    readonly resolving: {};
+                    readonly answering: {};
+                    readonly retrieving: {};
+                    readonly tools: {
+                        states: {
+                            readonly selecting: {};
+                            readonly batching: {};
+                            readonly inspecting: {};
+                            readonly rejecting: {};
+                            readonly approving: {};
+                            readonly executing: {};
+                        };
+                    };
+                    readonly wrapping: {};
+                    readonly finishing: {};
+                };
+            };
+            readonly pausing: {};
+            readonly resuming: {};
+            readonly paused: {};
+            readonly done: {};
+            readonly failed: {};
+        };
+    }, import("xstate").MetaObject>;
+    static definition: typeof completionMachineDefinition;
+    static emptyContext: typeof emptyCompletionContext;
+    static transitionName: typeof transitionName;
+    static runsUnasked: typeof runsUnasked;
+}
+export type { MachineDefinitionNode } from './definition.ts';
+export type { EmptyCompletionContextOptions } from './completion/context.ts';
+export type { CompletionActorLogic, CompletionParent, InvocationInput, Stage } from './completion/ports.ts';
+export type { CompletionContext, RunPolicy, CompletionActorOutput, CompletionActorOutputs, EngineEvent } from './completion/types.ts';

package/dist-lib/lib/machine/index.js

@@ -1,11 +1,15 @@
-export { completionMachineDefinition, runEngine } from './engine.js';
-export { contextFromBoot, requestFromBoot } from '../run-log/protocol.js';
-export { brandCapturedRecord, isCapturedJson } from '../run-log/protocol.js';
-export { emptyCompletionContext } from './completion/context.js';
-export { createCompletionMachine } from './completion/machine.js';
-export { replayRun, ReplayDivergence, ReplayTraceDivergence } from '../run-log/replay.js';
-export { createInvokeTracker } from './completion/ports.js';
-export { AbortedError, RecoveryRequired, ToolPolicyChanged, didDrainTimeOut, raceDrain, rehydrateError, tagError } from './errors.js';
-export { stableStringify } from './stable-stringify.js';
-export { MAX_BLOCKED_REPEATS, MAX_CAPPED_ROUNDS, MAX_MUTE_ROUNDS, MAX_TOOL_ROUNDS, TOOL_CONTINUATION_NUDGE, foldMetrics, failureResultRef, isFailureResultReference, readFailureResult, storeFailureResult, spliceFrom, toolCallKey, TOOL_DENIED_MESSAGE, toolDeniedResult } from './completion/rules.js';
-export { MACHINE_VERSION, RUN_LOG_VERSION, XSTATE_VERSION, RunIncompatible, readRunLog, copy, safeForkLength, unresolvedWriteIds, unsettledRedactedIds, forkRepeatsSettledWrite, recoveryAdvice } from '../run-log/run-journal.js';
+import { PLAN_MODE_REFUSAL } from './completion/actions/tools.js';
+import { emptyCompletionContext } from './completion/context.js';
+import { createCompletionMachine } from './completion/machine.js';
+import { runsUnasked } from './completion/rules.js';
+import { MACHINE_VERSION } from './completion/version.js';
+import { completionMachineDefinition, transitionName } from './definition.js';
+export class CompletionMachine {
+    static VERSION = MACHINE_VERSION;
+    static PLAN_MODE_REFUSAL = PLAN_MODE_REFUSAL;
+    static create = createCompletionMachine;
+    static definition = completionMachineDefinition;
+    static emptyContext = emptyCompletionContext;
+    static transitionName = transitionName;
+    static runsUnasked = runsUnasked;
+}

package/dist-lib/lib/models/llm-presets.d.ts

@@ -6,5 +6,6 @@ export interface LlmGenerationParams {
     repeat_penalty?: number;
     frequency_penalty?: number;
     reasoning_budget: -1 | 0;
+    tool_choice?: 'auto' | 'none' | 'required';
 }
 export declare function resolveLlmGenerationParams(modelName: string | undefined, reasoningEnabled: boolean | undefined, deviceDefault?: boolean): LlmGenerationParams | undefined;

package/dist-lib/lib/models/model-catalog-constants.d.ts

@@ -6,6 +6,8 @@ export declare const QWEN_35_9B = "Qwen3.5-9B-Q4_K_M";
 export declare const QWEN_36_27B = "Qwen3.6-27B-UD-Q4_K_XL";
 export declare const QWEN_36_35B_A3B = "Qwen3.6-35B-A3B-UD-Q4_K_M";
 export declare const QWEN_38_27B = "Qwen3.8-27B-UD-Q4_K_XL";
+export declare const BONSAI_2_27B_PQ2 = "Ternary-Bonsai-2-27B-PQ2_0";
+export declare const BONSAI_2_27B_PTQ1 = "Ternary-Bonsai-2-27B-PTQ1_0";
 export declare const MEDPSY_1_7B = "medpsy-1.7b-q4_k_m-imat";
 export declare const MEDPSY_4B = "medpsy-4b-q4_k_m-imat";
 export declare function isCapabilityProfile(value: string): value is CapabilityProfile;
@@ -19,7 +21,7 @@ export interface HostCapability {
 export declare function isMobilePlatform(platform: string): boolean;
 export declare function runnableModelName(requested: string, host: HostCapability | null): string;
 export declare function capabilityProfileToModelName(profile: CapabilityProfile): string;
-export declare const AGENT_MODEL_NAMES: readonly ["Qwen3.5-2B-Q4_K_M", "Qwen3.5-4B-Q4_K_M", "Qwen3.5-9B-Q4_K_M", "Qwen3.6-27B-UD-Q4_K_XL", "Qwen3.6-35B-A3B-UD-Q4_K_M", "Qwen3.8-27B-UD-Q4_K_XL", "medpsy-1.7b-q4_k_m-imat", "medpsy-4b-q4_k_m-imat"];
+export declare const AGENT_MODEL_NAMES: readonly ["Qwen3.5-2B-Q4_K_M", "Qwen3.5-4B-Q4_K_M", "Qwen3.5-9B-Q4_K_M", "Qwen3.6-27B-UD-Q4_K_XL", "Qwen3.6-35B-A3B-UD-Q4_K_M", "Qwen3.8-27B-UD-Q4_K_XL", "Ternary-Bonsai-2-27B-PQ2_0", "Ternary-Bonsai-2-27B-PTQ1_0", "medpsy-1.7b-q4_k_m-imat", "medpsy-4b-q4_k_m-imat"];
 export declare function modelDisplayName(modelName: string): string;
 export declare function capabilityProfileModelLabel(profile: CapabilityProfile): string;
 export declare function isMultimodalLlm(modelName: string): boolean;

package/dist-lib/lib/models/model-catalog-constants.js

@@ -11,6 +11,8 @@ export const QWEN_35_9B = 'Qwen3.5-9B-Q4_K_M';
 export const QWEN_36_27B = 'Qwen3.6-27B-UD-Q4_K_XL';
 export const QWEN_36_35B_A3B = 'Qwen3.6-35B-A3B-UD-Q4_K_M';
 export const QWEN_38_27B = 'Qwen3.8-27B-UD-Q4_K_XL';
+export const BONSAI_2_27B_PQ2 = 'Ternary-Bonsai-2-27B-PQ2_0';
+export const BONSAI_2_27B_PTQ1 = 'Ternary-Bonsai-2-27B-PTQ1_0';
 export const MEDPSY_1_7B = 'medpsy-1.7b-q4_k_m-imat';
 export const MEDPSY_4B = 'medpsy-4b-q4_k_m-imat';
 export function isCapabilityProfile(value) {
@@ -26,6 +28,8 @@ const MODEL_NAME_TO_PROFILE = new Map([
     [QWEN_36_27B, 'xhigh'],
     [QWEN_36_35B_A3B, 'xhigh'],
     [QWEN_38_27B, 'xhigh'],
+    [BONSAI_2_27B_PQ2, 'high'],
+    [BONSAI_2_27B_PTQ1, 'high'],
     [MEDPSY_1_7B, 'low'],
     [MEDPSY_4B, 'mid']
 ]);
@@ -70,6 +74,8 @@ export const AGENT_MODEL_NAMES = [
     QWEN_36_27B,
     QWEN_36_35B_A3B,
     QWEN_38_27B,
+    BONSAI_2_27B_PQ2,
+    BONSAI_2_27B_PTQ1,
     MEDPSY_1_7B,
     MEDPSY_4B
 ];
@@ -87,7 +93,9 @@ const MULTIMODAL_LLMS = new Set([
     QWEN_35_9B,
     QWEN_36_27B,
     QWEN_36_35B_A3B,
-    QWEN_38_27B
+    QWEN_38_27B,
+    BONSAI_2_27B_PQ2,
+    BONSAI_2_27B_PTQ1
 ]);
 export function isMultimodalLlm(modelName) {
     return MULTIMODAL_LLMS.has(modelName);

package/dist-lib/lib/models/model-catalog.d.ts

@@ -1,12 +1,11 @@
 import type { ModelRegistryEntry, ToolDialect } from '@qvac/sdk';
-import type { ImageModelSet } from '../tools/generate-image.ts';
-import type { MusicModelStages } from '../tools/generate-music.ts';
+import type { ModelSrc } from './context.ts';
 import type { ModelAddon } from './model-source.ts';
 export interface SdkModelAsset extends ModelRegistryEntry {
     readonly src: string;
 }
-import { CAPABILITY_PROFILE_ORDER, QWEN_35_2B, QWEN_35_4B, QWEN_35_9B, QWEN_36_27B, QWEN_36_35B_A3B, QWEN_38_27B, MEDPSY_1_7B, MEDPSY_4B, isCapabilityProfile, meetsMinCapabilityProfile, modelNameToCapabilityProfile, capabilityProfileToModelName, isMultimodalLlm, AGENT_MODEL_NAMES, modelDisplayName, capabilityProfileModelLabel, DEFAULT_IMAGE_MODEL_CHOICE, IMAGE_CHOICE_CATALOG, isMobilePlatform, runnableModelName, type CapabilityProfile, type HostCapability, type ImageModelChoice, type ImageChoiceEntry } from './model-catalog-constants.ts';
-export { CAPABILITY_PROFILE_ORDER, QWEN_35_2B, QWEN_35_4B, QWEN_35_9B, QWEN_36_27B, QWEN_36_35B_A3B, QWEN_38_27B, MEDPSY_1_7B, MEDPSY_4B, isCapabilityProfile, meetsMinCapabilityProfile, modelNameToCapabilityProfile, capabilityProfileToModelName, isMultimodalLlm, AGENT_MODEL_NAMES, modelDisplayName, capabilityProfileModelLabel, DEFAULT_IMAGE_MODEL_CHOICE, IMAGE_CHOICE_CATALOG, isMobilePlatform, runnableModelName };
+import { CAPABILITY_PROFILE_ORDER, QWEN_35_2B, QWEN_35_4B, QWEN_35_9B, QWEN_36_27B, QWEN_36_35B_A3B, QWEN_38_27B, BONSAI_2_27B_PQ2, BONSAI_2_27B_PTQ1, MEDPSY_1_7B, MEDPSY_4B, isCapabilityProfile, meetsMinCapabilityProfile, modelNameToCapabilityProfile, capabilityProfileToModelName, isMultimodalLlm, AGENT_MODEL_NAMES, modelDisplayName, capabilityProfileModelLabel, DEFAULT_IMAGE_MODEL_CHOICE, IMAGE_CHOICE_CATALOG, isMobilePlatform, runnableModelName, type CapabilityProfile, type HostCapability, type ImageModelChoice, type ImageChoiceEntry } from './model-catalog-constants.ts';
+export { CAPABILITY_PROFILE_ORDER, QWEN_35_2B, QWEN_35_4B, QWEN_35_9B, QWEN_36_27B, QWEN_36_35B_A3B, QWEN_38_27B, BONSAI_2_27B_PQ2, BONSAI_2_27B_PTQ1, MEDPSY_1_7B, MEDPSY_4B, isCapabilityProfile, meetsMinCapabilityProfile, modelNameToCapabilityProfile, capabilityProfileToModelName, isMultimodalLlm, AGENT_MODEL_NAMES, modelDisplayName, capabilityProfileModelLabel, DEFAULT_IMAGE_MODEL_CHOICE, IMAGE_CHOICE_CATALOG, isMobilePlatform, runnableModelName };
 export type { CapabilityProfile, HostCapability, ImageModelChoice, ImageChoiceEntry };
 export interface LlmCatalogEntry {
     readonly name: string;
@@ -14,6 +13,7 @@ export interface LlmCatalogEntry {
     readonly capabilityProfile: CapabilityProfile;
     readonly projection?: SdkModelAsset;
     readonly textOnly?: true;
+    readonly toolDialect?: ToolDialect;
 }
 export declare const LLM_CATALOG: ReadonlyArray<LlmCatalogEntry>;
 export declare function defaultProjectionMap(): Record<string, string>;
@@ -22,8 +22,18 @@ export interface CategoryDefault {
     readonly name: string;
     readonly category: ModelCategory;
     readonly asset: SdkModelAsset;
+    readonly modelConfig?: Readonly<Record<string, unknown>>;
+    readonly companions?: ReadonlyArray<SdkModelAsset>;
 }
+export declare const MOSS_TTS: CategoryDefault;
+export declare const MOSS_CODEC_ENCODER_SRC: "registry://s3/qvac_models_compiled/ggml/openmoss/2026-09-25/moss-codec-encoder-f16.gguf";
 export declare const CATEGORY_DEFAULTS: ReadonlyArray<CategoryDefault>;
+export declare function categoryModelConfig(modelSrc: ModelSrc): Readonly<Record<string, unknown>> | undefined;
+export interface CategoryDownloadMetadata {
+    readonly companions: ReadonlyArray<string>;
+    readonly assetSizes: Readonly<Record<string, number>>;
+}
+export declare function categoryDownloadMetadata(model: string, addon: ModelAddon | undefined): CategoryDownloadMetadata | undefined;
 export declare function defaultVoiceModel(category: ModelCategory): string;
 export declare function defaultTtsFor(profile: CapabilityProfile): CategoryDefault;
 export interface CatalogModel {
@@ -93,6 +103,22 @@ export interface ImageClamps {
     maxDim?: number;
     maxSteps?: number;
 }
+export interface ImageModelSet {
+    model: string;
+    llmModel?: string;
+    vaeModel?: string;
+    prediction?: 'flux2_flow';
+}
+export interface MusicModelStages {
+    dit: string;
+    textEnc: string;
+    lm: string;
+    vae: string;
+}
+export interface MusicClamps {
+    maxDuration?: number;
+    maxSteps?: number;
+}
 export declare function imageClampsFromEnv(env: Record<string, string | undefined>): ImageClamps | undefined;
 export declare function imageModelFromEnv(env: Record<string, string | undefined>, onIgnoredCompanions?: () => void, onIgnoredPrediction?: () => void): NonNullable<ReturnType<typeof imageModelFor>> | undefined;
 export interface CuratedListable {
@@ -120,6 +146,7 @@ export declare function setCustomModels(entries: ReadonlyArray<CustomModelEntry>
 export declare function customModels(): ReadonlyArray<CustomModelEntry>;
 export declare function customContextLength(name: string): number | undefined;
 export declare function customModelSrc(name: string, addon: ModelRegistryEntry['addon']): string | undefined;
+export declare function toolDialectFor(name: string): ToolDialect | undefined;
 export declare function customToolDialect(name: string): ToolDialect | undefined;
 export declare function customProjectionMap(): Record<string, string>;
 export declare function companionRegistryPaths(): Map<string, string[]>;