pi-adaptive-thinking 0.1.0 → 0.1.2

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_reasoning_effort`.
+`pi-adaptive-thinking` is a Pi extension that lets the agent change Pi's thinking level through a tool named `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,8 +22,7 @@ For local development:
 
 ```bash
 pnpm install
-pnpm build
-pi -e ./dist/index.js
+pi -e ./src/index.ts
 ```
 
 ## Behavior
@@ -37,7 +38,7 @@ Temporary changes:
 { "level": "high", "persist": false }
 ```
 
-This changes reasoning effort for the current agent turn and restores the prior/baseline level when the turn ends.
+This changes thinking level for the current agent turn and restores the prior/baseline level when the turn ends.
 
 Persistent changes:
 
@@ -61,9 +62,9 @@ Project configuration takes precedence over global configuration.
 {
   "enabled": true,
   "quiet": false,
-  "toolName": "set_reasoning_effort",
-  "toolDescription": "Set your reasoning effort",
-  "systemPrompt": "You MUST manage reasoning effort 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."
+  "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."
 }
 ```
 
@@ -75,7 +76,6 @@ pnpm format:check
 pnpm lint
 pnpm typecheck
 pnpm test
-pnpm build
 ```
 
 Run all checks:

package/package.json

@@ -1,79 +1,57 @@
 {
   "name": "pi-adaptive-thinking",
-  "version": "0.1.0",
-  "description": "Pi Adaptive Thinking extension",
+  "version": "0.1.2",
+  "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
   },
+  "dependencies": {
+    "proper-lockfile": "^4.1.2"
+  },
   "devDependencies": {
-    "@changesets/changelog-github": "^0.7.0",
-    "@changesets/cli": "^2.31.0",
-    "@types/node": "^25.9.1",
-    "@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,55 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { parseConfig, 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 }
+  | { 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 {
+      return { success: true, source, config: parseConfig(JSON.parse(raw)) };
+    } catch (error) {
+      return invalidConfig(source, error);
+    }
+  }
+
+  return { success: true, config: parseConfig(undefined) };
+};

package/src/config.ts

@@ -0,0 +1,34 @@
+import { Type, type Static } from "typebox";
+import { Parse } from "typebox/value";
+
+export const defaultSystemPrompt =
+  "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 const configDefaults = {
+  enabled: true,
+  quiet: false,
+  toolName: "set_thinking_level",
+  toolDescription: "Set your thinking level",
+  systemPrompt: defaultSystemPrompt,
+};
+
+export const ConfigSchema = Type.Object(
+  {
+    enabled: Type.Boolean(),
+    quiet: Type.Boolean(),
+    toolName: Type.String({ minLength: 1 }),
+    toolDescription: Type.String({ minLength: 1 }),
+    systemPrompt: Type.String({ minLength: 1 }),
+  },
+  { additionalProperties: false },
+);
+
+export type AdaptiveThinkingConfig = Static<typeof ConfigSchema>;
+
+export const parseConfig = (input: unknown): AdaptiveThinkingConfig => {
+  const merged = input === undefined ? configDefaults : { ...configDefaults, ...input };
+  return Parse(ConfigSchema, merged);
+};

package/src/index.ts

@@ -0,0 +1,333 @@
+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,
+  BeforeAgentStartEvent,
+  BeforeAgentStartEventResult,
+  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;
+  currentLevel?: PiThinkingLevel;
+  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 textResult = (text: string): AgentToolResult<undefined> => ({
+  content: [{ type: "text", text }],
+  details: undefined,
+});
+
+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);
+};
+
+const appendSystemPromptBlock = (systemPrompt: string, block: string) => {
+  const trimmedBlock = block.trim();
+  if (!trimmedBlock) return systemPrompt;
+  if (!systemPrompt.trim()) return trimmedBlock;
+  return `${systemPrompt.trimEnd()}\n\n${trimmedBlock}`;
+};
+
+const formatGuidance = (
+  config: AdaptiveThinkingConfig,
+  currentLevel: string | undefined,
+  validLevels: string[],
+) => {
+  return (
+    config.systemPrompt.trim() +
+    " " +
+    (currentLevel ? `Current thinking level: ${currentLevel}. ` : "") +
+    `Valid thinking levels for this session: ${validLevels.join(", ")}. ` +
+    `To change the thinking level, use the \`${config.toolName}\` tool with one of the valid levels. ` +
+    "Only call it when the task complexity justifies changing levels. " +
+    `Do not call ${config.toolName} if the current thinking level already matches the target level. ` +
+    `Do not call ${config.toolName} twice in a row; reassess only after new evidence from other tool calls or user input.`
+  );
+};
+
+export default function adaptiveThinking(pi: ExtensionAPI) {
+  let runtime: RuntimeState | undefined;
+  let runtimeHandlersRegistered = false;
+
+  const registerRuntimeHandlers = () => {
+    if (runtimeHandlersRegistered) return;
+    runtimeHandlersRegistered = true;
+
+    pi.on("thinking_level_select", async (event) => {
+      if (!runtime) return;
+      if (isThinkingLevel(event.level)) runtime.currentLevel = event.level;
+    });
+
+    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("before_agent_start", async (event, ctx) => beforeAgentStart(event, ctx));
+
+    pi.on("agent_end", async (_event, ctx) => {
+      await resetTemporaryLevel(ctx);
+      if (!runtime) return;
+      runtime.lastToolCallWasReasoningTool = false;
+      runtime.reasoningToolCallBackToBackById.clear();
+    });
+  };
+
+  const beforeAgentStart = async (
+    event: BeforeAgentStartEvent,
+    ctx: ExtensionContext,
+  ): Promise<BeforeAgentStartEventResult> => {
+    const state = runtime;
+    if (!state) return { systemPrompt: event.systemPrompt };
+
+    state.lastToolCallWasReasoningTool = false;
+    state.reasoningToolCallBackToBackById.clear();
+
+    const currentLevel = state.currentLevel ?? pi.getThinkingLevel();
+    if (isThinkingLevel(currentLevel)) state.currentLevel = currentLevel;
+
+    const validLevels = resolveSupportedThinkingLevels(ctx.model);
+    return {
+      systemPrompt: appendSystemPromptBlock(
+        event.systemPrompt,
+        formatGuidance(state.config, state.currentLevel, validLevels),
+      ),
+    };
+  };
+
+  const resetTemporaryLevel = async (ctx: ExtensionContext) => {
+    const state = runtime;
+    const resetLevel = state?.temporaryResetLevel;
+    if (!state || !resetLevel) return;
+
+    try {
+      withSessionOnlyThinkingLevelChange(() => pi.setThinkingLevel(resetLevel));
+      state.currentLevel = 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;
+    }
+
+    const initialLevel = pi.getThinkingLevel();
+    runtime = { config, reasoningToolCallBackToBackById: new Map() };
+    if (isThinkingLevel(initialLevel)) runtime.currentLevel = initialLevel;
+
+    pi.registerTool({
+      name: config.toolName,
+      label: "Set Thinking Level",
+      description: config.toolDescription,
+      promptSnippet: "Set the current Pi thinking level.",
+      promptGuidelines: [
+        `Use ${config.toolName} to change the thinking level when task complexity justifies a different level.`,
+      ],
+      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 = state.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);
+
+        try {
+          withSessionOnlyThinkingLevelChange(() => pi.setThinkingLevel(level));
+        } catch (error) {
+          return textResult(`Failed to set thinking level: ${errorMessage(error)}`);
+        }
+
+        state.currentLevel = level;
+        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}`);
+      },
+    });
+
+    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),
+  );
+};

package/dist/config-loader.d.ts

@@ -1,16 +0,0 @@
-import { type AdaptiveThinkingConfig } from "./config";
-export type { AdaptiveThinkingConfig } from "./config";
-export type LoadConfigOptions = {
-    cwd: string;
-    homeDir?: string;
-};
-export type LoadConfigResult = {
-    success: true;
-    config: AdaptiveThinkingConfig;
-    source?: string;
-} | {
-    success: false;
-    source: string;
-    error: Error;
-};
-export declare const loadConfig: ({ cwd, homeDir, }: LoadConfigOptions) => Promise<LoadConfigResult>;

package/dist/config.d.ts

@@ -1,18 +0,0 @@
-import { Type, type Static } from "typebox";
-export declare const defaultSystemPrompt: string;
-export declare const configDefaults: {
-    enabled: boolean;
-    quiet: boolean;
-    toolName: string;
-    toolDescription: string;
-    systemPrompt: string;
-};
-export declare const ConfigSchema: Type.TObject<{
-    enabled: Type.TBoolean;
-    quiet: Type.TBoolean;
-    toolName: Type.TString;
-    toolDescription: Type.TString;
-    systemPrompt: Type.TString;
-}>;
-export type AdaptiveThinkingConfig = Static<typeof ConfigSchema>;
-export declare const parseConfig: (input: unknown) => AdaptiveThinkingConfig;

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-export default function adaptiveThinking(pi: ExtensionAPI): void;