pi-adaptive-thinking 0.1.1 → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright 2026 Ian Pascoe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -6,7 +6,9 @@ Bring adaptive reasoning-effort control to Pi agents.
 
 </div>
 
-`pi-adaptive-thinking` is a Pi extension that lets the agent change Pi's thinking level through a tool named `set_thinking_level`.
+`pi-adaptive-thinking` is a Pi extension that lets the agent inspect and change Pi's thinking level through tools named `get_thinking_level` and `set_thinking_level`.
+
+Requires Node `>=22.19.0` and Pi `>=0.84.1`.
 
 It mirrors the user-facing behavior of `opencode-adaptive-thinking` while using Pi-native APIs: `pi.getThinkingLevel()`, `pi.setThinkingLevel()`, and `thinking_level_select`.
 
@@ -20,13 +22,14 @@ For local development:
 
 ```bash
 pnpm install
-pnpm build
-pi -e ./dist/index.js
+pi -e ./src/index.ts
 ```
 
 ## Behavior
 
-The extension registers a tool with these parameters:
+The extension registers two tools. `get_thinking_level` returns the current native Pi thinking level and the levels supported by the selected model. The agent should inspect status only when the level is uncertain, not poll it every turn.
+
+`set_thinking_level` accepts these parameters:
 
 - `level`: one of the valid Pi thinking levels for the current model.
 - `persist`: optional boolean, default `false`.
@@ -47,6 +50,8 @@ Persistent changes:
 
 This changes the session baseline until another persistent change is made or the user changes thinking level manually.
 
+The extension contributes only static tool guidance to Pi's base prompt. It never replaces the per-turn system prompt, so current level, supported levels, model, and session state cannot invalidate the system-prompt cache prefix.
+
 ## Configuration
 
 Configuration files are loaded in this order:
@@ -63,10 +68,15 @@ Project configuration takes precedence over global configuration.
   "quiet": false,
   "toolName": "set_thinking_level",
   "toolDescription": "Set your thinking level",
-  "systemPrompt": "You MUST manage thinking level actively. Lower it before trivial or routine turns; raise it for ambiguity, debugging, risky changes, or multi-step synthesis. Reassess at turn start, after meaningful new evidence, and when the task shifts. NEVER leave the current level unchanged by inertia, and NEVER reply to a trivial turn before considering a downshift."
+  "statusToolName": "get_thinking_level",
+  "guidance": "You MUST manage thinking level actively. Lower it before trivial or routine turns; raise it for ambiguity, debugging, risky changes, or multi-step synthesis. Reassess at turn start, after meaningful new evidence, and when the task shifts. NEVER leave the current level unchanged by inertia, and NEVER reply to a trivial turn before considering a downshift."
 }
 ```
 
+`guidance`, tool names, and tool descriptions are loaded once per session and remain static. Do not put runtime state in `guidance`.
+
+The former `systemPrompt` field remains a deprecated alias for `guidance` during the `0.x` release line. Existing configurations continue to work and produce one UI warning at session start unless `quiet` is enabled. A configuration containing both fields is invalid.
+
 ## Development
 
 ```bash
@@ -75,7 +85,6 @@ pnpm format:check
 pnpm lint
 pnpm typecheck
 pnpm test
-pnpm build
 ```
 
 Run all checks:

package/package.json

@@ -1,38 +1,32 @@
 {
   "name": "pi-adaptive-thinking",
-  "version": "0.1.1",
-  "description": "Pi Adaptive Thinking extension",
+  "version": "0.2.0",
+  "private": false,
+  "description": "Pi extension for adaptive reasoning-effort control",
   "keywords": [
     "adaptive-thinking",
     "pi",
+    "pi-extension",
     "pi-package",
-    "reasoning",
     "thinking"
   ],
-  "homepage": "https://github.com/ian-pascoe/pi-adaptive-thinking#readme",
+  "homepage": "https://github.com/ian-pascoe/pi-extensions#readme",
   "bugs": {
-    "url": "https://github.com/ian-pascoe/pi-adaptive-thinking/issues"
+    "url": "https://github.com/ian-pascoe/pi-extensions/issues"
   },
   "license": "MIT",
-  "author": "Ian Pascoe",
+  "author": "Ian Pascoe <ian.g.pascoe@gmail.com>",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/ian-pascoe/pi-adaptive-thinking.git"
+    "url": "git+https://github.com/ian-pascoe/pi-extensions.git",
+    "directory": "packages/pi-adaptive-thinking"
   },
   "files": [
-    "dist",
-    "README.md"
+    "src",
+    "README.md",
+    "LICENSE"
   ],
   "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
-    }
-  },
   "publishConfig": {
     "access": "public",
     "provenance": true
@@ -41,43 +35,23 @@
     "proper-lockfile": "^4.1.2"
   },
   "devDependencies": {
-    "@changesets/changelog-github": "^0.7.0",
-    "@changesets/cli": "^2.31.0",
-    "@types/node": "^25.9.1",
-    "@types/proper-lockfile": "^4.1.4",
-    "@typescript/native-preview": "7.0.0-dev.20260526.1",
-    "husky": "^9.1.7",
-    "oxfmt": "^0.52.0",
-    "oxlint": "^1.67.0",
-    "rolldown": "1.0.2",
-    "typescript": "^6.0.3",
-    "vitest": "^4.1.7"
+    "@types/proper-lockfile": "4.1.4"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",
     "@earendil-works/pi-coding-agent": "*",
     "typebox": "*"
   },
+  "engines": {
+    "node": ">=22.19.0"
+  },
   "pi": {
     "extensions": [
-      "./dist/index.js"
+      "./src/index.ts"
     ]
   },
   "scripts": {
-    "build": "pnpm run clean && pnpm run build:js && pnpm run build:types",
-    "build:js": "rolldown -c",
-    "build:types": "tsgo --project tsconfig.build.json --emitDeclarationOnly",
-    "build:watch": "rolldown -c -w",
-    "changeset": "changeset",
-    "clean": "rm -rf dist",
-    "format": "oxfmt",
-    "format:check": "oxfmt --check",
-    "lint": "oxlint",
-    "lint:fix": "oxlint --fix",
-    "release": "pnpm run build && changeset publish",
-    "test": "vitest run",
-    "typecheck": "tsgo --noEmit",
-    "verify": "pnpm run format:check && pnpm run lint && pnpm run typecheck && pnpm run test && pnpm run build",
-    "version-packages": "changeset version"
+    "test": "vitest run --config ../../vitest.config.ts --root .",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
   }
 }

package/src/config-loader.ts

@@ -0,0 +1,66 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { parseConfig, usesDeprecatedSystemPrompt, type AdaptiveThinkingConfig } from "./config.js";
+
+export type { AdaptiveThinkingConfig } from "./config.js";
+
+export type LoadConfigOptions = {
+  cwd: string;
+  homeDir?: string;
+};
+
+export type LoadConfigResult =
+  | {
+      success: true;
+      config: AdaptiveThinkingConfig;
+      source?: string;
+      usedDeprecatedSystemPrompt?: true;
+    }
+  | { success: false; source: string; error: Error };
+
+const hasCode = (error: unknown, code: string) => {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+};
+
+const errorMessage = (error: unknown) => (error instanceof Error ? error.message : String(error));
+
+const invalidConfig = (source: string, error: unknown): LoadConfigResult => ({
+  success: false,
+  source,
+  error: new Error(`Invalid Adaptive Thinking configuration in ${source}: ${errorMessage(error)}`),
+});
+
+export const loadConfig = async ({
+  cwd,
+  homeDir = homedir(),
+}: LoadConfigOptions): Promise<LoadConfigResult> => {
+  const candidates = [
+    join(cwd, ".pi", "adaptive-thinking.json"),
+    join(homeDir, ".pi", "agent", "adaptive-thinking.json"),
+  ];
+
+  for (const source of candidates) {
+    let raw: string;
+    try {
+      raw = await readFile(source, "utf8");
+    } catch (error) {
+      if (hasCode(error, "ENOENT")) continue;
+      return invalidConfig(source, error);
+    }
+
+    try {
+      const input: unknown = JSON.parse(raw);
+      return {
+        success: true,
+        source,
+        config: parseConfig(input),
+        ...(usesDeprecatedSystemPrompt(input) ? { usedDeprecatedSystemPrompt: true as const } : {}),
+      };
+    } catch (error) {
+      return invalidConfig(source, error);
+    }
+  }
+
+  return { success: true, config: parseConfig(undefined) };
+};

package/src/config.ts

@@ -0,0 +1,72 @@
+import { Type } from "typebox";
+import { Parse } from "typebox/value";
+
+export const defaultGuidance =
+  "You MUST manage thinking level actively. " +
+  "Lower it before trivial or routine turns; raise it for ambiguity, debugging, risky changes, or multi-step synthesis. " +
+  "Reassess at turn start, after meaningful new evidence, and when the task shifts. " +
+  "NEVER leave the current level unchanged by inertia, and NEVER reply to a trivial turn before considering a downshift.";
+
+export type AdaptiveThinkingConfig = {
+  enabled: boolean;
+  quiet: boolean;
+  toolName: string;
+  toolDescription: string;
+  statusToolName: string;
+  guidance: string;
+};
+
+export const configDefaults: AdaptiveThinkingConfig = {
+  enabled: true,
+  quiet: false,
+  toolName: "set_thinking_level",
+  toolDescription: "Set your thinking level",
+  statusToolName: "get_thinking_level",
+  guidance: defaultGuidance,
+};
+
+const ConfigInputSchema = Type.Object(
+  {
+    enabled: Type.Boolean(),
+    quiet: Type.Boolean(),
+    toolName: Type.String({ minLength: 1 }),
+    toolDescription: Type.String({ minLength: 1 }),
+    statusToolName: Type.String({ minLength: 1 }),
+    guidance: Type.Optional(Type.String({ minLength: 1 })),
+    systemPrompt: Type.Optional(Type.String({ minLength: 1 })),
+  },
+  { additionalProperties: false },
+);
+
+const hasOwnProperty = (input: unknown, property: string) =>
+  typeof input === "object" &&
+  input !== null &&
+  Object.prototype.hasOwnProperty.call(input, property);
+
+/** Returns whether raw configuration uses the deprecated system prompt alias. */
+export const usesDeprecatedSystemPrompt = (input: unknown) => hasOwnProperty(input, "systemPrompt");
+
+/** Parses configuration and normalizes legacy system prompt guidance. */
+export const parseConfig = (input: unknown): AdaptiveThinkingConfig => {
+  const usesGuidance = hasOwnProperty(input, "guidance");
+  const usesSystemPrompt = usesDeprecatedSystemPrompt(input);
+  if (usesGuidance && usesSystemPrompt) {
+    throw new Error(
+      "Adaptive Thinking configuration cannot contain both guidance and systemPrompt",
+    );
+  }
+
+  const rawInput = input as Record<string, unknown> | undefined;
+  const merged = {
+    ...configDefaults,
+    ...rawInput,
+    guidance: usesSystemPrompt ? rawInput?.systemPrompt : (rawInput?.guidance ?? defaultGuidance),
+  };
+  delete (merged as Record<string, unknown>).systemPrompt;
+
+  const config = Parse(ConfigInputSchema, merged) as AdaptiveThinkingConfig;
+  if (config.toolName === config.statusToolName) {
+    throw new Error("Adaptive Thinking toolName and statusToolName must be different");
+  }
+  return config;
+};

package/src/index.ts

@@ -0,0 +1,329 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import lockfile from "proper-lockfile";
+import type {
+  AgentToolResult,
+  ExtensionAPI,
+  ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { type Static, Type } from "typebox";
+import { loadConfig, type AdaptiveThinkingConfig } from "./config-loader.js";
+import {
+  isThinkingLevel,
+  resolveSupportedThinkingLevels,
+  type PiThinkingLevel,
+} from "./thinking-levels.js";
+
+type NotifyType = "info" | "warning" | "error";
+
+type RuntimeState = {
+  config: AdaptiveThinkingConfig;
+  persistedLevel?: PiThinkingLevel;
+  temporaryResetLevel?: PiThinkingLevel;
+  lastToolCallWasReasoningTool?: boolean;
+  reasoningToolCallBackToBackById: Map<string, boolean>;
+};
+
+const ToolParameters = Type.Object(
+  {
+    level: Type.String({
+      minLength: 1,
+      description:
+        "The Pi thinking level to apply. Higher levels may improve hard-task quality but may take more time and resources.",
+    }),
+    persist: Type.Optional(
+      Type.Boolean({
+        default: false,
+        description:
+          "Whether to persist the setting for this session; otherwise it applies only for the current turn.",
+      }),
+    ),
+  },
+  { additionalProperties: false },
+);
+
+type ToolParameters = Static<typeof ToolParameters>;
+
+const StatusToolParameters = Type.Object({}, { additionalProperties: false });
+
+type ThinkingLevelStatus = {
+  currentLevel: PiThinkingLevel | "unknown";
+  supportedLevels: PiThinkingLevel[];
+};
+
+const textResult = (text: string): AgentToolResult<undefined> => ({
+  content: [{ type: "text", text }],
+  details: undefined,
+});
+
+const thinkingLevelStatusResult = (
+  currentLevel: PiThinkingLevel | "unknown",
+  supportedLevels: PiThinkingLevel[],
+): AgentToolResult<ThinkingLevelStatus> => ({
+  content: [
+    {
+      type: "text",
+      text: `Current thinking level: ${currentLevel}. Supported thinking levels: ${supportedLevels.join(", ")}.`,
+    },
+  ],
+  details: { currentLevel, supportedLevels },
+});
+
+const errorMessage = (error: unknown) => (error instanceof Error ? error.message : String(error));
+
+const agentDir = () => process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".pi", "agent");
+
+const globalSettingsPath = () => join(agentDir(), "settings.json");
+
+const sleepSync = (milliseconds: number) => {
+  const end = Date.now() + milliseconds;
+  while (Date.now() < end) {
+    // Synchronous ExtensionAPI methods require a synchronous retry loop.
+  }
+};
+
+const acquireSettingsLock = (lockPath: string) => {
+  const maxAttempts = 100;
+  const delayMs = 20;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return lockfile.lockSync(lockPath, { realpath: false });
+    } catch (error) {
+      const code =
+        typeof error === "object" && error !== null && "code" in error ? error.code : undefined;
+      if (code !== "ELOCKED" || attempt === maxAttempts) throw error;
+      sleepSync(delayMs);
+    }
+  }
+
+  throw new Error(`Failed to acquire settings lock: ${lockPath}`);
+};
+
+const withSettingsLock = <T>(settingsPath: string, fn: () => T): T => {
+  mkdirSync(join(settingsPath, ".."), { recursive: true });
+  const lockPath = `${settingsPath}.adaptive-thinking`;
+  if (!existsSync(lockPath)) writeFileSync(lockPath, "");
+
+  const release = acquireSettingsLock(lockPath);
+
+  try {
+    return fn();
+  } finally {
+    release();
+  }
+};
+
+const readDefaultThinkingLevel = (settingsPath: string): PiThinkingLevel | undefined => {
+  if (!existsSync(settingsPath)) return undefined;
+
+  try {
+    const parsed = JSON.parse(readFileSync(settingsPath, "utf-8")) as {
+      defaultThinkingLevel?: unknown;
+    };
+    return typeof parsed.defaultThinkingLevel === "string" &&
+      isThinkingLevel(parsed.defaultThinkingLevel)
+      ? parsed.defaultThinkingLevel
+      : undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+const restoreDefaultThinkingLevel = (
+  settingsPath: string,
+  previousDefaultThinkingLevel: PiThinkingLevel | undefined,
+) => {
+  if (!existsSync(settingsPath)) return;
+
+  try {
+    const settings = JSON.parse(readFileSync(settingsPath, "utf-8")) as Record<string, unknown>;
+    if (previousDefaultThinkingLevel === undefined) {
+      delete settings.defaultThinkingLevel;
+    } else {
+      settings.defaultThinkingLevel = previousDefaultThinkingLevel;
+    }
+    writeFileSync(settingsPath, JSON.stringify(settings, undefined, 2) + "\n");
+  } catch {
+    return;
+  }
+};
+
+const withSessionOnlyThinkingLevelChange = (changeThinkingLevel: () => void) => {
+  const settingsPath = globalSettingsPath();
+
+  return withSettingsLock(settingsPath, () => {
+    const previousDefaultThinkingLevel = readDefaultThinkingLevel(settingsPath);
+
+    changeThinkingLevel();
+
+    restoreDefaultThinkingLevel(settingsPath, previousDefaultThinkingLevel);
+  });
+};
+
+const notify = (
+  ctx: ExtensionContext,
+  type: NotifyType,
+  message: string,
+  config?: Pick<AdaptiveThinkingConfig, "quiet">,
+) => {
+  if (config?.quiet) return;
+  if (!ctx.hasUI) return;
+  ctx.ui.notify(message, type);
+};
+
+export default function adaptiveThinking(pi: ExtensionAPI) {
+  let runtime: RuntimeState | undefined;
+  let runtimeHandlersRegistered = false;
+
+  const registerRuntimeHandlers = () => {
+    if (runtimeHandlersRegistered) return;
+    runtimeHandlersRegistered = true;
+
+    pi.on("tool_call", async (event) => {
+      const state = runtime;
+      if (!state) return;
+
+      if (event.toolName === state.config.toolName) {
+        state.reasoningToolCallBackToBackById.set(
+          event.toolCallId,
+          state.lastToolCallWasReasoningTool ?? false,
+        );
+        state.lastToolCallWasReasoningTool = true;
+      } else {
+        state.lastToolCallWasReasoningTool = false;
+      }
+    });
+
+    pi.on("agent_end", async (_event, ctx) => {
+      await resetTemporaryLevel(ctx);
+      if (!runtime) return;
+      runtime.lastToolCallWasReasoningTool = false;
+      runtime.reasoningToolCallBackToBackById.clear();
+    });
+  };
+
+  const resetTemporaryLevel = async (ctx: ExtensionContext) => {
+    const state = runtime;
+    const resetLevel = state?.temporaryResetLevel;
+    if (!state || !resetLevel) return;
+
+    try {
+      withSessionOnlyThinkingLevelChange(() => pi.setThinkingLevel(resetLevel));
+      delete state.temporaryResetLevel;
+    } catch (error) {
+      notify(ctx, "error", `Failed to reset thinking level: ${errorMessage(error)}`, state.config);
+    }
+  };
+
+  pi.on("session_start", async (_event, ctx) => {
+    const configResult = await loadConfig({ cwd: ctx.cwd });
+    if (!configResult.success) {
+      runtime = undefined;
+      notify(ctx, "error", configResult.error.message);
+      return;
+    }
+
+    const { config } = configResult;
+    if (!config.enabled) {
+      runtime = undefined;
+      return;
+    }
+
+    runtime = { config, reasoningToolCallBackToBackById: new Map() };
+
+    if (configResult.usedDeprecatedSystemPrompt) {
+      notify(
+        ctx,
+        "warning",
+        "Adaptive Thinking configuration: systemPrompt is deprecated; rename it to guidance.",
+        config,
+      );
+    }
+
+    pi.registerTool({
+      name: config.toolName,
+      label: "Set Thinking Level",
+      description: config.toolDescription,
+      promptSnippet: "Set the current Pi thinking level.",
+      promptGuidelines: [
+        config.guidance,
+        `Use ${config.toolName} to change the thinking level when task complexity justifies a different level.`,
+        `Use ${config.statusToolName} only when the current or supported thinking levels are uncertain; do not poll it routinely.`,
+        `Do not call ${config.toolName} twice in a row; reassess only after new evidence from other tool calls or user input.`,
+      ],
+      parameters: ToolParameters,
+      execute: async (toolCallId, params: ToolParameters, _signal, _onUpdate, ctx) => {
+        const state = runtime;
+        if (!state) return textResult("Adaptive Thinking is not enabled for this session.");
+
+        const level = params.level.trim();
+        const validLevels = resolveSupportedThinkingLevels(ctx.model);
+        if (!isThinkingLevel(level) || !validLevels.includes(level)) {
+          return textResult(
+            `Invalid thinking level: ${level}. Valid levels: ${validLevels.join(", ")}.`,
+          );
+        }
+
+        const persist = params.persist ?? false;
+        const currentLevel = pi.getThinkingLevel();
+        if (currentLevel === level) {
+          return textResult(`Thinking level is already ${level}; no change made.`);
+        }
+
+        if (state.reasoningToolCallBackToBackById.get(toolCallId) ?? false) {
+          return textResult(
+            `Thinking level change skipped because the previous tool call was also ${state.config.toolName}. Reassess after another tool call or new user input.`,
+          );
+        }
+
+        const resetLevel =
+          state.persistedLevel ?? (isThinkingLevel(currentLevel) ? currentLevel : undefined);
+
+        if (!persist && !resetLevel) {
+          return textResult(
+            "Cannot apply a temporary thinking level because the Session Baseline is unknown.",
+          );
+        }
+
+        try {
+          withSessionOnlyThinkingLevelChange(() => pi.setThinkingLevel(level));
+        } catch (error) {
+          return textResult(`Failed to set thinking level: ${errorMessage(error)}`);
+        }
+
+        if (persist) {
+          state.persistedLevel = level;
+          delete state.temporaryResetLevel;
+        } else if (resetLevel && resetLevel !== level) {
+          state.temporaryResetLevel = resetLevel;
+        } else {
+          delete state.temporaryResetLevel;
+        }
+
+        return textResult(`Thinking level set to ${level}`);
+      },
+    });
+
+    pi.registerTool({
+      name: config.statusToolName,
+      label: "Get Thinking Level",
+      description: "Get the current and supported Pi thinking levels",
+      promptSnippet: "Inspect the current and supported Pi thinking levels.",
+      promptGuidelines: [
+        `Use ${config.statusToolName} only when thinking-level state is uncertain; do not poll it routinely.`,
+      ],
+      parameters: StatusToolParameters,
+      execute: async (_toolCallId, _params, _signal, _onUpdate, ctx) => {
+        const currentLevel = pi.getThinkingLevel();
+        return thinkingLevelStatusResult(
+          isThinkingLevel(currentLevel) ? currentLevel : "unknown",
+          resolveSupportedThinkingLevels(ctx.model),
+        );
+      },
+    });
+
+    registerRuntimeHandlers();
+  });
+}

package/src/thinking-levels.ts

@@ -0,0 +1,28 @@
+import { getSupportedThinkingLevels } from "@earendil-works/pi-ai";
+import type { Api, Model, ModelThinkingLevel } from "@earendil-works/pi-ai";
+
+export const fallbackThinkingLevels = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+] as const;
+
+export type PiThinkingLevel = (typeof fallbackThinkingLevels)[number];
+
+const levelSet = new Set<string>(fallbackThinkingLevels);
+
+export const isThinkingLevel = (level: string): level is PiThinkingLevel => levelSet.has(level);
+
+export const resolveSupportedThinkingLevels = (
+  model: Model<Api> | undefined,
+): PiThinkingLevel[] => {
+  if (!model) return [...fallbackThinkingLevels];
+
+  return getSupportedThinkingLevels(model).filter(
+    (level: ModelThinkingLevel): level is PiThinkingLevel => isThinkingLevel(level),
+  );
+};