@selesai/code 0.13.40 → 0.14.3

package/dist/core/trust-manager.js

@@ -4,8 +4,10 @@ import { dirname, join } from "node:path";
 import lockfile from "proper-lockfile";
 import { CONFIG_DIR_NAME } from "../config.js";
 import { canonicalizePath, resolvePath } from "../utils/paths.js";
+import { stripBom } from "../utils/text.js";
 const TRUST_REQUIRING_PROJECT_CONFIG_RESOURCES = [
     "settings.json",
+    "mcp.json",
     "extensions",
     "skills",
     "prompts",
@@ -72,7 +74,7 @@ function readTrustFile(path) {
     }
     let parsed;
     try {
-        parsed = JSON.parse(readFileSync(path, "utf-8"));
+        parsed = JSON.parse(stripBom(readFileSync(path, "utf-8")));
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);

package/dist/core/usage-totals.d.ts

@@ -11,6 +11,8 @@ export interface UsageTotals {
 }
 export declare function createUsageTotals(): UsageTotals;
 export declare function addUsageToTotals(totals: UsageTotals, usage: Usage): void;
+/** Sum of two usages, keeping the optional token splits when either side reports them. */
+export declare function combineUsage(first: Usage, second: Usage): Usage;
 export interface UsageCostBreakdownEntry {
     key: string;
     cost: number;

package/dist/core/usage-totals.js

@@ -24,6 +24,29 @@ export function addUsageToTotals(totals, usage) {
     totals.cacheWrite += usage.cacheWrite;
     totals.cost += usage.cost.total;
 }
+/** Sum of two usages, keeping the optional token splits when either side reports them. */
+export function combineUsage(first, second) {
+    return {
+        input: first.input + second.input,
+        output: first.output + second.output,
+        cacheRead: first.cacheRead + second.cacheRead,
+        cacheWrite: first.cacheWrite + second.cacheWrite,
+        ...(first.cacheWrite1h !== undefined || second.cacheWrite1h !== undefined
+            ? { cacheWrite1h: (first.cacheWrite1h ?? 0) + (second.cacheWrite1h ?? 0) }
+            : {}),
+        ...(first.reasoning !== undefined || second.reasoning !== undefined
+            ? { reasoning: (first.reasoning ?? 0) + (second.reasoning ?? 0) }
+            : {}),
+        totalTokens: first.totalTokens + second.totalTokens,
+        cost: {
+            input: first.cost.input + second.cost.input,
+            output: first.cost.output + second.cost.output,
+            cacheRead: first.cost.cacheRead + second.cost.cacheRead,
+            cacheWrite: first.cost.cacheWrite + second.cost.cacheWrite,
+            total: first.cost.total + second.cost.total,
+        },
+    };
+}
 /** Group model-attributed usage by model and all other usage into a separate bucket. */
 export function getUsageCostBreakdown(entries) {
     const totalsByKey = new Map();

package/dist/core/virtual-models.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Virtual models are catalog entries that route each request to a physical model.
+ *
+ * The selection (`model_change`, `agent.state.model`, `ctx.model`) may name a virtual model.
+ * Everything below the routing step only sees physical models: providers stream them and
+ * assistant messages record them. A virtual model never reaches a provider.
+ *
+ * Virtual models belong to a provider id but are not provider models. `ModelRuntime` keeps them
+ * separately and adds them to the provider's catalog with `withVirtualModels()`, so any provider,
+ * including one with physical models, can list several virtual models.
+ */
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import { type Api, type AssistantMessage, type Message, type Model, type ModelThinkingLevel, type Provider } from "@earendil-works/pi-ai";
+import type { SessionEntry } from "./session-manager.ts";
+/** API id of virtual catalog entries. Requests for it fail unless routed first. */
+export declare const VIRTUAL_MODEL_API = "pi-virtual";
+/** Custom entry type that stores router state on the session branch. */
+export declare const VIRTUAL_MODEL_STATE_ENTRY = "pi.virtual-model-state";
+/** Data of a `pi.virtual-model-state` custom entry. */
+export interface VirtualModelStateData<TState = unknown> {
+    provider: string;
+    modelId: string;
+    state: TState;
+}
+/**
+ * Why a request is being routed.
+ * - `user`: first request after a message the user wrote (prompt, steering, or follow-up)
+ * - `continuation`: any other request in the agent loop, e.g. after tool results or extension messages
+ * - `retry`: automatic retry after a failed request, including after compaction for a context overflow
+ * - `direct`: a request outside the agent loop, e.g. a compaction summary or an extension call
+ */
+export type ModelRouteReason = "user" | "continuation" | "retry" | "direct";
+export interface ModelRouteRequest<TState = unknown> {
+    /** The selected virtual model. */
+    model: Model<Api>;
+    /** The selected thinking level. Its meaning is up to the router. */
+    thinkingLevel: ModelThinkingLevel;
+    reason: ModelRouteReason;
+    /** Physical model and thinking level of the latest successful response in `messages`. */
+    previous?: {
+        model: Model<Api>;
+        thinkingLevel?: ModelThinkingLevel;
+    };
+    /**
+     * For `retry`: the failed request, which `messages` no longer contains. `message` carries its
+     * `stopReason` and `errorMessage`. Absent when the router itself failed.
+     */
+    failed?: {
+        model: Model<Api>;
+        thinkingLevel?: ModelThinkingLevel;
+        message: AssistantMessage;
+    };
+    /** Router state last returned on this session branch. Undefined before the first state and for `direct` requests. */
+    state?: TState;
+    /** Conversation for this request, including system messages. */
+    messages: readonly Message[];
+    signal?: AbortSignal;
+}
+/** Physical model and thinking level for one request. */
+export interface ModelRoute<TState = unknown> {
+    model: Model<Api>;
+    thinkingLevel: ModelThinkingLevel;
+    /**
+     * New router state, stored on the session branch unless it is `request.state` itself. Return
+     * `request.state` or undefined to keep the current state. Must be JSON-serializable. Ignored for
+     * `direct` requests.
+     */
+    state?: TState;
+}
+export interface VirtualModelDefinition<TState = unknown> {
+    /** Provider the virtual model is listed under. May be a provider with physical models. */
+    provider: string;
+    /** Model id. Must not be the id of a physical model of `provider`. */
+    id: string;
+    name: string;
+    /** Thinking levels offered for selection. Defaults to `["off"]`. */
+    thinkingLevels?: readonly ModelThinkingLevel[];
+    /**
+     * Limits shown before the first response. Afterwards, Pi uses the limits of the physical model
+     * that answered. Unset limits are unknown (0).
+     */
+    contextWindow?: number;
+    maxTokens?: number;
+    /** Input types accepted for selection. Defaults to text and images; routed models without image support get placeholders. */
+    input?: ("text" | "image")[];
+    /** Pick the physical model, which must have credentials, and thinking level for one request. */
+    route(request: ModelRouteRequest<TState>): ModelRoute<TState> | Promise<ModelRoute<TState>>;
+}
+/** Whether a model or message names a virtual model. Failed routing leaves the virtual model on its message. */
+export declare function isVirtualModel(model: {
+    api: string;
+}): boolean;
+/** Latest successful response. Its model is physical: failed or aborted requests, including failed routing, are skipped. */
+export declare function findLatestResponse(messages: readonly AgentMessage[]): AssistantMessage | undefined;
+/**
+ * The model selection a session branch records. A virtual `model_change` holds until the next
+ * `model_change`, because responses name the physical models it routed to. Otherwise the latest
+ * physical response wins, as in sessions without virtual models. A virtual model that is no longer
+ * registered does not hold, so the selection falls back to the physical model that answered last.
+ *
+ * Only the last `model_change` can hold, so this looks up at most one model in the catalog.
+ */
+export declare function getBranchSelection(branch: readonly SessionEntry[], getModel: (provider: string, modelId: string) => Model<Api> | undefined): {
+    provider: string;
+    modelId: string;
+} | undefined;
+/** Latest router state a session branch stores for a virtual model. */
+export declare function getVirtualModelState(branch: readonly SessionEntry[], provider: string, modelId: string): unknown;
+/** Build the catalog entry of a virtual model. */
+export declare function createVirtualModel(definition: Omit<VirtualModelDefinition, "route">): Model<Api>;
+/**
+ * Add virtual models to a provider's catalog. Without a provider, the result is a keyless provider
+ * that only lists the virtual models. A virtual model hides a physical chat model with the same id,
+ * which a catalog refresh can add after registration. Availability follows the provider's auth.
+ */
+export declare function withVirtualModels(providerId: string, provider: Provider | undefined, virtualModels: readonly Model<Api>[]): Provider;

package/dist/core/virtual-models.js

@@ -0,0 +1,123 @@
+import { isModelType, lazyStream, } from "@earendil-works/pi-ai";
+/** API id of virtual catalog entries. Requests for it fail unless routed first. */
+export const VIRTUAL_MODEL_API = "pi-virtual";
+/** Custom entry type that stores router state on the session branch. */
+export const VIRTUAL_MODEL_STATE_ENTRY = "pi.virtual-model-state";
+const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+/** Whether a model or message names a virtual model. Failed routing leaves the virtual model on its message. */
+export function isVirtualModel(model) {
+    return model.api === VIRTUAL_MODEL_API;
+}
+/** Latest successful response. Its model is physical: failed or aborted requests, including failed routing, are skipped. */
+export function findLatestResponse(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if (message.role === "assistant" && message.stopReason !== "error" && message.stopReason !== "aborted") {
+            return message;
+        }
+    }
+    return undefined;
+}
+/**
+ * The model selection a session branch records. A virtual `model_change` holds until the next
+ * `model_change`, because responses name the physical models it routed to. Otherwise the latest
+ * physical response wins, as in sessions without virtual models. A virtual model that is no longer
+ * registered does not hold, so the selection falls back to the physical model that answered last.
+ *
+ * Only the last `model_change` can hold, so this looks up at most one model in the catalog.
+ */
+export function getBranchSelection(branch, getModel) {
+    for (let i = branch.length - 1; i >= 0; i--) {
+        const entry = branch[i];
+        if (entry.type === "model_change") {
+            return { provider: entry.provider, modelId: entry.modelId };
+        }
+        if (entry.type === "message" && entry.message.role === "assistant" && !isVirtualModel(entry.message)) {
+            const response = { provider: entry.message.provider, modelId: entry.message.model };
+            const change = findLastModelChange(branch, i);
+            const model = change && getModel(change.provider, change.modelId);
+            return change && model && isVirtualModel(model) ? change : response;
+        }
+    }
+    return undefined;
+}
+function findLastModelChange(branch, before) {
+    for (let i = before - 1; i >= 0; i--) {
+        const entry = branch[i];
+        if (entry.type === "model_change")
+            return { provider: entry.provider, modelId: entry.modelId };
+    }
+    return undefined;
+}
+/** Latest router state a session branch stores for a virtual model. */
+export function getVirtualModelState(branch, provider, modelId) {
+    for (let i = branch.length - 1; i >= 0; i--) {
+        const entry = branch[i];
+        if (entry.type !== "custom" || entry.customType !== VIRTUAL_MODEL_STATE_ENTRY)
+            continue;
+        const data = entry.data;
+        if (data?.provider === provider && data.modelId === modelId)
+            return data.state;
+    }
+    return undefined;
+}
+/** Build the catalog entry of a virtual model. */
+export function createVirtualModel(definition) {
+    const levels = definition.thinkingLevels ?? ["off"];
+    const thinkingLevelMap = {};
+    for (const level of THINKING_LEVELS)
+        thinkingLevelMap[level] = levels.includes(level) ? level : null;
+    return {
+        id: definition.id,
+        name: definition.name,
+        api: VIRTUAL_MODEL_API,
+        provider: definition.provider,
+        baseUrl: "",
+        reasoning: levels.some((level) => level !== "off"),
+        thinkingLevelMap,
+        input: definition.input ?? ["text", "image"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: definition.contextWindow ?? 0,
+        maxTokens: definition.maxTokens ?? 0,
+    };
+}
+/** Stream for a virtual model that was not routed, e.g. `stream()` with API-specific options. */
+function unroutedStream(model) {
+    return lazyStream(model, async () => {
+        throw new Error(`Virtual model ${model.provider}/${model.id} must be routed before streaming`);
+    });
+}
+/**
+ * Add virtual models to a provider's catalog. Without a provider, the result is a keyless provider
+ * that only lists the virtual models. A virtual model hides a physical chat model with the same id,
+ * which a catalog refresh can add after registration. Availability follows the provider's auth.
+ */
+export function withVirtualModels(providerId, provider, virtualModels) {
+    if (!provider) {
+        return {
+            id: providerId,
+            name: providerId,
+            auth: { apiKey: { name: "Virtual model", resolve: async () => ({ auth: {}, source: "virtual" }) } },
+            getModels: () => virtualModels,
+            stream: unroutedStream,
+            streamSimple: unroutedStream,
+        };
+    }
+    const ids = new Set(virtualModels.map((model) => model.id));
+    const physical = (models) => models.filter((model) => !isVirtualModel(model) && !(isModelType(model, "chat") && ids.has(model.id)));
+    const virtual = (models) => models.filter((model) => isVirtualModel(model));
+    const { filterModels, filterAllModels } = provider;
+    return {
+        ...provider,
+        getModels: () => [...physical(provider.getModels()), ...virtualModels],
+        getAllModels: () => [...physical(provider.getAllModels?.() ?? provider.getModels()), ...virtualModels],
+        filterModels: (models, credential) => {
+            const real = physical(models);
+            return [...(filterModels?.(real, credential) ?? real), ...virtual(models)];
+        },
+        filterAllModels: filterAllModels &&
+            ((models, credential) => [...filterAllModels(physical(models), credential), ...virtual(models)]),
+        stream: (model, context, options) => isVirtualModel(model) ? unroutedStream(model) : provider.stream(model, context, options),
+        streamSimple: (model, context, options) => isVirtualModel(model) ? unroutedStream(model) : provider.streamSimple(model, context, options),
+    };
+}

package/dist/defaults/models.json

@@ -153,6 +153,38 @@
             "max": null
           }
         },
+        {
+          "id": "gpt-6-luna",
+          "name": "GPT-6 Luna",
+          "reasoning": true,
+          "input": ["text", "image"],
+          "contextWindow": 327680,
+          "maxTokens": 128000,
+          "thinkingLevelMap": {
+            "minimal": null,
+            "low": "low",
+            "medium": null,
+            "high": "high",
+            "xhigh": null,
+            "max": "max"
+          }
+        },
+        {
+          "id": "gpt-6.1-sol",
+          "name": "GPT-6.1 Sol",
+          "reasoning": true,
+          "input": ["text", "image"],
+          "contextWindow": 327680,
+          "maxTokens": 128000,
+          "thinkingLevelMap": {
+            "minimal": null,
+            "low": "low",
+            "medium": "medium",
+            "high": "high",
+            "xhigh": "xhigh",
+            "max": "max"
+          }
+        },
         {
           "id": "kimi-k3",
           "name": "Kimi K3",

package/dist/defaults/settings.json

@@ -1,8 +1,4 @@
 {
-  "autoHandoff": {
-    "enabled": true,
-    "thresholdTokens": 256000
-  },
   "jevAdvisory": {
     "provider": "tokenin",
     "model": "jev-1.13",
@@ -11,17 +7,13 @@
       "recommendations": { "enabled": false }
     }
   },
-  "capabilityGateway": {
-    "routing": {
-      "jev": { "enabled": true }
-    }
-  },
   "collapseChangelog": true,
   "compaction": {
     "enabled": true,
     "keepRecentTokens": 32000,
     "reserveTokens": 64000
   },
+  "defaultTools": ["+codemode"],
   "defaultModel": "celestial-pro",
   "defaultProvider": "tokenin",
   "defaultThinkingLevel": "high",

package/dist/extensions/codemode/execute.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Runs one codemode script in the sandbox. Split from tool.ts and loaded through
+ * execute.lazy.ts so the sandbox runtime only loads when a script runs.
+ */
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { ExtensionToolContext } from "../../core/extensions/types.ts";
+import type { SessionEntry } from "../../core/session-manager.ts";
+import { type CodemodeToolDetails, type CodemodeToolInput, type CodemodeToolOptions } from "./tool.ts";
+/** Values of `load()`: the `codemode-store` entries on the branch, applied from the root. */
+export declare function readCodemodeStore(branch: readonly SessionEntry[]): Record<string, unknown>;
+/**
+ * Run one script. Without a session context (a plain Agent or a direct call) scripts cannot call
+ * tools, `store()` starts empty, and writes are dropped.
+ */
+export declare function executeCodemode(toolCallId: string, input: CodemodeToolInput, signal: AbortSignal | undefined, onUpdate: ((result: AgentToolResult<CodemodeToolDetails>) => void) | undefined, ctx: ExtensionToolContext | undefined, options?: CodemodeToolOptions): Promise<AgentToolResult<CodemodeToolDetails>>;