@selesai/code 0.13.40 → 0.14.3

package/dist/cli/startup-ui.js

@@ -7,7 +7,9 @@ import { SettingsManager } from "../core/settings-manager.js";
 import { ExtensionInputComponent } from "../modes/interactive/components/extension-input.js";
 import { ExtensionSelectorComponent } from "../modes/interactive/components/extension-selector.js";
 import { FirstTimeSetupComponent, } from "../modes/interactive/components/first-time-setup.js";
-import { detectTerminalBackgroundFromEnv, detectTerminalThemeForAuto, initTheme, loadThemeFromPath, parseAutoThemeSetting, resolveThemeSetting, setRegisteredThemes, setTheme, } from "../modes/interactive/theme/theme.js";
+import { SYSTEM_THEME_NAME } from "../modes/interactive/theme/system-theme.js";
+import { getTerminalTheme, initTheme, loadThemeFromPath, markTerminalColorsPending, resolveThemeSetting, setRegisteredThemes, setTerminalColors, setTheme, } from "../modes/interactive/theme/theme.js";
+import { requestTerminalColors } from "../modes/interactive/theme/theme-controller.js";
 function loadThemes(resources) {
     const themes = [];
     const seen = new Set();
@@ -45,8 +47,9 @@ async function loadStartupThemes(settingsManager) {
 export async function createStartupTui(settingsManager) {
     setCapabilityOverrides(settingsManager.getTerminalCapabilityOverrides());
     setRegisteredThemes(await loadStartupThemes(settingsManager));
-    const terminalTheme = detectTerminalBackgroundFromEnv().theme;
-    initTheme(resolveThemeSetting(settingsManager.getThemeSetting(), terminalTheme) ?? terminalTheme);
+    // The system theme starts in grayscale until the terminal reports its colors.
+    markTerminalColorsPending();
+    initTheme(resolveThemeSetting(settingsManager.getThemeSetting(), getTerminalTheme()) ?? SYSTEM_THEME_NAME);
     setKeybindings(KeybindingsManager.create());
     const ui = new TuiMainScreen(new ProcessTerminal(), settingsManager.getShowHardwareCursor(), getAgentDir());
     ui.setClearOnShrink(settingsManager.getClearOnShrink());
@@ -54,16 +57,22 @@ export async function createStartupTui(settingsManager) {
 }
 export function startStartupTui(ui, settingsManager) {
     ui.start();
-    void applyDetectedStartupTheme(ui, settingsManager);
-}
-async function applyDetectedStartupTheme(ui, settingsManager) {
     const themeSetting = settingsManager.getThemeSetting();
-    if (themeSetting && !parseAutoThemeSetting(themeSetting))
-        return;
-    const terminalTheme = await detectTerminalThemeForAuto({ ui, timeoutMs: 100 });
-    setTheme(resolveThemeSetting(themeSetting, terminalTheme) ?? terminalTheme);
-    ui.invalidate();
-    ui.requestRender();
+    queryStartupTerminalColors(ui, () => {
+        setTheme(resolveThemeSetting(themeSetting, getTerminalTheme()) ?? SYSTEM_THEME_NAME);
+    });
+}
+/**
+ * Query the terminal's colors without waiting for them. When they arrive, including after the timeout,
+ * record them for the system theme and "" (terminal default) tokens, run `onColors`, and re-render.
+ */
+function queryStartupTerminalColors(ui, onColors) {
+    void requestTerminalColors(ui, (colors) => {
+        setTerminalColors(colors);
+        onColors();
+        ui.invalidate();
+        ui.requestRender();
+    });
 }
 async function clearStartupTui(ui) {
     ui.clear();
@@ -128,24 +137,23 @@ export async function showFirstTimeSetup(settingsManager) {
             ui.stop();
             resolve();
         };
-        const showSetup = async () => {
-            ui.start();
-            const detectedTheme = await detectTerminalThemeForAuto({ ui, timeoutMs: 100 });
-            setTheme(detectedTheme);
-            const component = new FirstTimeSetupComponent({
-                detectedTheme,
-                onThemePreview: (themeName) => {
-                    setTheme(themeName);
-                    ui.requestRender();
-                },
-                onSubmit: (result) => void finish(result),
-                onCancel: () => void finish(undefined),
-            });
-            ui.addChild(component);
-            ui.setFocus(component);
-            ui.requestRender();
-        };
-        void showSetup();
+        ui.start();
+        let previewTheme = SYSTEM_THEME_NAME;
+        setTheme(previewTheme);
+        const component = new FirstTimeSetupComponent({
+            onThemePreview: (themeName) => {
+                previewTheme = themeName;
+                setTheme(themeName);
+                ui.requestRender();
+            },
+            onSubmit: (result) => void finish(result),
+            onCancel: () => void finish(undefined),
+        });
+        ui.addChild(component);
+        ui.setFocus(component);
+        ui.requestRender();
+        // The terminal's colors regenerate the system theme; re-rendering rebuilds the dialog with it.
+        queryStartupTerminalColors(ui, () => setTheme(previewTheme));
     });
 }
 export async function showStartupInput(settingsManager, title, placeholder) {

package/dist/config.d.ts

@@ -26,22 +26,23 @@ export declare function getUpdateInstruction(packageName: string): string;
 /**
  * Get the base directory for resolving package assets (themes, package.json, README.md, CHANGELOG.md).
  * - For Bun binary: returns the directory containing the executable
- * - For Node.js (dist/): returns __dirname (the dist/ directory)
- * - For tsx (src/): returns parent directory (the package root)
+ * - For Node.js: returns the package root containing package.json
+ * - Ignores Bun binary metadata copied into dist/ when the package root is available
  */
+export declare function findNodePackageDir(startDir: string): string;
 export declare function getPackageDir(): string;
 /**
  * Get path to built-in themes directory (shipped with package)
  * - For Bun binary: theme/ next to executable
  * - For Node.js (dist/): dist/modes/interactive/theme/
- * - For tsx (src/): src/modes/interactive/theme/
+ * - For source (src/): src/modes/interactive/theme/
  */
 export declare function getThemesDir(): string;
 /**
  * Get path to HTML export template directory (shipped with package)
  * - For Bun binary: export-html/ next to executable
  * - For Node.js (dist/): dist/core/export-html/
- * - For tsx (src/): src/core/export-html/
+ * - For source (src/): src/core/export-html/
  */
 export declare function getExportTemplateDir(): string;
 /** Get path to package.json */
@@ -58,7 +59,7 @@ export declare function getChangelogPath(): string;
  * Get path to built-in interactive assets directory.
  * - For Bun binary: assets/ next to executable
  * - For Node.js (dist/): dist/modes/interactive/assets/
- * - For tsx (src/): src/modes/interactive/assets/
+ * - For source (src/): src/modes/interactive/assets/
  */
 export declare function getInteractiveAssetsDir(): string;
 /**
@@ -87,6 +88,34 @@ export declare function getBundledThemesDir(): string;
 export declare function getBundledSkillsDir(): string;
 /** Get path to a bundled interactive asset */
 export declare function getBundledInteractiveAssetPath(name: string): string;
+/** Called by the Bun entry with the path of the QuickJS wasm file embedded in the compiled executable. */
+export declare function setEmbeddedQuickJSWasmPath(path: string): void;
+/**
+ * Get path to `quickjs-wasi/quickjs.wasm`, the VM that runs codemode scripts. Resolved once so the
+ * compiled module cached per path keeps working after an update removes this install (#10439).
+ */
+export declare function getQuickJSWasmPath(): string;
+/** Resolve the codemode worker entry for a release runtime. */
+export declare function resolveCodemodeWorkerSpecifier(runtime: "bun-binary" | "bundled-node" | "unbundled", moduleUrl: string): string | URL | undefined;
+/**
+ * Get the codemode worker entry, or undefined to use the worker that ships next to pi-codemode.
+ * The Bun and Node release builds both pass the worker as an extra entrypoint.
+ */
+export declare function getCodemodeWorkerSpecifier(): string | URL | undefined;
+export type InstallChange = {
+    kind: "updated";
+    version: string;
+} | {
+    kind: "removed";
+};
+/**
+ * Detect that the package this process runs from changed on disk, for example after `pi update`
+ * in another terminal. Code loaded on demand can then be missing or from another version.
+ *
+ * Checks the package.json read at startup. Resolving it again would walk up past a deleted install
+ * and could find an unrelated package.json, such as one in the home directory.
+ */
+export declare function detectInstallChange(packageJsonPath?: string | undefined): InstallChange | undefined;
 export declare const PACKAGE_NAME: string;
 export declare const APP_NAME: string;
 export declare const APP_TITLE: string;
@@ -97,7 +126,7 @@ export declare const PI_PLATFORM_VERSION: string;
 export declare const ENV_AGENT_DIR: string;
 export declare const ENV_SESSION_DIR: string;
 export declare function expandTildePath(path: string): string;
-/** Get the share viewer URL for a gist ID */
+/** Get the share viewer URL for a gist ID. */
 export declare function getShareViewerUrl(gistId: string): string;
 /** Get the agent config directory (e.g., ~/.selesai/agent/) */
 export declare function getAgentDir(): string;
@@ -158,6 +187,15 @@ export declare function seedMissingSubagentSettings(destPath: string, bundledDef
  * rewritten.
  */
 export declare function seedMissingGraftSettings(destPath: string, bundledDefaultsDir?: string): boolean;
+/**
+ * Add the bundled `defaultTools` selection (which enables `codemode`) to an existing user
+ * settings file that does not set `defaultTools` at all. Settings files created before the
+ * bundled default existed would otherwise never get it. A user-provided `defaultTools`, even an
+ * empty one or one with only `-name` entries, is never touched. The file is modified with a
+ * minimal textual insertion, so other settings keep their formatting. Returns true when the file
+ * was rewritten.
+ */
+export declare function seedMissingDefaultToolsSettings(destPath: string, bundledDefaultsDir?: string): boolean;
 /**
  * Bundled extensions load directly from the installed package. Do not copy them
  * into the user's agent dir, otherwise startup discovers both copies and tool
@@ -184,7 +222,7 @@ export declare function seedDefaultSkills(agentDir: string, bundledSkillsDir?: s
 export declare function seedDefaultThemes(agentDir: string, bundledThemesDir?: string): string[];
 /**
  * Run bootstrap for the agent dir: ensure directories, seed a missing
- * settings.json, and add missing bundled subagent defaults. Idempotent — safe
+ * settings.json, and add missing bundled subagent, graft, and default-tools settings. Idempotent — safe
  * on every startup.
  * Bundled models load package-locally; copying them would expose internal
  * providers as user config. Bundled extensions also stay package-local.

package/dist/config.js

@@ -1,4 +1,6 @@
+import { stripBom } from "./utils/text.js";
 import { accessSync, chmodSync, constants, copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync, unlinkSync, writeFileSync, } from "fs";
+import { createRequire } from "module";
 import { homedir } from "os";
 import { basename, dirname, join, resolve, sep, win32 } from "path";
 import { fileURLToPath } from "url";
@@ -134,6 +136,9 @@ function getSelfUpdateCommandForMethod(method, installedPackageName, updatePacka
             const [command = "npm", ...npmArgs] = npmCommand ?? [];
             const inferred = npmCommand?.length ? undefined : getInferredNpmInstall();
             const prefixArgs = [...npmArgs, ...(inferred ? ["--prefix", inferred.prefix] : [])];
+            // pi.dev advertises releases immediately, so a configured npm age gate would
+            // block the update. npm has no per-package age gate, so this also lets new
+            // transitive dependency releases through. Managed installs avoid this.
             const installStep = makeSelfUpdateCommandStep(command, [
                 ...prefixArgs,
                 "install",
@@ -311,9 +316,25 @@ export function getUpdateInstruction(packageName) {
 /**
  * Get the base directory for resolving package assets (themes, package.json, README.md, CHANGELOG.md).
  * - For Bun binary: returns the directory containing the executable
- * - For Node.js (dist/): returns __dirname (the dist/ directory)
- * - For tsx (src/): returns parent directory (the package root)
+ * - For Node.js: returns the package root containing package.json
+ * - Ignores Bun binary metadata copied into dist/ when the package root is available
  */
+export function findNodePackageDir(startDir) {
+    let dir = startDir;
+    while (dir !== dirname(dir)) {
+        if (existsSync(join(dir, "package.json"))) {
+            const parent = dirname(dir);
+            // build:binary places Bun's metadata inside dist/. Node still needs the
+            // package root so its dist-relative asset paths do not become dist/dist/.
+            if (basename(dir) === "dist" && existsSync(join(parent, "package.json"))) {
+                return parent;
+            }
+            return dir;
+        }
+        dir = dirname(dir);
+    }
+    return startDir;
+}
 export function getPackageDir() {
     // Allow override via environment variable (useful for Nix/Guix where store paths tokenize poorly)
     const envDir = process.env.PI_PACKAGE_DIR;
@@ -324,22 +345,13 @@ export function getPackageDir() {
         // Bun binary: process.execPath points to the compiled executable
         return dirname(process.execPath);
     }
-    // Node.js: walk up from __dirname until we find package.json
-    let dir = __dirname;
-    while (dir !== dirname(dir)) {
-        if (existsSync(join(dir, "package.json"))) {
-            return dir;
-        }
-        dir = dirname(dir);
-    }
-    // Fallback (shouldn't happen)
-    return __dirname;
+    return findNodePackageDir(__dirname);
 }
 /**
  * Get path to built-in themes directory (shipped with package)
  * - For Bun binary: theme/ next to executable
  * - For Node.js (dist/): dist/modes/interactive/theme/
- * - For tsx (src/): src/modes/interactive/theme/
+ * - For source (src/): src/modes/interactive/theme/
  */
 export function getThemesDir() {
     if (isBunBinary) {
@@ -354,7 +366,7 @@ export function getThemesDir() {
  * Get path to HTML export template directory (shipped with package)
  * - For Bun binary: export-html/ next to executable
  * - For Node.js (dist/): dist/core/export-html/
- * - For tsx (src/): src/core/export-html/
+ * - For source (src/): src/core/export-html/
  */
 export function getExportTemplateDir() {
     if (isBunBinary) {
@@ -388,7 +400,7 @@ export function getChangelogPath() {
  * Get path to built-in interactive assets directory.
  * - For Bun binary: assets/ next to executable
  * - For Node.js (dist/): dist/modes/interactive/assets/
- * - For tsx (src/): src/modes/interactive/assets/
+ * - For source (src/): src/modes/interactive/assets/
  */
 export function getInteractiveAssetsDir() {
     if (isBunBinary) {
@@ -448,9 +460,75 @@ export function getBundledSkillsDir() {
 export function getBundledInteractiveAssetPath(name) {
     return join(getInteractiveAssetsDir(), name);
 }
+let quickJSWasmPath;
+/** Called by the Bun entry with the path of the QuickJS wasm file embedded in the compiled executable. */
+export function setEmbeddedQuickJSWasmPath(path) {
+    quickJSWasmPath = path;
+}
+/**
+ * Get path to `quickjs-wasi/quickjs.wasm`, the VM that runs codemode scripts. Resolved once so the
+ * compiled module cached per path keeps working after an update removes this install (#10439).
+ */
+export function getQuickJSWasmPath() {
+    quickJSWasmPath ??= createRequire(import.meta.url).resolve("quickjs-wasi/quickjs.wasm");
+    return quickJSWasmPath;
+}
+/** Resolve the codemode worker entry for a release runtime. */
+export function resolveCodemodeWorkerSpecifier(runtime, moduleUrl) {
+    // Bun embeds explicit source entrypoints, but on Windows Bun 1.3 cannot map an absolute
+    // B:\~BUN URL back to one. A relative string with the original source extension works on
+    // every Bun platform.
+    if (runtime === "bun-binary")
+        return "./src/extensions/codemode/worker.ts";
+    if (runtime === "bundled-node")
+        return new URL("./codemode-worker.js", moduleUrl);
+    return undefined;
+}
+let codemodeWorkerDataUrl;
+/**
+ * Get the codemode worker entry, or undefined to use the worker that ships next to pi-codemode.
+ * The Bun and Node release builds both pass the worker as an extra entrypoint.
+ */
+export function getCodemodeWorkerSpecifier() {
+    const runtime = isBunBinary ? "bun-binary" : isBundledNode ? "bundled-node" : "unbundled";
+    const specifier = resolveCodemodeWorkerSpecifier(runtime, import.meta.url);
+    if (runtime !== "bundled-node" || !(specifier instanceof URL))
+        return specifier;
+    // Spawn workers from an in-memory copy. An update replaces or deletes the file while this
+    // process keeps running (#10439). The bundle build keeps the worker free of relative imports
+    // and import.meta, so it runs from a data: URL.
+    codemodeWorkerDataUrl ??= new URL(`data:text/javascript;base64,${readFileSync(specifier).toString("base64")}`);
+    return codemodeWorkerDataUrl;
+}
+/**
+ * Detect that the package this process runs from changed on disk, for example after `pi update`
+ * in another terminal. Code loaded on demand can then be missing or from another version.
+ *
+ * Checks the package.json read at startup. Resolving it again would walk up past a deleted install
+ * and could find an unrelated package.json, such as one in the home directory.
+ */
+export function detectInstallChange(packageJsonPath = startupPackageJsonPath) {
+    // The Bun binary embeds its code, so replacing the executable does not affect this process.
+    if (isBunBinary || !packageJsonPath)
+        return undefined;
+    let installed;
+    try {
+        installed = JSON.parse(stripBom(readFileSync(packageJsonPath, "utf-8")));
+    }
+    catch (error) {
+        return error.code === "ENOENT" ? { kind: "removed" } : undefined;
+    }
+    return installed.version && installed.version !== VERSION
+        ? { kind: "updated", version: installed.version }
+        : undefined;
+}
 let pkg = {};
+/** The package.json this process started from, if one existed. */
+let startupPackageJsonPath;
 try {
-    pkg = JSON.parse(readFileSync(getPackageJsonPath(), "utf-8"));
+    const packageJsonPath = getPackageJsonPath();
+    pkg = JSON.parse(stripBom(readFileSync(packageJsonPath, "utf-8")));
+    startupPackageJsonPath = packageJsonPath;
 }
 catch (e) {
     const err = e;
@@ -472,7 +550,7 @@ export function expandTildePath(path) {
     return normalizePath(path);
 }
 const DEFAULT_SHARE_VIEWER_URL = "https://pi.dev/session/";
-/** Get the share viewer URL for a gist ID */
+/** Get the share viewer URL for a gist ID. */
 export function getShareViewerUrl(gistId) {
     const baseUrl = process.env.PI_SHARE_VIEWER_URL || DEFAULT_SHARE_VIEWER_URL;
     return `${baseUrl}#${gistId}`;
@@ -723,6 +801,43 @@ export function seedMissingGraftSettings(destPath, bundledDefaultsDir = getBundl
         return false;
     }
 }
+/**
+ * Add the bundled `defaultTools` selection (which enables `codemode`) to an existing user
+ * settings file that does not set `defaultTools` at all. Settings files created before the
+ * bundled default existed would otherwise never get it. A user-provided `defaultTools`, even an
+ * empty one or one with only `-name` entries, is never touched. The file is modified with a
+ * minimal textual insertion, so other settings keep their formatting. Returns true when the file
+ * was rewritten.
+ */
+export function seedMissingDefaultToolsSettings(destPath, bundledDefaultsDir = getBundledDefaultsDir()) {
+    if (!existsSync(destPath))
+        return false;
+    try {
+        const raw = readFileSync(destPath, "utf-8");
+        const settings = JSON.parse(raw);
+        const defaults = JSON.parse(readFileSync(join(bundledDefaultsDir, "settings.json"), "utf-8"));
+        if (typeof settings !== "object" ||
+            settings === null ||
+            Array.isArray(settings) ||
+            Object.hasOwn(settings, "defaultTools") ||
+            typeof defaults !== "object" ||
+            defaults === null ||
+            Array.isArray(defaults)) {
+            return false;
+        }
+        const defaultTools = defaults.defaultTools;
+        if (!Array.isArray(defaultTools) || !defaultTools.every((entry) => typeof entry === "string"))
+            return false;
+        const injected = injectRootObjectKey(raw, "defaultTools", defaultTools);
+        if (injected === undefined)
+            return false;
+        writeFileSync(destPath, injected);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Recursively copy a bundled directory tree into the user's agent dir,
  * overwriting any existing file so the bundled copy stays authoritative.
@@ -824,7 +939,7 @@ export function seedDefaultThemes(agentDir, bundledThemesDir = getBundledThemesD
 }
 /**
  * Run bootstrap for the agent dir: ensure directories, seed a missing
- * settings.json, and add missing bundled subagent defaults. Idempotent — safe
+ * settings.json, and add missing bundled subagent, graft, and default-tools settings. Idempotent — safe
  * on every startup.
  * Bundled models load package-locally; copying them would expose internal
  * providers as user config. Bundled extensions also stay package-local.
@@ -835,6 +950,7 @@ export function bootstrapAgentDir(agentDir = getAgentDir()) {
     seedDefaultConfigFile(settingsPath, "settings.json");
     seedMissingSubagentSettings(settingsPath);
     seedMissingGraftSettings(settingsPath);
+    seedMissingDefaultToolsSettings(settingsPath);
     seedDefaultExtensions(agentDir);
     seedDefaultSkills(agentDir);
     seedDefaultThemes(agentDir);

package/dist/core/agent-session-custom-tools.test.js

@@ -0,0 +1,64 @@
+import { createExtensionRuntime } from "./extensions/loader.js";
+import { describe, expect, it, vi } from "vitest";
+import { Type } from "typebox";
+import { AgentSession } from "./agent-session.js";
+import { SessionManager } from "./session-manager.js";
+import { SettingsManager } from "./settings-manager.js";
+function createMockSession({ customTools, allowedToolNames, }) {
+    const settings = SettingsManager.inMemory();
+    const resourceLoader = {
+        getExtensions: () => ({ extensions: [], errors: [], runtime: createExtensionRuntime() }),
+        getSkills: () => ({ skills: [], diagnostics: [] }),
+        getPromptSkills: () => [],
+        setSkillsIndexFilter: () => { },
+        getPrompts: () => ({ prompts: [], diagnostics: [] }),
+        getThemes: () => ({ themes: [], diagnostics: [] }),
+        getAgents: () => ({ agents: [], diagnostics: [] }),
+        getAgentsFiles: () => ({ agentsFiles: [] }),
+        getSystemPrompt: () => undefined,
+        getAppendSystemPrompt: () => [],
+        getExtensionDiagnostics: () => [],
+        extendResources: () => { },
+        reload: vi.fn(),
+    };
+    const modelRegistry = {
+        registerProvider: vi.fn(),
+        unregisterProvider: vi.fn(),
+        getProvider: vi.fn(),
+        getProviders: vi.fn(() => []),
+        getModels: vi.fn(() => []),
+    };
+    const agent = {
+        state: { messages: [], tools: [] },
+        subscribe: vi.fn(() => () => { }),
+    };
+    const session = new AgentSession({
+        agent: agent,
+        sessionManager: SessionManager.inMemory(),
+        settingsManager: settings,
+        cwd: "/tmp",
+        resourceLoader: resourceLoader,
+        customTools,
+        modelRuntime: modelRegistry,
+        allowedToolNames,
+    });
+    return { session };
+}
+describe("AgentSession tools", () => {
+    const customTool = {
+        name: "custom",
+        label: "Custom",
+        description: "A custom tool",
+        parameters: Type.Object({}),
+        execute: async () => ({ content: [{ type: "text", text: "ok" }], details: undefined }),
+    };
+    it("includes custom tools by default but respects an explicit allowlist", () => {
+        const defaults = createMockSession({ customTools: [customTool] });
+        expect(defaults.session.getActiveToolNames()).toContain("custom");
+        const allowed = createMockSession({
+            customTools: [customTool],
+            allowedToolNames: ["custom"],
+        });
+        expect(allowed.session.getActiveToolNames()).toEqual(["custom"]);
+    });
+});

package/dist/core/agent-session-length-continuation.test.js

@@ -1,3 +1,4 @@
+import { createExtensionRuntime } from "./extensions/loader.js";
 import { describe, expect, it, vi } from "vitest";
 import { AgentSession } from "./agent-session.js";
 import { SessionManager } from "./session-manager.js";
@@ -13,7 +14,7 @@ function createMockSession() {
         hasHandlers: vi.fn(() => false),
     };
     const resourceLoader = {
-        getExtensions: () => ({ extensions: [], errors: [], runtime: { flagValues: new Map(), pendingProviderRegistrations: [], pendingNativeProviderRegistrations: [], assertActive: () => { } } }),
+        getExtensions: () => ({ extensions: [], errors: [], runtime: createExtensionRuntime() }),
         getSkills: () => ({ skills: [], diagnostics: [] }),
         getPromptSkills: () => [],
         setSkillsIndexFilter: () => { },
@@ -56,6 +57,9 @@ function createMockSession() {
 function lengthStopMessage(text) {
     return {
         role: "assistant",
+        provider: "test-provider",
+        model: "test-model",
+        api: "openai-completions",
         content: [{ type: "text", text }],
         stopReason: "length",
         timestamp: Date.now(),
@@ -76,8 +80,8 @@ describe("AgentSession length-stop continuation", () => {
     it("does not continue when the truncated message contains tool calls", async () => {
         const { session, followUp } = createMockSession();
         session._lastAssistantMessage = {
-            role: "assistant",
-            content: [{ type: "toolCall", id: "tc_1", name: "bash", arguments: "{}" }],
+            ...lengthStopMessage(""),
+            content: [{ type: "toolCall", id: "tc_1", name: "bash", arguments: {} }],
             stopReason: "length",
             timestamp: Date.now(),
         };

package/dist/core/agent-session-runtime.js

@@ -163,7 +163,7 @@ export class AgentSessionRuntime {
         }));
         if (options?.setup) {
             await options.setup(this.session.sessionManager);
-            this.session.agent.state.messages = this.session.sessionManager.buildSessionContext().messages;
+            this.session.refreshContext();
         }
         await this.finishSessionReplacement(options?.withSession);
         return { cancelled: false };
@@ -211,7 +211,7 @@ export class AgentSessionRuntime {
                 return { cancelled: false, selectedText };
             }
             if (!existsSync(currentSessionFile)) {
-                throw new Error("This session has not been saved yet. Wait for the first assistant response before cloning or forking it.");
+                throw new Error("This session has not been saved yet. Send a message before cloning or forking it.");
             }
             const sessionManager = SessionManager.open(currentSessionFile, sessionDir);
             const forkedSessionPath = sessionManager.createBranchedSession(targetLeafId);

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

@@ -29,6 +29,7 @@ export interface CreateAgentSessionServicesOptions {
     agentDir?: string;
     settingsManager?: SettingsManager;
     modelRuntime?: ModelRuntime;
+    modelRuntimeSignal?: AbortSignal;
     extensionFlagValues?: Map<string, boolean | string>;
     resourceLoaderOptions?: Omit<DefaultResourceLoaderOptions, "cwd" | "agentDir" | "settingsManager">;
     resourceLoaderReloadOptions?: ResourceLoaderReloadOptions;

package/dist/core/agent-session-services.js

@@ -57,6 +57,7 @@ export async function createAgentSessionServices(options) {
         (await ModelRuntime.create({
             authPath: join(agentDir, "auth.json"),
             modelsPath: join(agentDir, "models.json"),
+            signal: options.modelRuntimeSignal,
         }));
     const settingsManager = options.settingsManager ?? SettingsManager.create(cwd, agentDir);
     const resourceLoader = new DefaultResourceLoader({
@@ -94,6 +95,19 @@ export async function createAgentSessionServices(options) {
         }
     }
     extensionsResult.runtime.pendingNativeProviderRegistrations = [];
+    for (const { definition, extensionPath } of extensionsResult.runtime.pendingVirtualModelRegistrations) {
+        try {
+            modelRuntime.registerVirtualModel(definition);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            diagnostics.push({
+                type: "error",
+                message: `Extension "${extensionPath}" error: ${message}`,
+            });
+        }
+    }
+    extensionsResult.runtime.pendingVirtualModelRegistrations = [];
     await modelRuntime.refresh({ allowNetwork: false });
     diagnostics.push(...applyExtensionFlagValues(resourceLoader, options.extensionFlagValues));
     return {