@selesai/code 0.13.12 → 0.13.13

package/dist/core/runtime-credentials.d.ts

@@ -1,16 +0,0 @@
-import type { Credential, CredentialInfo, CredentialStore } from "@earendil-works/pi-ai";
-/** Async credential store overlay for non-persistent runtime API keys. */
-export declare class RuntimeCredentials implements CredentialStore {
-    private readonly store;
-    private readonly overrides;
-    constructor(store: CredentialStore);
-    setRuntimeApiKey(providerId: string, apiKey: string): void;
-    removeRuntimeApiKey(providerId: string): void;
-    hasRuntimeApiKey(providerId: string): boolean;
-    getStore(): CredentialStore;
-    reload(): void;
-    read(providerId: string): Promise<Credential | undefined>;
-    list(): Promise<readonly CredentialInfo[]>;
-    modify(providerId: string, fn: (current: Credential | undefined) => Promise<Credential | undefined>): Promise<Credential | undefined>;
-    delete(providerId: string): Promise<void>;
-}

package/dist/core/runtime-credentials.js

@@ -1,41 +0,0 @@
-/** Async credential store overlay for non-persistent runtime API keys. */
-export class RuntimeCredentials {
-    store;
-    overrides = new Map();
-    constructor(store) {
-        this.store = store;
-    }
-    setRuntimeApiKey(providerId, apiKey) {
-        this.overrides.set(providerId, apiKey);
-    }
-    removeRuntimeApiKey(providerId) {
-        this.overrides.delete(providerId);
-    }
-    hasRuntimeApiKey(providerId) {
-        return this.overrides.has(providerId);
-    }
-    getStore() {
-        return this.store;
-    }
-    reload() {
-        this.store.reload?.();
-    }
-    async read(providerId) {
-        const override = this.overrides.get(providerId);
-        return override ? { type: "api_key", key: override } : this.store.read(providerId);
-    }
-    async list() {
-        const entries = new Map((await this.store.list()).map((entry) => [entry.providerId, entry]));
-        for (const providerId of this.overrides.keys()) {
-            entries.set(providerId, { providerId, type: "api_key" });
-        }
-        return [...entries.values()];
-    }
-    modify(providerId, fn) {
-        return this.store.modify(providerId, fn);
-    }
-    async delete(providerId) {
-        this.overrides.delete(providerId);
-        await this.store.delete(providerId);
-    }
-}

package/dist/core/sdk.d.ts

@@ -1,107 +0,0 @@
-import { type ThinkingLevel } from "@earendil-works/pi-agent-core";
-import { type Model } from "@earendil-works/pi-ai/compat";
-import { AgentSession } from "./agent-session.ts";
-import type { LoadExtensionsResult, SessionStartEvent, ToolDefinition } from "./extensions/index.ts";
-import { ModelRuntime } from "./model-runtime.ts";
-import type { ResourceLoader } from "./resource-loader.ts";
-import { SessionManager } from "./session-manager.ts";
-import { SettingsManager } from "./settings-manager.ts";
-import { createBashTool, createCodingTools, createEditTool, createFindTool, createGrepTool, createLsTool, createPowerShellTool, createReadOnlyTools, createReadTool, createWriteTool, withFileMutationQueue } from "./tools/index.ts";
-export interface CreateAgentSessionOptions {
-    /** Working directory for project-local discovery. Default: process.cwd() */
-    cwd?: string;
-    /** Global config directory. Defaults to the configured agent directory. */
-    agentDir?: string;
-    /** Canonical model/auth runtime. Defaults to a runtime using agentDir/auth.json and models.json. */
-    modelRuntime?: ModelRuntime;
-    /** Model to use. Default: from settings, else first available */
-    model?: Model<any>;
-    /** Thinking level. Default: from settings, else 'medium' (clamped to model capabilities) */
-    thinkingLevel?: ThinkingLevel;
-    /** Models available for cycling (Ctrl+P in interactive mode) */
-    scopedModels?: Array<{
-        model: Model<any>;
-        thinkingLevel?: ThinkingLevel;
-    }>;
-    /**
-     * Optional default tool suppression mode when no explicit allowlist is provided.
-     *
-     * - "all": start with no tools enabled
-     * - "builtin": disable the default built-in tools (read, bash, edit, write, grep, find, ls)
-     *   but keep extension/custom tools enabled
-     */
-    noTools?: "all" | "builtin";
-    /**
-     * Optional allowlist of tool names.
-     *
-     * When omitted, pi uses the `defaultTools` setting for the initial built-in
-     * selection when configured. Otherwise it enables the default built-in tools
-     * (read, bash, edit, write, grep, find, ls). Extension/custom tools are inactive by default;
-     * `noTools: "builtin"` enables them instead. When provided, only the listed
-     * tool names are enabled.
-     */
-    tools?: string[];
-    /** Optional denylist of tool names to disable. Applies after `tools` when both are provided. */
-    excludeTools?: string[];
-    /** Custom tools to register (in addition to built-in tools). */
-    customTools?: ToolDefinition[];
-    /** Resource loader. When omitted, DefaultResourceLoader is used. */
-    resourceLoader?: ResourceLoader;
-    /** Session manager. Default: SessionManager.create(cwd) */
-    sessionManager?: SessionManager;
-    /** Settings manager. Default: SettingsManager.create(cwd, agentDir) */
-    settingsManager?: SettingsManager;
-    /** Session start event metadata for extension runtime startup. */
-    sessionStartEvent?: SessionStartEvent;
-}
-/** Result from createAgentSession */
-export interface CreateAgentSessionResult {
-    /** The created session */
-    session: AgentSession;
-    /** Extensions result (for UI context setup in interactive mode) */
-    extensionsResult: LoadExtensionsResult;
-    /** Warning if session was restored with a different model than saved */
-    modelFallbackMessage?: string;
-}
-export * from "./agent-session-runtime.ts";
-export type { ExtensionAPI, ExtensionCommandContext, ExtensionContext, ExtensionFactory, InlineExtension, SlashCommandInfo, SlashCommandSource, ToolDefinition, } from "./extensions/index.ts";
-export type { PromptTemplate } from "./prompt-templates.ts";
-export type { Skill } from "./skills.ts";
-export type { Tool } from "./tools/index.ts";
-export { withFileMutationQueue, createCodingTools, createReadOnlyTools, createReadTool, createBashTool, createPowerShellTool, createEditTool, createWriteTool, createGrepTool, createFindTool, createLsTool, };
-/**
- * Create an AgentSession with the specified options.
- *
- * @example
- * ```typescript
- * // Minimal - uses defaults
- * const { session } = await createAgentSession();
- *
- * // With explicit model
- * import { getModel } from '@earendil-works/pi-ai';
- * const { session } = await createAgentSession({
- *   model: getModel('anthropic', 'claude-opus-4-5'),
- *   thinkingLevel: 'high',
- * });
- *
- * // Continue previous session
- * const { session, modelFallbackMessage } = await createAgentSession({
- *   continueSession: true,
- * });
- *
- * // Full control
- * const loader = new DefaultResourceLoader({
- *   cwd: process.cwd(),
- *   agentDir: getAgentDir(),
- *   settingsManager: SettingsManager.create(),
- * });
- * await loader.reload();
- * const { session } = await createAgentSession({
- *   model: myModel,
- *   tools: ["read", "bash"],
- *   resourceLoader: loader,
- *   sessionManager: SessionManager.inMemory(),
- * });
- * ```
- */
-export declare function createAgentSession(options?: CreateAgentSessionOptions): Promise<CreateAgentSessionResult>;

package/dist/core/sdk.js

@@ -1,279 +0,0 @@
-import { join } from "node:path";
-import { Agent, setDefaultStreamFn } from "@earendil-works/pi-agent-core";
-import { clampThinkingLevel, streamSimple } from "@earendil-works/pi-ai/compat";
-import { getAgentDir } from "../config.js";
-import { resolvePath } from "../utils/paths.js";
-import { AgentSession } from "./agent-session.js";
-import { formatNoModelsAvailableMessage } from "./auth-guidance.js";
-import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
-import { convertToLlm } from "./messages.js";
-import { findInitialModel } from "./model-resolver.js";
-import { ModelRuntime } from "./model-runtime.js";
-import { mergeProviderAttributionHeaders } from "./provider-attribution.js";
-import { DefaultResourceLoader } from "./resource-loader.js";
-import { getDefaultSessionDir, SessionManager } from "./session-manager.js";
-import { SettingsManager } from "./settings-manager.js";
-import { time } from "./timings.js";
-import { createBashTool, createCodingTools, createEditTool, createFindTool, createGrepTool, createLsTool, createPowerShellTool, createReadOnlyTools, createReadTool, createWriteTool, withFileMutationQueue, } from "./tools/index.js";
-// Preserve the pre-0.81 fallback for extensions that construct Agent instances
-// or invoke low-level agent loops without supplying streamFn. Agent core remains
-// provider-agnostic and does not import pi-ai/compat itself.
-setDefaultStreamFn(streamSimple);
-// Re-exports
-export * from "./agent-session-runtime.js";
-export { withFileMutationQueue, 
-// Tool factories (for custom cwd)
-createCodingTools, createReadOnlyTools, createReadTool, createBashTool, createPowerShellTool, createEditTool, createWriteTool, createGrepTool, createFindTool, createLsTool, };
-// Helper Functions
-function getDefaultAgentDir() {
-    return getAgentDir();
-}
-/**
- * Create an AgentSession with the specified options.
- *
- * @example
- * ```typescript
- * // Minimal - uses defaults
- * const { session } = await createAgentSession();
- *
- * // With explicit model
- * import { getModel } from '@earendil-works/pi-ai';
- * const { session } = await createAgentSession({
- *   model: getModel('anthropic', 'claude-opus-4-5'),
- *   thinkingLevel: 'high',
- * });
- *
- * // Continue previous session
- * const { session, modelFallbackMessage } = await createAgentSession({
- *   continueSession: true,
- * });
- *
- * // Full control
- * const loader = new DefaultResourceLoader({
- *   cwd: process.cwd(),
- *   agentDir: getAgentDir(),
- *   settingsManager: SettingsManager.create(),
- * });
- * await loader.reload();
- * const { session } = await createAgentSession({
- *   model: myModel,
- *   tools: ["read", "bash"],
- *   resourceLoader: loader,
- *   sessionManager: SessionManager.inMemory(),
- * });
- * ```
- */
-export async function createAgentSession(options = {}) {
-    const cwd = resolvePath(options.cwd ?? options.sessionManager?.getCwd() ?? process.cwd());
-    const agentDir = options.agentDir ? resolvePath(options.agentDir) : getDefaultAgentDir();
-    let resourceLoader = options.resourceLoader;
-    const authPath = options.agentDir ? join(agentDir, "auth.json") : undefined;
-    const modelsPath = options.agentDir ? join(agentDir, "models.json") : undefined;
-    const modelRuntime = options.modelRuntime ?? (await ModelRuntime.create({ authPath, modelsPath }));
-    const settingsManager = options.settingsManager ?? SettingsManager.create(cwd, agentDir);
-    const sessionManager = options.sessionManager ?? SessionManager.create(cwd, getDefaultSessionDir(cwd, agentDir));
-    if (!resourceLoader) {
-        resourceLoader = new DefaultResourceLoader({ cwd, agentDir, settingsManager });
-        await resourceLoader.reload();
-        time("resourceLoader.reload");
-    }
-    // Check if session has existing data to restore
-    const existingSession = sessionManager.buildSessionContext();
-    const hasExistingSession = existingSession.messages.length > 0;
-    const hasThinkingEntry = sessionManager.getBranch().some((entry) => entry.type === "thinking_level_change");
-    let model = options.model;
-    let modelFallbackMessage;
-    // If session has data, try to restore model from it
-    if (!model && hasExistingSession && existingSession.model) {
-        const restoredModel = modelRuntime.getModel(existingSession.model.provider, existingSession.model.modelId);
-        if (restoredModel && modelRuntime.hasConfiguredAuth(restoredModel.provider)) {
-            model = restoredModel;
-        }
-        if (!model) {
-            modelFallbackMessage = `Could not restore model ${existingSession.model.provider}/${existingSession.model.modelId}`;
-        }
-    }
-    // If still no model, use findInitialModel (checks settings default, then provider defaults)
-    if (!model) {
-        const result = await findInitialModel({
-            scopedModels: [],
-            isContinuing: hasExistingSession,
-            defaultProvider: settingsManager.getDefaultProvider(),
-            defaultModelId: settingsManager.getDefaultModel(),
-            defaultThinkingLevel: settingsManager.getDefaultThinkingLevel(),
-            modelThinkingLevels: settingsManager.getAllModelThinkingLevels(),
-            modelRuntime,
-        });
-        model = result.model;
-        if (!model) {
-            modelFallbackMessage = formatNoModelsAvailableMessage();
-        }
-        else if (modelFallbackMessage) {
-            modelFallbackMessage += `. Using ${model.provider}/${model.id}`;
-        }
-    }
-    let thinkingLevel = options.thinkingLevel;
-    // If session has data, restore thinking level from it
-    if (thinkingLevel === undefined && hasExistingSession) {
-        thinkingLevel = hasThinkingEntry
-            ? existingSession.thinkingLevel
-            : (settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL);
-    }
-    // Fall back to the selected model's override, then settings default
-    if (thinkingLevel === undefined && model) {
-        thinkingLevel = settingsManager.getModelThinkingLevel(model.provider, model.id);
-    }
-    if (thinkingLevel === undefined) {
-        thinkingLevel = settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL;
-    }
-    // Clamp to model capabilities
-    if (!model) {
-        thinkingLevel = "off";
-    }
-    else {
-        thinkingLevel = clampThinkingLevel(model, thinkingLevel);
-    }
-    const defaultActiveToolNames = ["read", "bash", "edit", "write", "grep", "find", "ls"];
-    const configuredDefaultToolNames = settingsManager.getDefaultTools();
-    const allowedToolNames = options.tools ?? (options.noTools === "all" ? [] : undefined);
-    const excludedToolNames = options.excludeTools;
-    const excludedToolNameSet = excludedToolNames ? new Set(excludedToolNames) : undefined;
-    const initialActiveToolNames = (options.tools ??
-        (options.noTools === "builtin"
-            ? [
-                ...resourceLoader.getExtensions().extensions.flatMap((extension) => Array.from(extension.tools.keys())),
-                ...(options.customTools?.map((tool) => tool.name) ?? []),
-            ]
-            : options.noTools
-                ? []
-                : (configuredDefaultToolNames ?? defaultActiveToolNames))).filter((name) => !excludedToolNameSet?.has(name));
-    let agent;
-    // Create convertToLlm wrapper that filters images if blockImages is enabled (defense-in-depth)
-    const convertToLlmWithBlockImages = (messages) => {
-        const converted = convertToLlm(messages);
-        // Check setting dynamically so mid-session changes take effect
-        if (!settingsManager.getBlockImages()) {
-            return converted;
-        }
-        // Filter out ImageContent from all messages, replacing with text placeholder
-        return converted.map((msg) => {
-            if (msg.role === "user" || msg.role === "toolResult") {
-                const content = msg.content;
-                if (Array.isArray(content)) {
-                    const hasImages = content.some((c) => c.type === "image");
-                    if (hasImages) {
-                        const filteredContent = content
-                            .map((c) => c.type === "image" ? { type: "text", text: "Image reading is disabled." } : c)
-                            .filter((c, i, arr) => 
-                        // Dedupe consecutive "Image reading is disabled." texts
-                        !(c.type === "text" &&
-                            c.text === "Image reading is disabled." &&
-                            i > 0 &&
-                            arr[i - 1].type === "text" &&
-                            arr[i - 1].text === "Image reading is disabled."));
-                        return { ...msg, content: filteredContent };
-                    }
-                }
-            }
-            return msg;
-        });
-    };
-    const extensionRunnerRef = {};
-    agent = new Agent({
-        initialState: {
-            systemPrompt: "",
-            model,
-            thinkingLevel,
-            tools: [],
-        },
-        convertToLlm: convertToLlmWithBlockImages,
-        streamFn: async (model, context, options) => {
-            const providerRetrySettings = settingsManager.getProviderRetrySettings();
-            const httpIdleTimeoutMs = settingsManager.getHttpIdleTimeoutMs();
-            // SDKs treat timeout=0 as 0ms (immediate timeout), not "no timeout".
-            // Use max int32 to effectively disable the timeout.
-            const effectiveTimeoutMs = httpIdleTimeoutMs === 0 ? 2147483647 : httpIdleTimeoutMs;
-            const timeoutMs = options?.timeoutMs ?? providerRetrySettings.timeoutMs ?? effectiveTimeoutMs;
-            const websocketConnectTimeoutMs = options?.websocketConnectTimeoutMs ?? settingsManager.getWebSocketConnectTimeoutMs();
-            const headerRunner = extensionRunnerRef.current;
-            return modelRuntime.streamSimple(model, context, {
-                ...options,
-                timeoutMs,
-                websocketConnectTimeoutMs,
-                maxRetries: options?.maxRetries ?? providerRetrySettings.maxRetries,
-                maxRetryDelayMs: options?.maxRetryDelayMs ?? providerRetrySettings.maxRetryDelayMs,
-                transformHeaders: async (requestHeaders) => {
-                    const headers = mergeProviderAttributionHeaders(model, settingsManager, options?.sessionId, requestHeaders);
-                    return headerRunner?.hasHandlers("before_provider_headers")
-                        ? headerRunner.emitBeforeProviderHeaders(headers ?? {})
-                        : (headers ?? {});
-                },
-            });
-        },
-        onPayload: async (payload, _model) => {
-            const runner = extensionRunnerRef.current;
-            if (!runner?.hasHandlers("before_provider_request")) {
-                return payload;
-            }
-            return runner.emitBeforeProviderRequest(payload);
-        },
-        onResponse: async (response, _model) => {
-            const runner = extensionRunnerRef.current;
-            if (!runner?.hasHandlers("after_provider_response")) {
-                return;
-            }
-            await runner.emit({
-                type: "after_provider_response",
-                status: response.status,
-                headers: response.headers,
-            });
-        },
-        sessionId: sessionManager.getSessionId(),
-        transformContext: async (messages) => {
-            const runner = extensionRunnerRef.current;
-            if (!runner)
-                return messages;
-            return runner.emitContext(messages);
-        },
-        steeringMode: settingsManager.getSteeringMode(),
-        followUpMode: settingsManager.getFollowUpMode(),
-        transport: settingsManager.getTransport(),
-        thinkingBudgets: settingsManager.getThinkingBudgets(),
-        maxRetryDelayMs: settingsManager.getProviderRetrySettings().maxRetryDelayMs,
-    });
-    // Restore messages if session has existing data
-    if (hasExistingSession) {
-        agent.state.messages = existingSession.messages;
-        if (!hasThinkingEntry) {
-            sessionManager.appendThinkingLevelChange(thinkingLevel);
-        }
-    }
-    else {
-        // Save initial model and thinking level for new sessions so they can be restored on resume
-        if (model) {
-            sessionManager.appendModelChange(model.provider, model.id);
-        }
-        sessionManager.appendThinkingLevelChange(thinkingLevel);
-    }
-    const session = new AgentSession({
-        agent,
-        sessionManager,
-        settingsManager,
-        cwd,
-        scopedModels: options.scopedModels,
-        resourceLoader,
-        customTools: options.customTools,
-        modelRuntime,
-        initialActiveToolNames,
-        allowedToolNames,
-        excludedToolNames,
-        extensionRunnerRef,
-        sessionStartEvent: options.sessionStartEvent,
-    });
-    const extensionsResult = resourceLoader.getExtensions();
-    return {
-        session,
-        extensionsResult,
-        modelFallbackMessage,
-    };
-}

package/dist/core/session-cwd.d.ts

@@ -1,18 +0,0 @@
-export interface SessionCwdIssue {
-    sessionFile?: string;
-    sessionCwd: string;
-    fallbackCwd: string;
-}
-interface SessionCwdSource {
-    getCwd(): string;
-    getSessionFile(): string | undefined;
-}
-export declare function getMissingSessionCwdIssue(sessionManager: SessionCwdSource, fallbackCwd: string): SessionCwdIssue | undefined;
-export declare function formatMissingSessionCwdError(issue: SessionCwdIssue): string;
-export declare function formatMissingSessionCwdPrompt(issue: SessionCwdIssue): string;
-export declare class MissingSessionCwdError extends Error {
-    readonly issue: SessionCwdIssue;
-    constructor(issue: SessionCwdIssue);
-}
-export declare function assertSessionCwdExists(sessionManager: SessionCwdSource, fallbackCwd: string): void;
-export {};

package/dist/core/session-cwd.js

@@ -1,37 +0,0 @@
-import { existsSync } from "node:fs";
-export function getMissingSessionCwdIssue(sessionManager, fallbackCwd) {
-    const sessionFile = sessionManager.getSessionFile();
-    if (!sessionFile) {
-        return undefined;
-    }
-    const sessionCwd = sessionManager.getCwd();
-    if (!sessionCwd || existsSync(sessionCwd)) {
-        return undefined;
-    }
-    return {
-        sessionFile,
-        sessionCwd,
-        fallbackCwd,
-    };
-}
-export function formatMissingSessionCwdError(issue) {
-    const sessionFile = issue.sessionFile ? `\nSession file: ${issue.sessionFile}` : "";
-    return `Stored session working directory does not exist: ${issue.sessionCwd}${sessionFile}\nCurrent working directory: ${issue.fallbackCwd}`;
-}
-export function formatMissingSessionCwdPrompt(issue) {
-    return `cwd from session file does not exist\n${issue.sessionCwd}\n\ncontinue in current cwd\n${issue.fallbackCwd}`;
-}
-export class MissingSessionCwdError extends Error {
-    issue;
-    constructor(issue) {
-        super(formatMissingSessionCwdError(issue));
-        this.name = "MissingSessionCwdError";
-        this.issue = issue;
-    }
-}
-export function assertSessionCwdExists(sessionManager, fallbackCwd) {
-    const issue = getMissingSessionCwdIssue(sessionManager, fallbackCwd);
-    if (issue) {
-        throw new MissingSessionCwdError(issue);
-    }
-}