@selesai/code 0.13.40 → 0.14.3

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

@@ -1,16 +1,21 @@
-import type { ModelsStore, ModelsStoreEntry } from "@earendil-works/pi-ai";
+import type { ModelsStore, ModelsStoreEntry, ModelsStoreOperationOptions } from "@earendil-works/pi-ai";
 export declare class InMemoryCodingAgentModelsStore implements ModelsStore {
     private readonly entries;
-    read(providerId: string): Promise<ModelsStoreEntry | undefined>;
-    write(providerId: string, entry: ModelsStoreEntry): Promise<void>;
-    delete(providerId: string): Promise<void>;
+    read(providerId: string, options?: ModelsStoreOperationOptions): Promise<ModelsStoreEntry | undefined>;
+    write(providerId: string, entry: ModelsStoreEntry, options?: ModelsStoreOperationOptions): Promise<void>;
+    delete(providerId: string, options?: ModelsStoreOperationOptions): Promise<void>;
 }
 /** Locked JSON-backed storage for dynamically refreshed provider catalogs. */
 export declare class FileModelsStore implements ModelsStore {
     private readonly storage;
+    private readonly path;
+    private readonly readState;
     constructor(path?: string);
     private parse;
-    read(providerId: string): Promise<ModelsStoreEntry | undefined>;
-    write(providerId: string, entry: ModelsStoreEntry): Promise<void>;
-    delete(providerId: string): Promise<void>;
+    private updateReadState;
+    private reloadFromStorage;
+    private readLatest;
+    read(providerId: string, options?: ModelsStoreOperationOptions): Promise<ModelsStoreEntry | undefined>;
+    write(providerId: string, entry: ModelsStoreEntry, options?: ModelsStoreOperationOptions): Promise<void>;
+    delete(providerId: string, options?: ModelsStoreOperationOptions): Promise<void>;
 }

package/dist/core/models-store.js

@@ -1,44 +1,114 @@
 import { join } from "node:path";
 import { getAgentDir } from "../config.js";
+import { raceWithAbortSignal } from "../utils/abort.js";
+import { getFileRevision, normalizePath } from "../utils/paths.js";
+import { stripBom } from "../utils/text.js";
 import { FileAuthStorageBackend } from "./auth-storage.js";
+// Optimize the common path without retaining an unbounded set of custom paths.
+let sharedModelsFileReadState;
 export class InMemoryCodingAgentModelsStore {
     entries = new Map();
-    async read(providerId) {
-        return this.entries.get(providerId);
+    async read(providerId, options) {
+        options?.signal?.throwIfAborted();
+        const entry = this.entries.get(providerId);
+        return entry ? structuredClone(entry) : undefined;
     }
-    async write(providerId, entry) {
-        this.entries.set(providerId, entry);
+    async write(providerId, entry, options) {
+        options?.signal?.throwIfAborted();
+        this.entries.set(providerId, structuredClone(entry));
     }
-    async delete(providerId) {
+    async delete(providerId, options) {
+        options?.signal?.throwIfAborted();
         this.entries.delete(providerId);
     }
 }
 /** Locked JSON-backed storage for dynamically refreshed provider catalogs. */
 export class FileModelsStore {
     storage;
+    path;
+    readState;
     constructor(path = join(getAgentDir(), "models-store.json")) {
-        this.storage = new FileAuthStorageBackend(path);
+        this.path = normalizePath(path);
+        this.storage = new FileAuthStorageBackend(this.path);
+        this.readState =
+            sharedModelsFileReadState?.path === this.path ? sharedModelsFileReadState.readState : { data: {} };
+        if (!sharedModelsFileReadState) {
+            sharedModelsFileReadState = { path: this.path, readState: this.readState };
+        }
     }
     parse(content) {
-        return content ? JSON.parse(content) : {};
+        return content ? JSON.parse(stripBom(content)) : {};
     }
-    async read(providerId) {
-        return this.storage.withLock((content) => ({
-            result: structuredClone(this.parse(content)[providerId]),
-        }));
+    updateReadState(readState, data, revision) {
+        readState.data = data;
+        readState.revision = revision;
     }
-    async write(providerId, entry) {
+    reloadFromStorage(readState, options) {
+        return this.storage.withLockAsync(async (content) => {
+            const data = this.parse(content);
+            this.updateReadState(readState, data, getFileRevision(this.path));
+            return { result: data };
+        }, options);
+    }
+    async readLatest(readState, options) {
+        options?.signal?.throwIfAborted();
+        const revision = getFileRevision(this.path);
+        if (revision !== undefined && revision === readState.revision)
+            return readState.data;
+        if (!readState.reload) {
+            const controller = new AbortController();
+            const reload = {
+                controller,
+                promise: this.reloadFromStorage(readState, { signal: controller.signal }),
+                readers: 0,
+            };
+            readState.reload = reload;
+            void reload.promise.then(() => {
+                if (readState.reload === reload)
+                    readState.reload = undefined;
+            }, () => {
+                if (readState.reload === reload)
+                    readState.reload = undefined;
+            });
+        }
+        const reload = readState.reload;
+        reload.readers++;
+        try {
+            return await raceWithAbortSignal(reload.promise, options?.signal);
+        }
+        finally {
+            reload.readers--;
+            if (reload.readers === 0 && readState.reload === reload) {
+                readState.reload = undefined;
+                reload.controller.abort();
+            }
+        }
+    }
+    async read(providerId, options) {
+        const entry = (await this.readLatest(this.readState, options))[providerId];
+        options?.signal?.throwIfAborted();
+        return entry ? structuredClone(entry) : undefined;
+    }
+    async write(providerId, entry, options) {
+        let latest;
         await this.storage.withLockAsync(async (content) => {
             const current = this.parse(content);
             current[providerId] = structuredClone(entry);
+            latest = current;
             return { result: undefined, next: JSON.stringify(current, null, 2) };
-        });
+        }, options);
+        if (latest)
+            this.updateReadState(this.readState, latest);
     }
-    async delete(providerId) {
+    async delete(providerId, options) {
+        let latest;
         await this.storage.withLockAsync(async (content) => {
             const current = this.parse(content);
             delete current[providerId];
+            latest = current;
             return { result: undefined, next: JSON.stringify(current, null, 2) };
-        });
+        }, options);
+        if (latest)
+            this.updateReadState(this.readState, latest);
     }
 }

package/dist/core/nested-tool-calls.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Tool calls that a tool makes while it runs (`ctx.executeTool()`), for example from codemode
+ * scripts. The agent loop does not know about them: the session runs each one through the agent's
+ * tool pipeline (`runToolCall`) with its own hooks, emits `tool_execution_*` events with
+ * `parentToolCallId`, and records the calls and their usage on the model-issued call's tool result
+ * message.
+ *
+ * Nothing here runs until a tool calls `ctx.executeTool()`.
+ */
+import type { AgentTool, AgentToolCall, AgentToolCallOutcome, AgentToolResult, AgentToolUpdateCallback } from "@earendil-works/pi-agent-core";
+import type { NestedToolCallRecord, NestedToolCalls, Usage } from "@earendil-works/pi-ai";
+/**
+ * Limits of the nested-call record on a tool result: arguments
+ * over the per-call or total size are omitted, calls beyond the count are dropped, and the record
+ * is marked incomplete when any of that happens.
+ */
+export declare const NESTED_CALL_LIMITS: {
+    readonly maxCalls: 256;
+    readonly maxArgumentBytesPerCall: number;
+    readonly maxArgumentBytesTotal: number;
+    readonly maxErrorChars: 500;
+};
+/** What the nested calls of one model-issued tool call leave on its tool result message. */
+export interface NestedCallSummary {
+    /** Becomes `nestedCalls`. Undefined when no nested call was made. */
+    calls: NestedToolCalls | undefined;
+    /** Summed `usage` of the nested results, added to the message's `usage`. */
+    usage: Usage | undefined;
+}
+/**
+ * Collects the nested calls of one model-issued tool call, including calls made by nested tools.
+ * The snapshot becomes `nestedCalls` on the tool result message.
+ */
+export declare class NestedCallRecorder {
+    private readonly calls;
+    private readonly startedAt;
+    private complete;
+    private argumentBytes;
+    /** Summed usage of every nested result, including calls dropped from the record. */
+    private usage;
+    /** Record a call as it starts. Returns undefined when the call is dropped. */
+    start(toolCall: AgentToolCall): NestedToolCallRecord | undefined;
+    finish(record: NestedToolCallRecord | undefined, isError: boolean, errorText: string): void;
+    addUsage(usage: Usage): void;
+    get totalUsage(): Usage | undefined;
+    /** Copy of the record so far, or undefined when no nested call was made. */
+    snapshot(): NestedToolCalls | undefined;
+}
+export interface NestedToolCallOptions {
+    /** Defaults to the calling tool's signal. */
+    signal?: AbortSignal;
+    /** Receives partial results of the nested tool, in addition to `tool_execution_update` events. */
+    onUpdate?: AgentToolUpdateCallback;
+}
+/** `tool_execution_*` events of nested calls. */
+export type NestedToolExecutionEvent = {
+    type: "tool_execution_start";
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+    parentToolCallId: string;
+} | {
+    type: "tool_execution_update";
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+    partialResult: AgentToolResult<unknown>;
+    parentToolCallId: string;
+} | {
+    type: "tool_execution_end";
+    toolCallId: string;
+    toolName: string;
+    result: AgentToolResult<unknown>;
+    isError: boolean;
+    durationMs?: number;
+    parentToolCallId: string;
+};
+export interface NestedToolCallHost {
+    /** Tools nested calls resolve against. */
+    getTools(): readonly AgentTool[];
+    /** Whether every nested call runs exclusively, as when the agent executes tool calls sequentially. */
+    isSequential(): boolean;
+    /** Run the call through the tool pipeline, with hooks that report `parentToolCallId`. */
+    runToolCall(toolCall: AgentToolCall, parentToolCallId: string, signal: AbortSignal | undefined, onUpdate: (partialResult: AgentToolResult<unknown>) => Promise<void>): Promise<AgentToolCallOutcome>;
+    emit(event: NestedToolExecutionEvent): Promise<void>;
+}
+export declare class NestedToolCallRunner {
+    private readonly host;
+    /** Scopes by the id of the calling tool call. */
+    private readonly scopes;
+    /** Serializes nested calls that must not run concurrently. */
+    private queueTail;
+    constructor(host: NestedToolCallHost);
+    /**
+     * Run `name` on behalf of the call `callerId`. The nested call gets the id `<callerId>/<n>`.
+     * Never rejects for tool failures: they come back as `isError: true`.
+     */
+    execute(callerId: string, name: string, args: unknown, options?: NestedToolCallOptions): Promise<AgentToolCallOutcome>;
+    /** Remove and return the record of the nested calls a model-issued call made. */
+    takeRecord(toolCallId: string): NestedCallSummary | undefined;
+    clear(): void;
+}

package/dist/core/nested-tool-calls.js

@@ -0,0 +1,178 @@
+/**
+ * Tool calls that a tool makes while it runs (`ctx.executeTool()`), for example from codemode
+ * scripts. The agent loop does not know about them: the session runs each one through the agent's
+ * tool pipeline (`runToolCall`) with its own hooks, emits `tool_execution_*` events with
+ * `parentToolCallId`, and records the calls and their usage on the model-issued call's tool result
+ * message.
+ *
+ * Nothing here runs until a tool calls `ctx.executeTool()`.
+ */
+import { combineUsage } from "./usage-totals.js";
+/**
+ * Limits of the nested-call record on a tool result: arguments
+ * over the per-call or total size are omitted, calls beyond the count are dropped, and the record
+ * is marked incomplete when any of that happens.
+ */
+export const NESTED_CALL_LIMITS = {
+    maxCalls: 256,
+    maxArgumentBytesPerCall: 8 * 1024,
+    maxArgumentBytesTotal: 32 * 1024,
+    maxErrorChars: 500,
+};
+const encoder = new TextEncoder();
+/**
+ * Collects the nested calls of one model-issued tool call, including calls made by nested tools.
+ * The snapshot becomes `nestedCalls` on the tool result message.
+ */
+export class NestedCallRecorder {
+    calls = [];
+    startedAt = new Map();
+    complete = true;
+    argumentBytes = 0;
+    /** Summed usage of every nested result, including calls dropped from the record. */
+    usage;
+    /** Record a call as it starts. Returns undefined when the call is dropped. */
+    start(toolCall) {
+        if (this.calls.length >= NESTED_CALL_LIMITS.maxCalls) {
+            this.complete = false;
+            return undefined;
+        }
+        const record = { id: toolCall.id, name: toolCall.name, status: "unfinished" };
+        const json = JSON.stringify(toolCall.arguments ?? {});
+        const bytes = encoder.encode(json).length;
+        if (bytes > NESTED_CALL_LIMITS.maxArgumentBytesPerCall ||
+            this.argumentBytes + bytes > NESTED_CALL_LIMITS.maxArgumentBytesTotal) {
+            record.argumentsBytes = bytes;
+            this.complete = false;
+        }
+        else {
+            record.arguments = JSON.parse(json);
+            this.argumentBytes += bytes;
+        }
+        this.calls.push(record);
+        this.startedAt.set(record, performance.now());
+        return record;
+    }
+    finish(record, isError, errorText) {
+        if (!record)
+            return;
+        record.status = isError ? "error" : "ok";
+        record.durationMs = Math.round(performance.now() - (this.startedAt.get(record) ?? performance.now()));
+        this.startedAt.delete(record);
+        if (isError && errorText)
+            record.error = errorText.slice(0, NESTED_CALL_LIMITS.maxErrorChars);
+    }
+    addUsage(usage) {
+        this.usage = this.usage ? combineUsage(this.usage, usage) : usage;
+    }
+    get totalUsage() {
+        return this.usage;
+    }
+    /** Copy of the record so far, or undefined when no nested call was made. */
+    snapshot() {
+        if (this.calls.length === 0 && this.complete)
+            return undefined;
+        const calls = this.calls.map((call) => ({ ...call }));
+        return { calls, complete: this.complete && calls.every((call) => call.status !== "unfinished") };
+    }
+}
+function textOf(result) {
+    return (result.content ?? [])
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join("\n");
+}
+export class NestedToolCallRunner {
+    host;
+    /** Scopes by the id of the calling tool call. */
+    scopes = new Map();
+    /** Serializes nested calls that must not run concurrently. */
+    queueTail = Promise.resolve();
+    constructor(host) {
+        this.host = host;
+    }
+    /**
+     * Run `name` on behalf of the call `callerId`. The nested call gets the id `<callerId>/<n>`.
+     * Never rejects for tool failures: they come back as `isError: true`.
+     */
+    async execute(callerId, name, args, options = {}) {
+        let scope = this.scopes.get(callerId);
+        if (!scope) {
+            scope = { recorder: new NestedCallRecorder(), nextId: 1, holdsQueue: false };
+            this.scopes.set(callerId, scope);
+        }
+        const toolCall = {
+            type: "toolCall",
+            id: `${callerId}/${scope.nextId++}`,
+            name,
+            arguments: (args ?? {}),
+        };
+        const record = scope.recorder.start(toolCall);
+        await this.host.emit({
+            type: "tool_execution_start",
+            toolCallId: toolCall.id,
+            toolName: name,
+            args: toolCall.arguments,
+            parentToolCallId: callerId,
+        });
+        const exclusive = !scope.holdsQueue &&
+            (this.host.isSequential() ||
+                this.host.getTools().find((tool) => tool.name === name)?.executionMode === "sequential");
+        let release;
+        if (exclusive) {
+            const previous = this.queueTail;
+            this.queueTail = new Promise((resolve) => {
+                release = resolve;
+            });
+            await previous;
+        }
+        this.scopes.set(toolCall.id, {
+            recorder: scope.recorder,
+            nextId: 1,
+            holdsQueue: scope.holdsQueue || exclusive,
+        });
+        let outcome;
+        try {
+            outcome = await this.host.runToolCall(toolCall, callerId, options.signal, async (partialResult) => {
+                options.onUpdate?.(partialResult);
+                await this.host.emit({
+                    type: "tool_execution_update",
+                    toolCallId: toolCall.id,
+                    toolName: name,
+                    args: toolCall.arguments,
+                    partialResult,
+                    parentToolCallId: callerId,
+                });
+            });
+        }
+        finally {
+            this.scopes.delete(toolCall.id);
+            release?.();
+        }
+        scope.recorder.finish(record, outcome.isError, textOf(outcome.result));
+        // Nested results are not persisted, so their usage is only counted through the recorder.
+        if (outcome.result.usage)
+            scope.recorder.addUsage(outcome.result.usage);
+        await this.host.emit({
+            type: "tool_execution_end",
+            toolCallId: toolCall.id,
+            toolName: name,
+            result: outcome.result,
+            isError: outcome.isError,
+            ...(outcome.durationMs === undefined ? {} : { durationMs: outcome.durationMs }),
+            parentToolCallId: callerId,
+        });
+        return outcome;
+    }
+    /** Remove and return the record of the nested calls a model-issued call made. */
+    takeRecord(toolCallId) {
+        const scope = this.scopes.get(toolCallId);
+        this.scopes.delete(toolCallId);
+        if (!scope)
+            return undefined;
+        return { calls: scope.recorder.snapshot(), usage: scope.recorder.totalUsage };
+    }
+    clear() {
+        this.scopes.clear();
+    }
+}

package/dist/core/package-manager.d.ts

@@ -5,6 +5,7 @@ export interface PathMetadata {
     scope: SourceScope;
     origin: "package" | "top-level";
     baseDir?: string;
+    packageRoot?: string;
 }
 export interface ResolvedResource {
     path: string;
@@ -72,6 +73,8 @@ interface PackageManagerOptions {
     cwd: string;
     agentDir: string;
     settingsManager: SettingsManager;
+    /** Names of built-in extensions, resolved as `builtin:<name>` extension resources. */
+    builtinExtensions?: string[];
 }
 type SourceScope = "user" | "project" | "temporary";
 export declare function getExtensionTempFolder(agentDir: string): string;
@@ -88,6 +91,7 @@ export declare class DefaultPackageManager implements PackageManager {
     private cwd;
     private agentDir;
     private settingsManager;
+    private builtinExtensions;
     private globalNpmRoot;
     private globalNpmRootCommandKey;
     private progressCallback;
@@ -173,6 +177,10 @@ export declare class DefaultPackageManager implements PackageManager {
     private uninstallNpm;
     private installGit;
     private updateGit;
+    private hasMissingGitDependencies;
+    private repairMissingGitDependencies;
+    private getGitUpdateMarkerPath;
+    private cleanAndInstallGitDependencies;
     private ensureGitRef;
     private refreshTemporaryGitSource;
     private removeGit;
@@ -202,7 +210,6 @@ export declare class DefaultPackageManager implements PackageManager {
      * that pass the manifest's own patterns.
      */
     private collectManifestFiles;
-    private readPiManifest;
     private addManifestEntries;
     private collectFilesFromManifestEntries;
     private resolveLocalEntries;