opencode-matrixx-v2 0.0.0-stage → 1.0.0

package/dist/hooks/start-work/plan-filter.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Staleness-aware plan classification for start-work.
+ *
+ * Replaces the bare `!getPlanProgress(p).isComplete` predicate: archived
+ * plans are excluded, `total==0 needsTriage` plans leave the actionable set,
+ * and mtime-stale plans with no linked active tasks are demoted to stale
+ * candidates instead of hijacking auto-select.
+ */
+import type { MatrixxConfig } from "../../config/schema";
+/** Plans under this segment are archived candidates (see Task 6); never listed. */
+export declare const ARCHIVED_PLAN_SEGMENT = "_archive";
+export declare function isArchivedPlan(planPath: string): boolean;
+/** Age of a plan file in ms since last write (mtime). Null when unstatable. */
+export declare function getPlanAgeMs(planPath: string): number | null;
+/**
+ * Stale threshold in ms from plugin config.
+ * `tasks.stale_after_hours` (default 24h, legacy `morpheus.tasks.*`).
+ */
+export declare function getPlansStaleAfterMs(config?: Partial<MatrixxConfig>): number;
+/** A plan whose file cannot be stat'ed is treated as fresh (not stale). */
+export declare function isPlanStale(planPath: string, staleAfterMs: number): boolean;
+/** Human-readable age, e.g. "3h", "2d". Clamped at zero for clock skew. */
+export declare function formatPlanAge(ageMs: number): string;
+export interface ClassifyPlansOptions {
+    staleAfterMs?: number;
+    /**
+     * True when the plan still has linked active tasks. Defaults to false
+     * (stale by mtime alone); the Task 6 reconciler wires the real linkage.
+     */
+    hasLinkedActiveTasks?: (planPath: string) => boolean;
+}
+export interface ClassifiedPlans {
+    /** Fresh incomplete plans — the only auto-select candidates. */
+    actionable: string[];
+    /** Mtime-stale incomplete plans — shown under a stale-candidate section. */
+    staleCandidates: string[];
+    /** total==0 plans — shown with a needsTriage tag, never actionable. */
+    triage: string[];
+    completed: string[];
+}
+/** One plan whose front-matter status disagrees with its checkboxes. */
+export interface PlanMismatchWarning {
+    planPath: string;
+    warning: string;
+}
+/**
+ * Read-only overlay scan: verdict per plan, warnings only for mismatches.
+ *
+ * Plans without front-matter are skipped (nothing authoritative to agree
+ * with); checkbox counts are never recomputed here beyond the overlay's
+ * single-counter delegation. Buckets in `classifyPlans` are untouched.
+ */
+export declare function collectCompletionMismatchWarnings(plans: string[]): PlanMismatchWarning[];
+/**
+ * Split plans into actionable / stale-candidate / triage / completed.
+ * Input order (findOraclePlans mtime newest-first) is preserved per bucket.
+ */
+export declare function classifyPlans(plans: string[], opts?: ClassifyPlansOptions): ClassifiedPlans;
+export type PlanListTag = "stale" | "needsTriage" | "mismatch";
+/** One numbered plan line: progress + mtime age + optional tag. */
+export declare function formatPlanListLine(planPath: string, index: number, tag?: PlanListTag): string;

package/dist/hooks/start-work/start-work-hook.d.ts

@@ -0,0 +1,16 @@
+import type { MatrixxContext } from "../../plugin/context";
+export declare const HOOK_NAME: "start-work";
+interface StartWorkHookInput {
+    sessionID: string;
+    messageID?: string;
+}
+interface StartWorkHookOutput {
+    parts: Array<{
+        type: string;
+        text?: string;
+    }>;
+}
+export declare function createStartWorkHook(ctx: MatrixxContext): {
+    "chat.message": (input: StartWorkHookInput, output: StartWorkHookOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/stop-continuation-guard/hook.d.ts

@@ -0,0 +1,19 @@
+import type { NativePluginContext } from "../../shared/session-context-source";
+interface StopContinuationGuardOptions {
+    backgroundManager?: {
+        cancelAllForSession: (sessionID: string) => number;
+    };
+    isAwaitingUser?: (sessionID: string) => boolean;
+}
+import type { V2Event } from "../../plugin/context";
+export interface StopContinuationGuard {
+    event: (event: V2Event) => Promise<void>;
+    "chat.message": (input: {
+        sessionID?: string;
+    }) => Promise<void>;
+    stop: (sessionID: string) => Promise<void>;
+    isStopped: (sessionID: string) => boolean;
+    clear: (sessionID: string) => void;
+}
+export declare function createStopContinuationGuardHook(ctx: NativePluginContext, options?: StopContinuationGuardOptions): StopContinuationGuard;
+export {};

package/dist/hooks/subagent-block/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const HOOK_NAME = "subagent-block";
+export declare const BLOCK_MESSAGE = "[subagent-block] Native subagent tool is blocked. Use task tool instead (category or subagent_type + load_skills) to spawn agents so execution stays tracked and visible to background_output/background_wait_all.";
+export declare const BYPASS_LOG_PREFIX = "[subagent-block] allowlist bypass";

package/dist/hooks/subagent-block/hook.d.ts

@@ -0,0 +1,16 @@
+import type { SubagentBlockConfigInput } from "../../config/schema/subagent-block";
+import type { MatrixxContext } from "../../plugin/context";
+import type { Hooks } from "../../plugin/legacy-hooks";
+export interface SubagentBlockHookOptions {
+    readonly allowlist?: readonly string[];
+}
+/** Structural view of the context shapes that may carry the allowlist. */
+interface AllowlistCarrier {
+    readonly subagent_block?: SubagentBlockConfigInput | null;
+    readonly config?: {
+        readonly subagent_block?: SubagentBlockConfigInput | null;
+    } | null;
+}
+export type SubagentBlockContext = MatrixxContext & AllowlistCarrier;
+export declare function createSubagentBlockHook(ctx: SubagentBlockContext, options?: SubagentBlockHookOptions): Hooks;
+export {};

package/dist/hooks/task-continuation-enforcer/abort-detection.d.ts

@@ -0,0 +1,2 @@
+import type { MessageInfo } from "./types";
+export declare function isLastAssistantMessageAborted(messages: Array<MessageInfo>): boolean;

package/dist/hooks/task-continuation-enforcer/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const HOOK_NAME = "task-continuation-enforcer";
+export declare const DEFAULT_SKIP_AGENTS: string[];
+export declare const CONTINUATION_PROMPT: string;
+export declare const COUNTDOWN_SECONDS = 2;
+export declare const COUNTDOWN_GRACE_PERIOD_MS = 500;
+export declare const ABORT_WINDOW_MS = 3000;
+export declare const CONTINUATION_COOLDOWN_MS = 30000;
+export declare const MAX_CONSECUTIVE_FAILURES = 5;
+export declare const FAILURE_RESET_WINDOW_MS: number;

package/dist/hooks/task-continuation-enforcer/continuation-injection.d.ts

@@ -0,0 +1,14 @@
+import type { MatrixxConfig } from "../../config/schema";
+import type { BackgroundManager } from "../../features/background-agent";
+import type { NativePluginContext } from "../../shared/session-context-source";
+import type { SessionStateStore } from "./session-state";
+import type { ResolvedMessageInfo } from "./types";
+export declare function injectContinuation(args: {
+    ctx: NativePluginContext;
+    sessionID: string;
+    backgroundManager?: BackgroundManager;
+    skipAgents?: string[];
+    resolvedInfo?: ResolvedMessageInfo;
+    sessionStateStore: SessionStateStore;
+    config?: Partial<MatrixxConfig>;
+}): Promise<void>;

package/dist/hooks/task-continuation-enforcer/countdown.d.ts

@@ -0,0 +1,16 @@
+import type { MatrixxConfig } from "../../config/schema";
+import type { BackgroundManager } from "../../features/background-agent";
+import type { NativePluginContext } from "../../shared/session-context-source";
+import type { SessionStateStore } from "./session-state";
+import type { ResolvedMessageInfo } from "./types";
+export declare function startCountdown(args: {
+    ctx: NativePluginContext;
+    sessionID: string;
+    incompleteCount: number;
+    total: number;
+    resolvedInfo?: ResolvedMessageInfo;
+    backgroundManager?: BackgroundManager;
+    skipAgents: string[];
+    sessionStateStore: SessionStateStore;
+    config?: Partial<MatrixxConfig>;
+}): void;

package/dist/hooks/task-continuation-enforcer/handler.d.ts

@@ -0,0 +1,13 @@
+import type { MatrixxConfig } from "../../config/schema";
+import type { BackgroundManager } from "../../features/background-agent";
+import type { V2Event } from "../../plugin/context";
+import type { NativePluginContext } from "../../shared/session-context-source";
+import type { SessionStateStore } from "./session-state";
+export declare function createTaskContinuationHandler(args: {
+    ctx: NativePluginContext;
+    sessionStateStore: SessionStateStore;
+    backgroundManager?: BackgroundManager;
+    skipAgents?: string[];
+    isContinuationStopped?: (sessionID: string) => boolean;
+    config?: Partial<MatrixxConfig>;
+}): (event: V2Event) => Promise<void>;

package/dist/hooks/task-continuation-enforcer/idle-event.d.ts

@@ -0,0 +1,13 @@
+import type { MatrixxConfig } from "../../config/schema";
+import type { BackgroundManager } from "../../features/background-agent";
+import type { NativePluginContext } from "../../shared/session-context-source";
+import type { SessionStateStore } from "./session-state";
+export declare function handleSessionIdle(args: {
+    ctx: NativePluginContext;
+    sessionID: string;
+    sessionStateStore: SessionStateStore;
+    backgroundManager?: BackgroundManager;
+    skipAgents?: string[];
+    isContinuationStopped?: (sessionID: string) => boolean;
+    config?: Partial<MatrixxConfig>;
+}): Promise<void>;

package/dist/hooks/task-continuation-enforcer/index.d.ts

@@ -0,0 +1,5 @@
+import type { NativePluginContext } from "../../shared/session-context-source";
+import type { TaskContinuationEnforcer, TaskContinuationEnforcerOptions } from "./types";
+export { createTaskContinuationHandler } from "./handler";
+export type { TaskContinuationEnforcer, TaskContinuationEnforcerOptions } from "./types";
+export declare function createTaskContinuationEnforcer(ctx: NativePluginContext, options?: TaskContinuationEnforcerOptions): TaskContinuationEnforcer;

package/dist/hooks/task-continuation-enforcer/non-idle-events.d.ts

@@ -0,0 +1,6 @@
+import type { SessionStateStore } from "./session-state";
+export declare function handleNonIdleEvent(args: {
+    eventType: string;
+    properties: Record<string, unknown> | undefined;
+    sessionStateStore: SessionStateStore;
+}): void;

package/dist/hooks/task-continuation-enforcer/session-state.d.ts

@@ -0,0 +1,10 @@
+import type { SessionState } from "./types";
+export interface SessionStateStore {
+    getState: (sessionID: string) => SessionState;
+    getExistingState: (sessionID: string) => SessionState | undefined;
+    cancelCountdown: (sessionID: string) => void;
+    cleanup: (sessionID: string) => void;
+    cancelAllCountdowns: () => void;
+    shutdown: () => void;
+}
+export declare function createSessionStateStore(): SessionStateStore;

package/dist/hooks/task-continuation-enforcer/staleness.d.ts

@@ -0,0 +1,32 @@
+import type { MatrixxConfig } from "../../config/schema";
+import type { Task } from "../../features/task-storage/types";
+export declare const DEFAULT_STALE_AFTER_HOURS = 24;
+export { DEFAULT_BACKGROUND_STALE_AFTER_HOURS } from "../../shared/task-system-gating";
+/**
+ * Resolve the stale threshold (ms) from plugin config.
+ * `tasks.stale_after_hours` (default 24h, legacy `morpheus.tasks.stale_after_hours`) — a pending task whose
+ * task file has had no write activity for longer than this is "stale".
+ */
+export declare function getStaleAfterMs(config?: Partial<MatrixxConfig>): number;
+/**
+ * Resolve the background completion-gate threshold (ms) from plugin config.
+ * `tasks.background_stale_after_hours` (default 2h, canonical only) — the same
+ * mtime basis as `getStaleAfterMs`, but a much shorter window because a task
+ * held `pending`/`in_progress` with no file activity is a far stronger signal
+ * when it is blocking a background handle than when it is merely delaying a
+ * continuation nudge. The enforcer's 24h default deliberately stays at 24.
+ */
+export declare function getBackgroundStaleAfterMs(config?: Partial<MatrixxConfig>): number;
+/**
+ * Age of a task file in ms since last write (mtime). Returns null when the
+ * file cannot be stat'ed (missing/unreadable) — callers treat null as "not stale".
+ */
+export declare function getTaskAgeMs(taskPath: string): number | null;
+export declare function isTaskStale(taskPath: string, staleAfterMs: number): boolean;
+/**
+ * Filter incomplete tasks down to the ones that are still fresh (not stale).
+ * A task whose file cannot be stat'ed is treated as fresh (not stale).
+ */
+export declare function filterFreshIncompleteTasks(tasks: Task[], taskDir: string, staleAfterMs: number): Task[];
+/** Human-readable age, e.g. "3h", "2d". */
+export declare function formatTaskAge(ageMs: number): string;

package/dist/hooks/task-continuation-enforcer/todo.d.ts

@@ -0,0 +1,29 @@
+import type { Task } from "../../features/task-storage/types";
+export declare function getIncompleteCount(todos: {
+    status: string;
+}[]): number;
+export declare function getIncompleteTasks(tasks: Task[]): Task[];
+export declare function getIncompleteTaskCount(tasks: Task[]): number;
+export interface SessionFilterOptions {
+    sessionID: string;
+    /** LIVE subagent session ids (dead/unregistered subagents are excluded). */
+    subagentIDs: string[];
+    sessionScoped?: boolean;
+}
+/**
+ * Drop subtasks whose parent task is already resolved (completed/deleted).
+ * A task is dropped only when its `parentID` resolves to a task in the full
+ * input array whose status is "completed" or "deleted". Tasks without a
+ * parentID, or whose parent is missing from the input, are kept.
+ */
+export declare function dropSubtasksWithResolvedParent(tasks: Task[]): Task[];
+/**
+ * Filter tasks by session scope.
+ * - When sessionScoped=false: all tasks pass through (opt-out / legacy behavior)
+ * - Current session's tasks (threadID === sessionID) are included
+ * - Subagent session tasks (threadID in subagentIDs) are included
+ * - Tasks with no threadID are excluded: threadID is required by TaskObjectSchema, so
+ *   an unattributed task cannot be attributed and is not claimed by any session
+ * - All other tasks are excluded
+ */
+export declare function filterTasksBySession(tasks: Task[], options: SessionFilterOptions): Task[];

package/dist/hooks/task-continuation-enforcer/types.d.ts

@@ -0,0 +1,54 @@
+import type { MatrixxConfig } from "../../config/schema";
+import type { BackgroundManager } from "../../features/background-agent";
+import type { ToolPermission } from "../../features/hook-message-injector";
+import type { V2Event } from "../../plugin/context";
+export interface TaskContinuationEnforcerOptions {
+    backgroundManager?: BackgroundManager;
+    skipAgents?: string[];
+    isContinuationStopped?: (sessionID: string) => boolean;
+    /** Plugin config — used for task storage resolution and stale-task threshold. */
+    config?: Partial<MatrixxConfig>;
+}
+export interface TaskContinuationEnforcer {
+    handler: (event: V2Event) => Promise<void>;
+    markRecovering: (sessionID: string) => void;
+    markRecoveryComplete: (sessionID: string) => void;
+    cancelAllCountdowns: () => void;
+    isAwaitingUser: (sessionID: string) => boolean;
+}
+export interface SessionState {
+    countdownTimer?: ReturnType<typeof setTimeout>;
+    countdownInterval?: ReturnType<typeof setInterval>;
+    isRecovering?: boolean;
+    countdownStartedAt?: number;
+    abortDetectedAt?: number;
+    consecutiveFailures?: number;
+    lastInjectedAt?: number;
+    inFlight?: boolean;
+    awaitingUser?: boolean;
+    awaitingUserSince?: number;
+}
+export interface MessageInfo {
+    id?: string;
+    role?: string;
+    error?: {
+        name?: string;
+        data?: unknown;
+    } | undefined;
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+    providerID?: string;
+    modelID?: string;
+    tools?: Record<string, ToolPermission>;
+}
+export interface ResolvedMessageInfo {
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+    tools?: Record<string, ToolPermission>;
+}

package/dist/hooks/task-edit-guard/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const HOOK_NAME = "task-edit-guard";
+export declare const BLOCKED_PATTERNS: RegExp[];
+export declare const PLAN_WRITE_WARN = "[task-edit-guard] BLOCKED: Use plan_* tools (plan_create/read/update/list/delete) for .matrixx/plans/*.md \u2014 generic Write/Edit is blocked. Prefer plan_* for atomic, hashline-validated plan edits.";
+export declare const PLAN_READ_WARN = "[task-edit-guard] BLOCKED: Use plan_read for .matrixx/plans/*.md \u2014 generic Read is blocked. plan_read returns hashline-tagged output (plan_list for discovery); pair with plan_update for atomic, hashline-validated plan edits.";

package/dist/hooks/task-edit-guard/hook.d.ts

@@ -0,0 +1,3 @@
+import type { MatrixxContext } from "../../plugin/context";
+import type { Hooks } from "../../plugin/legacy-hooks";
+export declare function createTaskEditGuardHook(ctx: MatrixxContext): Hooks;

package/dist/hooks/task-notepad-writer/constants.d.ts

@@ -0,0 +1,42 @@
+export declare const HOOK_NAME = "task-notepad-writer";
+export declare const MATRIXX_DIR_NAME = ".matrixx";
+export declare const PLANS_SUBDIR = "plans";
+export declare const NOTEPADS_SUBDIR = "notepads";
+export declare const PLAN_EXTENSION = ".md";
+export declare const NOTEPAD_EXTENSION = ".md";
+export declare const ADHOC_BUCKET = "adhoc";
+export declare const TASK_CREATE_TOOL = "task_create";
+export declare const TASK_UPDATE_TOOL = "task_update";
+export declare const COMPLETED_STATUS = "completed";
+export declare const DEFAULT_PRIORITY = "medium";
+export declare const COMPLETION_SECTION_TITLE = "## Completion";
+export declare const PLAN_NAME_METADATA_KEY = "planName";
+export declare const SLUG_MAX_LENGTH = 60;
+export declare const NOTEPAD_SECTIONS: readonly [{
+    readonly heading: "## Findings";
+    readonly body: "(Record what you learn about this code as you work — patterns, conventions, gotchas, useful references.)";
+}, {
+    readonly heading: "## Blockers";
+    readonly body: "(Anything blocking progress. Be specific: file path, line, error, workaround if any.)";
+}, {
+    readonly heading: "## Questions";
+    readonly body: "(Open questions to revisit later. Don't lose them when context compacts.)";
+}, {
+    readonly heading: "## Results";
+    readonly body: "(Summary on completion. What changed, what was verified, what remains.)";
+}];
+/**
+ * The header's `**Task ID**: <id>` line is the durable idempotency marker: it
+ * lives inside the file, so a lookup finds the same notepad across process
+ * restarts, with no in-memory bookkeeping to lose.
+ */
+export declare function taskIdMarkerLine(taskId: string): string;
+export declare function taskIdMarkerPresent(content: string, taskId: string): boolean;
+export declare function renderNotepad(input: {
+    subject: string;
+    taskId: string;
+    priority?: string | undefined;
+    status?: string | undefined;
+    startedAt: string;
+}): string;
+export declare function renderCompletionStamp(completedAt: string): string;

package/dist/hooks/task-notepad-writer/hook.d.ts

@@ -0,0 +1,14 @@
+import { type TaskNotepadWriterContext } from "./notepad-path";
+export interface ToolAfterInput {
+    tool: string;
+    sessionID: string;
+    callID: string;
+}
+export interface ToolAfterOutput {
+    title: string;
+    output: string;
+    metadata?: Record<string, unknown>;
+}
+export declare function createTaskNotepadWriterHook(ctx: TaskNotepadWriterContext): {
+    "tool.execute.after": (input: ToolAfterInput, output: ToolAfterOutput | undefined) => Promise<void>;
+};

package/dist/hooks/task-notepad-writer/notepad-path.d.ts

@@ -0,0 +1,36 @@
+import type { MatrixxConfig } from "../../config/schema";
+import type { MatrixxContext } from "../../plugin/context";
+export type TaskNotepadWriterContext = MatrixxContext & {
+    config?: Partial<MatrixxConfig>;
+};
+export interface NotepadTask {
+    id: string;
+    subject: string;
+    metadata?: Record<string, unknown> | undefined;
+    status?: string | undefined;
+    priority?: string | undefined;
+}
+export type BucketReason = "plan-file-exists" | "no-plan-name" | "plan-file-missing";
+export interface NotepadResolution {
+    bucketDir: string;
+    filePath: string;
+    reason: BucketReason;
+}
+export declare function notepadsRootFor(directory: string): string;
+export declare function extractPlanName(task: NotepadTask): string | null;
+export declare function slugifySubject(subject: string, fallback: string): string;
+export declare function countNotepadFiles(bucketDir: string): number;
+export declare function resolveNotepadPath(input: {
+    ctx: TaskNotepadWriterContext;
+    task: NotepadTask;
+    notepadRoot: string;
+}): NotepadResolution;
+export declare function findExistingNotepadForTask(bucketDir: string, taskId: string): string | null;
+export declare function findNotepadForTask(input: {
+    ctx: TaskNotepadWriterContext;
+    task: NotepadTask;
+    notepadRoot: string;
+}): {
+    filePath: string;
+    bucketDir: string;
+} | null;

package/dist/hooks/task-resume-info/hook.d.ts

@@ -0,0 +1,11 @@
+export declare function createTaskResumeInfoHook(): {
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+};

package/dist/hooks/think-mode/detector.d.ts

@@ -0,0 +1,5 @@
+export declare function detectThinkKeyword(text: string): boolean;
+export declare function extractPromptText(parts: Array<{
+    type: string;
+    text?: string;
+}>): string;

package/dist/hooks/think-mode/hook.d.ts

@@ -0,0 +1,11 @@
+import type { ThinkModeInput, ThinkModeState } from "./types";
+import type { V2Event } from "../../plugin/context";
+export declare function setThinkModeState(key: string, value: ThinkModeState): void;
+export declare function getThinkModeState(key: string): ThinkModeState | undefined;
+export declare function _getThinkModeStateSizeForTesting(): number;
+export declare function _resetThinkModeStateForTesting(): void;
+export declare function clearThinkModeState(sessionID: string): void;
+export declare function createThinkModeHook(): {
+    "chat.params": (output: ThinkModeInput, sessionID: string) => Promise<void>;
+    event: (event: V2Event) => Promise<void>;
+};

package/dist/hooks/think-mode/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./detector";
+export { _getThinkModeStateSizeForTesting, _resetThinkModeStateForTesting, clearThinkModeState, createThinkModeHook, getThinkModeState, setThinkModeState, } from "./hook";
+export * from "./switcher";
+export * from "./types";

package/dist/hooks/think-mode/switcher.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Think Mode Switcher
+ *
+ * This module handles "thinking mode" activation for reasoning-capable models.
+ * When a user includes "think" keywords in their prompt, models are upgraded to
+ * their high-reasoning variants with extended thinking budgets.
+ *
+ * PROVIDER ALIASING:
+ * GitHub Copilot acts as a proxy provider that routes to underlying providers
+ * (Anthropic, Google, OpenAI). We resolve the proxy to the actual provider
+ * based on model name patterns, allowing GitHub Copilot to inherit thinking
+ * configurations without duplication.
+ *
+ * NORMALIZATION:
+ * Model IDs are normalized (dots → hyphens in version numbers) to handle API
+ * inconsistencies defensively while maintaining backwards compatibility.
+ */
+export declare function _resetNormalizeModelCacheForTesting(): void;
+export declare const THINKING_CONFIGS: {
+    readonly anthropic: {
+        readonly thinking: {
+            readonly type: "enabled";
+            readonly budgetTokens: 32000;
+        };
+        readonly maxTokens: 64000;
+    };
+    readonly "google-vertex-anthropic": {
+        readonly thinking: {
+            readonly type: "enabled";
+            readonly budgetTokens: 32000;
+        };
+        readonly maxTokens: 64000;
+    };
+    readonly "amazon-bedrock": {
+        readonly reasoningConfig: {
+            readonly type: "enabled";
+            readonly budgetTokens: 16000;
+        };
+        readonly maxTokens: 32000;
+    };
+    readonly google: {
+        readonly providerOptions: {
+            readonly google: {
+                readonly thinkingConfig: {
+                    readonly thinkingLevel: "HIGH";
+                };
+            };
+        };
+    };
+    readonly "google-vertex": {
+        readonly providerOptions: {
+            readonly "google-vertex": {
+                readonly thinkingConfig: {
+                    readonly thinkingLevel: "HIGH";
+                };
+            };
+        };
+    };
+    readonly openai: {
+        readonly reasoning_effort: "high";
+    };
+    readonly "zai-coding-plan": {
+        readonly providerOptions: {
+            readonly "zai-coding-plan": {
+                readonly extra_body: {
+                    readonly thinking: {
+                        readonly type: "disabled";
+                    };
+                };
+            };
+        };
+    };
+};
+export declare function getHighVariant(modelID: string): string | null;
+export declare function isAlreadyHighVariant(modelID: string): boolean;
+export declare function getThinkingConfig(providerID: string, modelID: string): Record<string, unknown> | null;

package/dist/hooks/think-mode/types.d.ts

@@ -0,0 +1,25 @@
+export interface ThinkModeState {
+    requested: boolean;
+    modelSwitched: boolean;
+    thinkingConfigInjected: boolean;
+    providerID?: string;
+    modelID?: string;
+}
+interface ModelRef {
+    providerID: string;
+    modelID: string;
+}
+interface MessageWithModel {
+    model?: ModelRef;
+    tool_choice?: unknown;
+    toolChoice?: unknown;
+    tools?: unknown[];
+}
+export interface ThinkModeInput {
+    parts: Array<{
+        type: string;
+        text?: string;
+    }>;
+    message: MessageWithModel;
+}
+export {};

package/dist/hooks/thinking-block-validator/flat.d.ts

@@ -0,0 +1,24 @@
+export interface FlatContentPart {
+    type?: string;
+    text?: string;
+    thinking?: string;
+    synthetic?: boolean;
+    [key: string]: unknown;
+}
+export interface FlatMessage {
+    id?: string;
+    role?: string;
+    type?: string;
+    text?: string;
+    content?: FlatContentPart[];
+    model?: unknown;
+    [key: string]: unknown;
+}
+export interface FlatSessionEvent {
+    readonly sessionID?: string;
+    readonly kind?: string;
+    readonly model?: unknown;
+    readonly messages?: FlatMessage[] | unknown;
+    readonly [key: string]: unknown;
+}
+export declare function applyThinkingBlockValidator(event: FlatSessionEvent): Promise<void>;