@selesai/code 0.13.11 → 0.13.13

package/dist/core/extensions/types.js

@@ -1,44 +0,0 @@
-/**
- * Extension system types.
- *
- * Extensions are TypeScript modules that can:
- * - Subscribe to agent lifecycle events
- * - Register LLM-callable tools
- * - Register commands, keyboard shortcuts, and CLI flags
- * - Interact with the user via UI primitives
- */
-/**
- * Preserve parameter inference for standalone tool definitions.
- *
- * Use this when assigning a tool to a variable or passing it through arrays such
- * as `customTools`, where contextual typing would otherwise widen params to
- * `unknown`.
- */
-export function defineTool(tool) {
-    return tool;
-}
-// Type guards for ToolResultEvent
-export function isBashToolResult(e) {
-    return e.toolName === "bash";
-}
-export function isReadToolResult(e) {
-    return e.toolName === "read";
-}
-export function isEditToolResult(e) {
-    return e.toolName === "edit";
-}
-export function isWriteToolResult(e) {
-    return e.toolName === "write";
-}
-export function isGrepToolResult(e) {
-    return e.toolName === "grep";
-}
-export function isFindToolResult(e) {
-    return e.toolName === "find";
-}
-export function isLsToolResult(e) {
-    return e.toolName === "ls";
-}
-export function isToolCallEventType(toolName, event) {
-    return event.toolName === toolName;
-}

package/dist/core/extensions/wrapper.d.ts

@@ -1,19 +0,0 @@
-/**
- * Tool wrappers for extension-registered tools.
- *
- * These wrappers only adapt tool execution so extension tools receive the runner context.
- * Tool call and tool result interception is handled by AgentSession via agent-core hooks.
- */
-import type { AgentTool } from "@earendil-works/pi-agent-core";
-import type { ExtensionRunner } from "./runner.ts";
-import type { RegisteredTool } from "./types.ts";
-/**
- * Wrap a RegisteredTool into an AgentTool.
- * Uses the runner's createContext() for consistent context across tools and event handlers.
- */
-export declare function wrapRegisteredTool(registeredTool: RegisteredTool, runner: ExtensionRunner): AgentTool;
-/**
- * Wrap all registered tools into AgentTools.
- * Uses the runner's createContext() for consistent context across tools and event handlers.
- */
-export declare function wrapRegisteredTools(registeredTools: RegisteredTool[], runner: ExtensionRunner): AgentTool[];

package/dist/core/extensions/wrapper.js

@@ -1,40 +0,0 @@
-/**
- * Tool wrappers for extension-registered tools.
- *
- * These wrappers only adapt tool execution so extension tools receive the runner context.
- * Tool call and tool result interception is handled by AgentSession via agent-core hooks.
- */
-import { wrapToolDefinition } from "../tools/tool-definition-wrapper.js";
-/**
- * Wrap a RegisteredTool into an AgentTool.
- * Uses the runner's createContext() for consistent context across tools and event handlers.
- */
-export function wrapRegisteredTool(registeredTool, runner) {
-    const tool = wrapToolDefinition(registeredTool.definition, () => runner.createContext());
-    const execute = tool.execute;
-    return {
-        ...tool,
-        execute: async (toolCallId, params, signal, onUpdate) => {
-            const activeBefore = runner.getActiveTools();
-            const result = await execute(toolCallId, params, signal, onUpdate);
-            const activeAfter = runner.getActiveTools();
-            if (!activeBefore.every((name) => activeAfter.includes(name)))
-                return result;
-            const beforeNames = new Set(activeBefore);
-            const addedToolNames = activeAfter.filter((name) => !beforeNames.has(name));
-            if (addedToolNames.length === 0)
-                return result;
-            return {
-                ...result,
-                addedToolNames: [...new Set([...(result.addedToolNames ?? []), ...addedToolNames])],
-            };
-        },
-    };
-}
-/**
- * Wrap all registered tools into AgentTools.
- * Uses the runner's createContext() for consistent context across tools and event handlers.
- */
-export function wrapRegisteredTools(registeredTools, runner) {
-    return registeredTools.map((tool) => wrapRegisteredTool(tool, runner));
-}

package/dist/core/footer-data-provider.d.ts

@@ -1,63 +0,0 @@
-export type GitPaths = {
-    repoDir: string;
-    commonGitDir: string;
-    headPath: string;
-};
-/**
- * Find git metadata paths by walking up from cwd.
- * Handles both regular git repos (.git is a directory) and worktrees (.git is a file).
- */
-export declare function findGitPaths(cwd: string): GitPaths | null;
-/**
- * Provides git branch and extension statuses - data not otherwise accessible to extensions.
- * Token stats, model info available via ctx.sessionManager and ctx.model.
- */
-export declare class FooterDataProvider {
-    private cwd;
-    private static readonly WATCH_DEBOUNCE_MS;
-    private extensionStatuses;
-    private cachedBranch;
-    private gitPaths;
-    private headWatcher;
-    private headWatchFilePath;
-    private headWatchFileListener;
-    private reftableWatcher;
-    private reftableTablesListWatcher;
-    private reftableTablesListPath;
-    private branchChangeCallbacks;
-    private availableProviderCount;
-    private refreshTimer;
-    private gitWatcherRetryTimer;
-    private refreshInFlight;
-    private refreshPending;
-    private disposed;
-    constructor(cwd: string);
-    /** Current git branch, null if not in repo, "detached" if detached HEAD */
-    getGitBranch(): string | null;
-    /** Extension status texts set via ctx.ui.setStatus() */
-    getExtensionStatuses(): ReadonlyMap<string, string>;
-    /** Subscribe to git branch changes. Returns unsubscribe function. */
-    onBranchChange(callback: () => void): () => void;
-    /** Internal: set extension status */
-    setExtensionStatus(key: string, text: string | undefined): void;
-    /** Internal: clear extension statuses */
-    clearExtensionStatuses(): void;
-    /** Number of unique providers with available models (for footer display) */
-    getAvailableProviderCount(): number;
-    /** Internal: update available provider count */
-    setAvailableProviderCount(count: number): void;
-    setCwd(cwd: string): void;
-    /** Internal: cleanup */
-    dispose(): void;
-    private notifyBranchChange;
-    private scheduleRefresh;
-    private refreshGitBranchAsync;
-    private resolveGitBranchSync;
-    private resolveGitBranchAsync;
-    private clearGitWatchers;
-    private scheduleGitWatcherRetry;
-    private handleGitWatcherError;
-    private setupGitWatcher;
-}
-/** Read-only view for extensions - excludes setExtensionStatus, setAvailableProviderCount and dispose */
-export type ReadonlyFooterDataProvider = Pick<FooterDataProvider, "getGitBranch" | "getExtensionStatuses" | "getAvailableProviderCount" | "onBranchChange">;

package/dist/core/footer-data-provider.js

@@ -1,337 +0,0 @@
-import { execFile, spawnSync } from "child_process";
-import { existsSync, readFileSync, statSync, unwatchFile, watchFile } from "fs";
-import { dirname, join, resolve } from "path";
-import { closeWatcher, FS_WATCH_RETRY_DELAY_MS, watchWithErrorHandler } from "../utils/fs-watch.js";
-/**
- * Find git metadata paths by walking up from cwd.
- * Handles both regular git repos (.git is a directory) and worktrees (.git is a file).
- */
-export function findGitPaths(cwd) {
-    let dir = cwd;
-    while (true) {
-        const gitPath = join(dir, ".git");
-        if (existsSync(gitPath)) {
-            try {
-                const stat = statSync(gitPath);
-                if (stat.isFile()) {
-                    const content = readFileSync(gitPath, "utf8").trim();
-                    if (content.startsWith("gitdir: ")) {
-                        const gitDir = resolve(dir, content.slice(8).trim());
-                        const headPath = join(gitDir, "HEAD");
-                        if (!existsSync(headPath))
-                            return null;
-                        const commonDirPath = join(gitDir, "commondir");
-                        const commonGitDir = existsSync(commonDirPath)
-                            ? resolve(gitDir, readFileSync(commonDirPath, "utf8").trim())
-                            : gitDir;
-                        return { repoDir: dir, commonGitDir, headPath };
-                    }
-                }
-                else if (stat.isDirectory()) {
-                    const headPath = join(gitPath, "HEAD");
-                    if (!existsSync(headPath))
-                        return null;
-                    return { repoDir: dir, commonGitDir: gitPath, headPath };
-                }
-            }
-            catch {
-                return null;
-            }
-        }
-        const parent = dirname(dir);
-        if (parent === dir)
-            return null;
-        dir = parent;
-    }
-}
-/** Ask git for the current branch. Returns null on detached HEAD or if git is unavailable. */
-function resolveBranchWithGitSync(repoDir) {
-    const result = spawnSync("git", ["--no-optional-locks", "symbolic-ref", "--quiet", "--short", "HEAD"], {
-        cwd: repoDir,
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"],
-    });
-    const branch = result.status === 0 ? result.stdout.trim() : "";
-    return branch || null;
-}
-/** Ask git for the current branch asynchronously. Returns null on detached HEAD or if git is unavailable. */
-function resolveBranchWithGitAsync(repoDir) {
-    return new Promise((resolvePromise) => {
-        execFile("git", ["--no-optional-locks", "symbolic-ref", "--quiet", "--short", "HEAD"], {
-            cwd: repoDir,
-            encoding: "utf8",
-        }, (error, stdout) => {
-            if (error) {
-                resolvePromise(null);
-                return;
-            }
-            const branch = stdout.trim();
-            resolvePromise(branch || null);
-        });
-    });
-}
-function isWslEnvironment() {
-    return process.platform === "linux" && !!(process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP);
-}
-function isWindowsMountedRepoPath(repoDir) {
-    return /^\/mnt\/[a-z](?:\/|$)/i.test(repoDir);
-}
-function shouldPollGitHead(repoDir) {
-    return isWslEnvironment() && isWindowsMountedRepoPath(repoDir);
-}
-/**
- * Provides git branch and extension statuses - data not otherwise accessible to extensions.
- * Token stats, model info available via ctx.sessionManager and ctx.model.
- */
-export class FooterDataProvider {
-    cwd;
-    static WATCH_DEBOUNCE_MS = 500;
-    extensionStatuses = new Map();
-    cachedBranch = undefined;
-    gitPaths = undefined;
-    headWatcher = null;
-    headWatchFilePath = null;
-    headWatchFileListener = null;
-    reftableWatcher = null;
-    reftableTablesListWatcher = null;
-    reftableTablesListPath = null;
-    branchChangeCallbacks = new Set();
-    availableProviderCount = 0;
-    refreshTimer = null;
-    gitWatcherRetryTimer = null;
-    refreshInFlight = false;
-    refreshPending = false;
-    disposed = false;
-    constructor(cwd) {
-        this.cwd = cwd;
-        this.gitPaths = findGitPaths(cwd);
-        this.setupGitWatcher();
-    }
-    /** Current git branch, null if not in repo, "detached" if detached HEAD */
-    getGitBranch() {
-        if (this.cachedBranch === undefined) {
-            this.cachedBranch = this.resolveGitBranchSync();
-        }
-        return this.cachedBranch;
-    }
-    /** Extension status texts set via ctx.ui.setStatus() */
-    getExtensionStatuses() {
-        return this.extensionStatuses;
-    }
-    /** Subscribe to git branch changes. Returns unsubscribe function. */
-    onBranchChange(callback) {
-        this.branchChangeCallbacks.add(callback);
-        return () => this.branchChangeCallbacks.delete(callback);
-    }
-    /** Internal: set extension status */
-    setExtensionStatus(key, text) {
-        if (text === undefined) {
-            this.extensionStatuses.delete(key);
-        }
-        else {
-            this.extensionStatuses.set(key, text);
-        }
-    }
-    /** Internal: clear extension statuses */
-    clearExtensionStatuses() {
-        this.extensionStatuses.clear();
-    }
-    /** Number of unique providers with available models (for footer display) */
-    getAvailableProviderCount() {
-        return this.availableProviderCount;
-    }
-    /** Internal: update available provider count */
-    setAvailableProviderCount(count) {
-        this.availableProviderCount = count;
-    }
-    setCwd(cwd) {
-        if (this.cwd === cwd) {
-            return;
-        }
-        this.cwd = cwd;
-        if (this.refreshTimer) {
-            clearTimeout(this.refreshTimer);
-            this.refreshTimer = null;
-        }
-        this.clearGitWatchers();
-        this.cachedBranch = undefined;
-        this.gitPaths = findGitPaths(cwd);
-        this.setupGitWatcher();
-        this.notifyBranchChange();
-    }
-    /** Internal: cleanup */
-    dispose() {
-        this.disposed = true;
-        if (this.refreshTimer) {
-            clearTimeout(this.refreshTimer);
-            this.refreshTimer = null;
-        }
-        this.clearGitWatchers();
-        this.branchChangeCallbacks.clear();
-    }
-    notifyBranchChange() {
-        for (const cb of this.branchChangeCallbacks)
-            cb();
-    }
-    scheduleRefresh() {
-        if (this.disposed || this.refreshTimer)
-            return;
-        if (this.refreshInFlight) {
-            this.refreshPending = true;
-            return;
-        }
-        this.refreshTimer = setTimeout(() => {
-            this.refreshTimer = null;
-            void this.refreshGitBranchAsync();
-        }, FooterDataProvider.WATCH_DEBOUNCE_MS);
-    }
-    async refreshGitBranchAsync() {
-        if (this.disposed)
-            return;
-        if (this.refreshInFlight) {
-            this.refreshPending = true;
-            return;
-        }
-        this.refreshInFlight = true;
-        try {
-            const nextBranch = await this.resolveGitBranchAsync();
-            if (this.disposed)
-                return;
-            if (this.cachedBranch !== undefined && this.cachedBranch !== nextBranch) {
-                this.cachedBranch = nextBranch;
-                this.notifyBranchChange();
-                return;
-            }
-            this.cachedBranch = nextBranch;
-        }
-        finally {
-            this.refreshInFlight = false;
-            if (this.refreshPending && !this.disposed) {
-                this.refreshPending = false;
-                this.scheduleRefresh();
-            }
-        }
-    }
-    resolveGitBranchSync() {
-        try {
-            if (!this.gitPaths)
-                return null;
-            const content = readFileSync(this.gitPaths.headPath, "utf8").trim();
-            if (content.startsWith("ref: refs/heads/")) {
-                const branch = content.slice(16);
-                return branch === ".invalid" ? (resolveBranchWithGitSync(this.gitPaths.repoDir) ?? "detached") : branch;
-            }
-            return "detached";
-        }
-        catch {
-            return null;
-        }
-    }
-    async resolveGitBranchAsync() {
-        try {
-            if (!this.gitPaths)
-                return null;
-            const content = readFileSync(this.gitPaths.headPath, "utf8").trim();
-            if (content.startsWith("ref: refs/heads/")) {
-                const branch = content.slice(16);
-                return branch === ".invalid"
-                    ? ((await resolveBranchWithGitAsync(this.gitPaths.repoDir)) ?? "detached")
-                    : branch;
-            }
-            return "detached";
-        }
-        catch {
-            return null;
-        }
-    }
-    clearGitWatchers() {
-        closeWatcher(this.headWatcher);
-        this.headWatcher = null;
-        if (this.headWatchFilePath && this.headWatchFileListener) {
-            unwatchFile(this.headWatchFilePath, this.headWatchFileListener);
-            this.headWatchFilePath = null;
-            this.headWatchFileListener = null;
-        }
-        closeWatcher(this.reftableWatcher);
-        this.reftableWatcher = null;
-        closeWatcher(this.reftableTablesListWatcher);
-        this.reftableTablesListWatcher = null;
-        if (this.reftableTablesListPath) {
-            unwatchFile(this.reftableTablesListPath);
-            this.reftableTablesListPath = null;
-        }
-        if (this.gitWatcherRetryTimer) {
-            clearTimeout(this.gitWatcherRetryTimer);
-            this.gitWatcherRetryTimer = null;
-        }
-    }
-    scheduleGitWatcherRetry() {
-        if (this.disposed || this.gitWatcherRetryTimer) {
-            return;
-        }
-        this.gitWatcherRetryTimer = setTimeout(() => {
-            this.gitWatcherRetryTimer = null;
-            this.setupGitWatcher();
-        }, FS_WATCH_RETRY_DELAY_MS);
-    }
-    handleGitWatcherError() {
-        this.clearGitWatchers();
-        this.scheduleGitWatcherRetry();
-    }
-    setupGitWatcher() {
-        this.clearGitWatchers();
-        if (!this.gitPaths)
-            return;
-        const pollGitHead = shouldPollGitHead(this.gitPaths.repoDir);
-        // Watch the directory containing HEAD, not HEAD itself.
-        // Git uses atomic writes (write temp, rename over HEAD), which changes the inode.
-        // fs.watch on a file stops working after the inode changes.
-        this.headWatcher = watchWithErrorHandler(dirname(this.gitPaths.headPath), (_eventType, filename) => {
-            if (!filename || filename === "HEAD") {
-                this.scheduleRefresh();
-            }
-        }, () => this.handleGitWatcherError());
-        if (pollGitHead) {
-            this.headWatchFilePath = this.gitPaths.headPath;
-            this.headWatchFileListener = (current, previous) => {
-                if (current.mtimeMs !== previous.mtimeMs ||
-                    current.ctimeMs !== previous.ctimeMs ||
-                    current.size !== previous.size) {
-                    this.scheduleRefresh();
-                }
-            };
-            watchFile(this.headWatchFilePath, { interval: 1000 }, this.headWatchFileListener);
-        }
-        if (!this.headWatcher && !pollGitHead) {
-            return;
-        }
-        // In reftable repos, branch switches update files in the reftable directory
-        // instead of HEAD. Watch it separately so the footer picks up those changes.
-        const reftableDir = join(this.gitPaths.commonGitDir, "reftable");
-        if (existsSync(reftableDir)) {
-            this.reftableWatcher = watchWithErrorHandler(reftableDir, () => {
-                this.scheduleRefresh();
-            }, () => this.handleGitWatcherError());
-            if (!this.reftableWatcher) {
-                return;
-            }
-            const tablesListPath = join(reftableDir, "tables.list");
-            if (existsSync(tablesListPath)) {
-                this.reftableTablesListPath = tablesListPath;
-                this.reftableTablesListWatcher = watchWithErrorHandler(tablesListPath, () => {
-                    this.scheduleRefresh();
-                }, () => this.handleGitWatcherError());
-                if (!this.reftableTablesListWatcher) {
-                    return;
-                }
-                watchFile(tablesListPath, { interval: 250 }, (current, previous) => {
-                    if (current.mtimeMs !== previous.mtimeMs ||
-                        current.ctimeMs !== previous.ctimeMs ||
-                        current.size !== previous.size) {
-                        this.scheduleRefresh();
-                    }
-                });
-            }
-        }
-    }
-}

package/dist/core/git-command.d.ts

@@ -1,8 +0,0 @@
-export interface GitCommandMode {
-    name: string;
-    aliases: string[];
-    description: string;
-    instructions: string;
-}
-export declare const GIT_COMMAND_MODES: ReadonlyArray<GitCommandMode>;
-export declare function buildGitCommandPrompt(input: string): string;

package/dist/core/git-command.js

@@ -1,48 +0,0 @@
-export const GIT_COMMAND_MODES = [
-    {
-        name: "worktree",
-        aliases: ["wt", "work-tree", "work tree"],
-        description: "Create, list, switch, or clean up git worktrees",
-        instructions: "Focus on git worktrees. Start with `git worktree list` and `git status --short --branch`. Help create, switch to, or clean up worktrees only after confirming the target branch/path.",
-    },
-    {
-        name: "checkpoint",
-        aliases: ["cp", "checkpoints", "save"],
-        description: "Save or restore small checkpoint commits",
-        instructions: "Focus on checkpoints. If saving, inspect the diff, summarize changes, propose a small checkpoint commit message, then wait for confirmation before staging or committing. If restoring, follow the restore flow. Do not push unless asked.",
-    },
-    {
-        name: "restore",
-        aliases: ["recover", "rollback"],
-        description: "Restore files from a checkpoint or commit safely",
-        instructions: "Focus on safe restore. Start with `git status --short --branch` and identify the checkpoint/ref. If there are local changes, ask the user to choose: stash them first (recommended) or discard them. Do not restore, stash, discard, reset, or checkout until the user explicitly confirms.",
-    },
-    {
-        name: "push",
-        aliases: ["commit", "publish", "sync"],
-        description: "Commit, push, pull, and related remote actions",
-        instructions: "Focus on commit/push workflow. Inspect status, branch, remotes, and recent commits. Propose the minimal commit/push steps, then wait for confirmation before committing, pulling, or pushing.",
-    },
-];
-function parseGitMode(input) {
-    const trimmed = input.trim();
-    if (!trimmed)
-        return { rest: "" };
-    const lower = trimmed.toLowerCase();
-    for (const mode of GIT_COMMAND_MODES) {
-        const names = [mode.name, ...mode.aliases].map((name) => name.toLowerCase());
-        const match = names.find((name) => lower === name || lower.startsWith(`${name} `));
-        if (match) {
-            return { mode, rest: trimmed.slice(match.length).trim() };
-        }
-    }
-    return { rest: trimmed };
-}
-export function buildGitCommandPrompt(input) {
-    const { mode, rest } = parseGitMode(input);
-    const requested = rest ? `\nUser request: ${rest}` : "";
-    const modeLine = mode
-        ? mode.instructions
-        : "Start by running `git status --short --branch`. Then help the user choose between worktrees, checkpoints, restore, or commit/push actions.";
-    return `Git helper for this repository.\n${modeLine}\nSafety: do not discard changes, delete branches/worktrees, reset, force-push, or push anything until the user explicitly confirms.${requested}`;
-}

package/dist/core/handoff.d.ts

@@ -1,11 +0,0 @@
-import type { AgentMessage } from "@earendil-works/pi-agent-core";
-import type { AssistantMessage, Context } from "@earendil-works/pi-ai";
-import type { Model } from "@earendil-works/pi-ai";
-import type { SessionEntry } from "./session-manager.ts";
-export declare const DEFAULT_HANDOFF_GOAL = "Continue the previous session from this handoff.";
-export declare function entryToMessage(entry: SessionEntry): AgentMessage | undefined;
-export declare function getHandoffMessages(branch: SessionEntry[]): AgentMessage[];
-export declare function buildAiContext(conversationText: string, goal: string): Context;
-export declare function generateHandoff(model: Model<any>, modelRuntime: {
-    complete(model: Model<any>, context: Context): Promise<AssistantMessage>;
-}, branch: SessionEntry[], goal?: string): Promise<string>;

package/dist/core/handoff.js

@@ -1,49 +0,0 @@
-import { serializeConversation } from "./compaction/utils.js";
-import { convertToLlm } from "./messages.js";
-export const DEFAULT_HANDOFF_GOAL = "Continue the previous session from this handoff.";
-const SYSTEM_PROMPT = `Write a handoff document for a fresh agent to continue the current conversation. Return only the handoff document text; do not save a file or describe saving one. No question, no fluff, just write the handoff. Do not reproduce, quote, or reformat the conversation history or its tool calls — distill it into what matters; never emit transcript-style markup or raw tool-call text.
-
-Include a "suggested skills" section in the document, which suggests skills that the agent should invoke.
-
-Do not duplicate content already captured in other artifacts (PRDs, plans, ADRs, issues, commits, diffs). Reference them by path or URL instead.
-
-Redact any sensitive information, such as API keys, passwords, or personally identifiable information.
-
-If the user passed arguments, treat them as a description of what the next session will focus on and tailor the doc accordingly.`;
-export function entryToMessage(entry) {
-    if (entry.type === "message")
-        return entry.message;
-    if (entry.type === "compaction") {
-        return { role: "compactionSummary", summary: entry.summary, tokensBefore: entry.tokensBefore, timestamp: new Date(entry.timestamp).getTime() };
-    }
-    return undefined;
-}
-export function getHandoffMessages(branch) {
-    let compactionIndex = -1;
-    for (let i = branch.length - 1; i >= 0; i--)
-        if (branch[i].type === "compaction") {
-            compactionIndex = i;
-            break;
-        }
-    if (compactionIndex < 0)
-        return branch.map(entryToMessage).filter((m) => m !== undefined);
-    const compaction = branch[compactionIndex];
-    const firstKeptIndex = compaction.type === "compaction" ? branch.findIndex((entry) => entry.id === compaction.firstKeptEntryId) : -1;
-    return [compaction, ...(firstKeptIndex >= 0 ? branch.slice(firstKeptIndex, compactionIndex) : []), ...branch.slice(compactionIndex + 1)]
-        .map(entryToMessage).filter((m) => m !== undefined);
-}
-export function buildAiContext(conversationText, goal) {
-    return { systemPrompt: SYSTEM_PROMPT, messages: [{ role: "user", content: [{ type: "text", text: `## Conversation History\n\n${conversationText}\n\n## User's Goal for New Thread\n\n${goal}` }], timestamp: Date.now() }] };
-}
-export async function generateHandoff(model, modelRuntime, branch, goal = DEFAULT_HANDOFF_GOAL) {
-    const messages = getHandoffMessages(branch);
-    if (messages.length === 0)
-        throw new Error("No conversation to hand off");
-    const response = await modelRuntime.complete(model, buildAiContext(serializeConversation(convertToLlm(messages)), goal));
-    if (response.stopReason === "aborted")
-        throw new Error("Handoff generation cancelled");
-    const text = response.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
-    if (!text.trim())
-        throw new Error("Handoff generation returned no text");
-    return text;
-}

package/dist/core/http-dispatcher.d.ts

@@ -1,21 +0,0 @@
-export declare const DEFAULT_HTTP_IDLE_TIMEOUT_MS = 300000;
-export declare const HTTP_IDLE_TIMEOUT_CHOICES: readonly [{
-    readonly label: "30 sec";
-    readonly timeoutMs: 30000;
-}, {
-    readonly label: "1 min";
-    readonly timeoutMs: 60000;
-}, {
-    readonly label: "2 min";
-    readonly timeoutMs: 120000;
-}, {
-    readonly label: "5 min";
-    readonly timeoutMs: 300000;
-}, {
-    readonly label: "disabled";
-    readonly timeoutMs: 0;
-}];
-export declare function parseHttpIdleTimeoutMs(value: unknown): number | undefined;
-export declare function formatHttpIdleTimeoutMs(timeoutMs: number): string;
-export declare function applyHttpProxySettings(httpProxy: string | undefined): void;
-export declare function configureHttpDispatcher(timeoutMs?: number): void;