open-multi-agent-kit 0.90.0 → 0.90.4

package/dist/core/agent-session.d.ts

@@ -37,6 +37,13 @@ export interface ParsedSkillBlock {
  * Returns null if the text doesn't contain a skill block.
  */
 export declare function parseSkillBlock(text: string): ParsedSkillBlock | null;
+/**
+ * Thinking mode: "manual" keeps the user-selected level; "auto" resolves the
+ * level per turn via the reasoning router. Manual `/think <level>` always wins
+ * because the router only runs in auto mode.
+ */
+export type ThinkingMode = "manual" | "auto";
+export type ThinkingRouterVersion = "v1" | "v2" | "v3" | "v4";
 /** Session-specific events that extend the core AgentEvent */
 export type AgentSessionEvent = Exclude<AgentEvent, {
     type: "agent_end";
@@ -143,6 +150,8 @@ export interface PromptOptions {
     streamingBehavior?: "steer" | "followUp";
     /** Source of input for extension input event handlers. Defaults to "interactive". */
     source?: InputSource;
+    activeSkillNames?: readonly string[];
+    activeSkillSource?: string;
     /** Internal hook used by RPC mode to observe prompt preflight acceptance or rejection. */
     preflightResult?: (success: boolean) => void;
 }
@@ -177,6 +186,36 @@ export declare class AgentSession {
     readonly sessionManager: SessionManager;
     readonly settingsManager: SettingsManager;
     private _scopedModels;
+    /**
+     * Thinking mode (default "manual"). Persists across turns within the session;
+     * auto-resolved levels are never written to the user's persisted settings.
+     */
+    private _thinkingMode;
+    /**
+     * Reasoning router version used by auto thinking mode. "v1" (default) keeps
+     * the frozen v1 classifyTask/resolveThinkingLevel; "v2" uses the Goal 004
+     * weighted router; "v3" uses the Goal 007 calibrated classifier; "v4" uses
+     * the Goal 009 confidence-bearing classifier (classifyTaskV4 +
+     * resolveThinkingLevelV4WithUncertainty). Default "v1" so behavior is
+     * unchanged until explicitly opted in.
+     */
+    private _thinkingRouterVersion;
+    /**
+     * N=8 ring buffer of recent auto-turn task classes (newest first), feeding
+     * the v2/v3 classifiers' multi-turn prior feature. Never persisted to settings.
+     */
+    private _taskClassHistory;
+    /**
+     * Compiled reasoning-router bias snapshot for the opt-in v4 learning path
+     * (Goal 010 Lane I). Loaded at most once per session and pinned thereafter:
+     * `_reasoningRouterBiasSnapshotLoaded` flips to `true` on the first v4
+     * auto-turn that has learning enabled, and `_reasoningRouterBiasSnapshot`
+     * then stays fixed for the rest of the session (even across later settings
+     * reloads, and even if the on-disk file changes or the load failed/was
+     * invalid, in which case it stays `null`). See `_getReasoningRouterBiasSnapshot`.
+     */
+    private _reasoningRouterBiasSnapshot;
+    private _reasoningRouterBiasSnapshotLoaded;
     private _unsubscribeAgent?;
     private _eventListeners;
     /** Tracks pending steering messages for UI display. Removed when delivered. */
@@ -278,6 +317,8 @@ export declare class AgentSession {
     get model(): Model<any> | undefined;
     /** Current thinking level */
     get thinkingLevel(): ThinkingLevel;
+    /** Current thinking mode ("manual" = user-selected level, "auto" = per-turn router) */
+    get thinkingMode(): ThinkingMode;
     /** Whether agent is currently streaming a response */
     get isStreaming(): boolean;
     /** Current effective system prompt (includes any per-turn extension modifications) */
@@ -452,6 +493,97 @@ export declare class AgentSession {
      * Saves to session and settings only if the level actually changes.
      */
     setThinkingLevel(level: ThinkingLevel): void;
+    /**
+     * Set the thinking mode. "auto" resolves a level per turn via the reasoning
+     * router; "manual" keeps the explicitly selected level. The mode persists for
+     * the session lifetime and is never written to user settings.
+     */
+    setThinkingMode(mode: ThinkingMode): void;
+    /**
+     * Reasoning router version selection for auto thinking mode.
+     * Default "v1". Switching to "v2", "v3", or "v4" activates the
+     * corresponding opt-in router; the multi-turn history buffer is only
+     * consulted there.
+     */
+    get thinkingRouterVersion(): ThinkingRouterVersion;
+    setThinkingRouterVersion(version: ThinkingRouterVersion): void;
+    /**
+     * In auto thinking mode, resolve and apply this turn's thinking level from the
+     * prompt content. Updates agent state, records the change in the session, and
+     * notifies observers - but never overwrites the user's persisted default
+     * thinking level in settings. Models without reasoning support bypass the
+     * router entirely (level stays "off").
+     */
+    private _applyAutoThinkingLevelForTurn;
+    /**
+     * v2 auto-mode resolver (Goal 004). Builds the caller-side features the pure
+     * classifier cannot reach on its own (multi-turn ring buffer, context-pressure
+     * bucket), then applies classifyTaskV2 + resolveThinkingLevelV2ForAuto. The
+     * resolved class is pushed to the N=8 history for the NEXT turn's prior.
+     */
+    private _applyAutoThinkingLevelV2;
+    /**
+     * v3 auto-mode resolver (Goal 007). Reuses the same N=8 recent-class history
+     * and context-pressure bucket as v2, but routes through the v3 classifier and
+     * resolver pair.
+     */
+    private _applyAutoThinkingLevelV3;
+    /**
+     * v4 auto-mode resolver (Goal 009 Wave 3 Lane V1; wired to the opt-in
+     * learning bias by Goal 010 Lane I). Reuses the same N=8 recent-class
+     * history and context-pressure bucket as v2/v3, routed through the
+     * confidence-bearing v4 classifier and its uncertainty-aware resolver. No
+     * `laneType` applies to the main session (always "none"/`undefined`);
+     * `hint` is permanently `null` -- the Adaptorch advisory bridge has no
+     * transport wired into the session (out of this lane's scope; see
+     * adaptorch-bridge.ts). `bias` stays `0` unless BOTH hold: (a) the global,
+     * owner-only `reasoningRouterLearning.enabled` setting is `true` (default
+     * off; a project-scope `.omk/settings.json` value for this key is never
+     * consulted -- see settings-manager.ts), and (b) a compiled
+     * `RouterBiasSnapshot` was found and passed strict validation at the
+     * configured/default path, loaded and cached ("pinned") at most once per
+     * session (see `_getReasoningRouterBiasSnapshot`). When learning is
+     * enabled, exactly one bounded "accepted" feedback record (no raw prompt/
+     * path/diff/session/model/provider/tool/hook content; see
+     * router-feedback-collector.ts's exact ten-key schema) is appended to the
+     * local ledger after every v4 auto-turn resolution, for a future, separate
+     * offline compile step to learn from -- this lane never records an
+     * override/fail/hook-outcome signal, only the neutral "accepted" one. The
+     * resolver's own confidence-band/fallback-reason escalation (see
+     * reasoning-router-v4.ts) still applies on top of the base+lane+bias
+     * target, so a low-confidence or fallback-decided verdict can still only
+     * match or exceed the confident-path level.
+     */
+    private _applyAutoThinkingLevelV4;
+    /**
+     * Loads and strictly validates the compiled reasoning-router bias snapshot
+     * for the opt-in v4 learning path (Goal 010 Lane I), at most once per
+     * session ("pinned"): the first call attempts the read and caches whatever
+     * it finds (including a `null` miss/failure); every later call in the same
+     * session reuses that cached result without touching disk again. Returns
+     * `null` when no file exists at the configured/default path, the file
+     * cannot be read, or its contents fail `parseRouterBiasSnapshot`'s schema
+     * validation -- never throws.
+     */
+    private _getReasoningRouterBiasSnapshot;
+    /**
+     * Locally derives the same three bounded, privacy-safe feedback-ledger
+     * features (`lenBucket`, `hadFence`, `hadDiff`) the v4 classifier computes
+     * internally (reasoning-router-v4.ts keeps those helpers file-private, so
+     * they cannot be imported here). Mirrors reasoning-router-v2.ts's
+     * `clampLenBucket` and reasoning-router-v4.ts's `hasCodeFence`/
+     * `hasDiffMarkers` byte-for-byte. Operates on the same trimmed prompt text
+     * the classifier scores; never returns raw prompt content or its exact
+     * length, only the clamped [0,7] bucket and two booleans.
+     */
+    private _deriveRouterFeedbackFeatures;
+    /**
+     * Context-pressure band 0..3 from the projected token estimate over the
+     * model context window (reuses estimateProjectedContextTokens). 0..<0.5,
+     * 1..<0.75, 2..<0.9, 3..>=0.9. Inert under DEFAULT_WEIGHTS (no pressure
+     * coefficient); computed for future calibrated weight presets.
+     */
+    private _computePressureBucket;
     /**
      * Cycle to next thinking level.
      * @returns New level, or undefined if model doesn't support thinking