pi2web 0.2.1 → 0.2.8

package/dist/sdk-backend.js

@@ -1,6 +1,7 @@
 import { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } from '@earendil-works/pi-coding-agent';
 import { EventEmitter } from 'node:events';
 import { randomUUID } from 'node:crypto';
+import { PERFORMANCE_ENTRY, SessionPerformanceTracker } from './session-performance.js';
 import { createCollabExtension } from './collab/pi-extension.js';
 /** Older Pi builds resolved steer()/followUp() with undefined; treat anything but an explicit `handled` as queued. */
 const normalizeDisposition = (value) => value === 'handled' ? 'handled' : 'queued';
@@ -16,12 +17,38 @@ export class SdkBackend {
         this.session = session;
         this.agentId = agentId;
         this.cwd = cwd;
+        const performance = new SessionPerformanceTracker(run => this.session.sessionManager.appendCustomEntry(PERFORMANCE_ENTRY, run));
+        this.session.subscribe(event => performance.apply(event));
     }
-    static async create(agentId, cwd, sessionFile, profile = 'default', collabBridge) {
+    static async create(agentId, cwd, sessionFile, profile = 'default', collabBridge, options = {}) {
         const sessionManager = sessionFile ? SessionManager.open(sessionFile) : SessionManager.create(cwd);
+        const { template, piDefaultPrompt } = options;
         // This factory is deliberately inline instead of auto-discovered: normal Pi and normal pi2web agents
         // never load the collaboration tools or their collaboration-specific system guidance.
-        const resourceLoader = profile === 'collab' && collabBridge ? new DefaultResourceLoader({ cwd, agentDir: getAgentDir(), extensionFactories: [{ name: 'pi2web-collab', factory: createCollabExtension(agentId, collabBridge) }] }) : undefined;
+        const extensionFactories = profile === 'collab' && collabBridge
+            ? [{ name: 'pi2web-collab', factory: createCollabExtension(agentId, collabBridge) }]
+            : [];
+        // A template behaves like Pi's own prompt files: `replace` stands in for SYSTEM.md, `append` follows
+        // APPEND_SYSTEM.md. `piDefaultPrompt` ignores both files to show what Pi itself would send.
+        const systemPromptOverride = piDefaultPrompt
+            ? () => undefined
+            : template?.mode === 'replace'
+                ? () => template.systemPrompt
+                : undefined;
+        const appendSystemPromptOverride = piDefaultPrompt
+            ? () => []
+            : template?.mode === 'append'
+                ? (base) => [...base, template.systemPrompt]
+                : undefined;
+        const resourceLoader = extensionFactories.length || systemPromptOverride || appendSystemPromptOverride
+            ? new DefaultResourceLoader({
+                cwd,
+                agentDir: getAgentDir(),
+                extensionFactories,
+                systemPromptOverride,
+                appendSystemPromptOverride
+            })
+            : undefined;
         if (resourceLoader)
             await resourceLoader.reload();
         const { session, modelFallbackMessage } = await createAgentSession({ cwd, sessionManager, resourceLoader });
@@ -35,29 +62,113 @@ export class SdkBackend {
     }
     // Slash commands, skills and prompt templates are expanded by prompt() itself (expandPromptTemplates defaults to true),
     // so `/name args` typed in the web composer behaves exactly like the Pi TUI.
-    prompt(message) { return this.session.prompt(message); }
+    prompt(message) {
+        return this.session.prompt(message);
+    }
     // Since pi 0.99 steer()/followUp() report whether the message reached the running turn (`handled`)
     // or waits for it (`queued`); the web composer shows that difference instead of guessing.
-    async steer(message) { return normalizeDisposition(await this.session.steer(message)); }
-    async followUp(message) { return normalizeDisposition(await this.session.followUp(message)); }
-    async getQueue() { return { steering: [...this.session.getSteeringMessages()], followUp: [...this.session.getFollowUpMessages()] }; }
+    async steer(message) {
+        return normalizeDisposition(await this.session.steer(message));
+    }
+    async followUp(message) {
+        return normalizeDisposition(await this.session.followUp(message));
+    }
+    async getQueue() {
+        return {
+            steering: [...this.session.getSteeringMessages()],
+            followUp: [...this.session.getFollowUpMessages()]
+        };
+    }
     /** Drop queued steering and follow-up messages and hand them back so a client can restore them to its composer. */
-    async clearQueue() { const cleared = this.session.clearQueue(); return { steering: [...cleared.steering], followUp: [...cleared.followUp] }; }
-    abort() { return this.session.abort(); }
-    async getState() { return { agentId: this.agentId, sessionId: this.session.sessionId, sessionFile: this.session.sessionFile, sessionName: this.session.sessionName, cwd: this.cwd, status: this.disposed ? 'stopped' : this.session.isStreaming ? 'streaming' : 'idle' }; }
-    async getMessages() { return [...this.session.state.messages]; }
+    async clearQueue() {
+        const cleared = this.session.clearQueue();
+        return { steering: [...cleared.steering], followUp: [...cleared.followUp] };
+    }
+    async moveQueue(from, index, expected) {
+        const before = {
+            steering: [...this.session.getSteeringMessages()],
+            followUp: [...this.session.getFollowUpMessages()]
+        };
+        if (!this.session.isStreaming || before[from][index] !== expected)
+            throw Object.assign(new Error('Queued message has changed or already been consumed'), {
+                code: 'QUEUE_CHANGED'
+            });
+        const to = from === 'steering' ? 'followUp' : 'steering';
+        before[from].splice(index, 1);
+        before[to].push(expected);
+        if ([...before.steering, ...before.followUp].some(text => text.startsWith('/')))
+            throw Object.assign(new Error('Slash commands cannot be moved safely'), { code: 'QUEUE_CHANGED' });
+        // Pi exposes clearQueue(), but no per-message move. Clear and requeue in the same JS turn:
+        // steer()/followUp() enqueue synchronously before their promises settle. No model callback can
+        // drain the half-updated queue between these calls. Never replace a stale queue by index alone.
+        this.session.clearQueue();
+        const pending = [
+            ...before.steering.map(text => this.session.steer(text)),
+            ...before.followUp.map(text => this.session.followUp(text))
+        ];
+        await Promise.all(pending);
+        return this.getQueue();
+    }
+    abort() {
+        return this.session.abort();
+    }
+    async getState() {
+        return {
+            agentId: this.agentId,
+            sessionId: this.session.sessionId,
+            sessionFile: this.session.sessionFile,
+            sessionName: this.session.sessionName,
+            cwd: this.cwd,
+            status: this.disposed ? 'stopped' : this.session.isStreaming ? 'streaming' : 'idle'
+        };
+    }
+    timeline() {
+        const manager = this.session.sessionManager;
+        return {
+            sessionId: this.session.sessionId,
+            leafId: manager.getLeafId(),
+            entries: () => manager.getBranch()
+        };
+    }
+    /** The effective system prompt Pi will send next, plus the prompt files that contributed to it. */
+    async getSystemPrompt() {
+        const loader = this.session.resourceLoader;
+        return {
+            systemPrompt: this.session.systemPrompt,
+            systemFile: loader.getSystemPromptSource()?.path,
+            appendFiles: loader.getAppendSystemPromptSources().map(source => source.path),
+            contextFiles: loader.getAgentsFiles().agentsFiles.map(file => file.path)
+        };
+    }
     async getCapabilities() {
         const current = this.session.model;
         // ModelRuntime.getAvailable() is async since 0.80.8 and may consult provider auth; the snapshot keeps
         // an unauthenticated or offline call from blocking the capabilities endpoint.
-        const available = await this.session.modelRuntime.getAvailable().catch(() => this.session.modelRuntime.getAvailableSnapshot());
-        return { model: current ? this.modelInfo(current) : null, models: available.map((model) => this.modelInfo(model)), thinkingLevel: this.session.thinkingLevel, thinkingLevels: this.session.getAvailableThinkingLevels(), supportsThinking: this.session.supportsThinking() };
+        const available = await this.session.modelRuntime
+            .getAvailable()
+            .catch(() => this.session.modelRuntime.getAvailableSnapshot());
+        return {
+            model: current ? this.modelInfo(current) : null,
+            models: available.map((model) => this.modelInfo(model)),
+            thinkingLevel: this.session.thinkingLevel,
+            thinkingLevels: this.session.getAvailableThinkingLevels(),
+            supportsThinking: this.session.supportsThinking()
+        };
     }
     /** Slash commands the composer can offer: file-based prompt templates and skills discovered for this cwd. */
     async listCommands() {
         const loader = this.session.resourceLoader;
-        const prompts = loader.getPrompts().prompts.map(prompt => ({ name: prompt.name, description: prompt.description, argumentHint: prompt.argumentHint, source: 'prompt' }));
-        const skills = loader.getSkills().skills.map(skill => ({ name: `skill:${skill.name}`, description: skill.description, source: 'skill' }));
+        const prompts = loader.getPrompts().prompts.map(prompt => ({
+            name: prompt.name,
+            description: prompt.description,
+            argumentHint: prompt.argumentHint,
+            source: 'prompt'
+        }));
+        const skills = loader.getSkills().skills.map(skill => ({
+            name: `skill:${skill.name}`,
+            description: skill.description,
+            source: 'skill'
+        }));
         return [...prompts, ...skills].sort((a, b) => a.name.localeCompare(b.name));
     }
     /** Run a command inside the Agent session so its output is recorded in the transcript (`!!` keeps it out of the model context). */
@@ -70,36 +181,100 @@ export class SdkBackend {
             return { id, ...result };
         }
         catch (error) {
-            this.events.emit('event', { type: 'bash_execution_end', id, command, isError: true, errorMessage: error instanceof Error ? error.message : String(error) });
+            this.events.emit('event', {
+                type: 'bash_execution_end',
+                id,
+                command,
+                isError: true,
+                errorMessage: error instanceof Error ? error.message : String(error)
+            });
             throw error;
         }
     }
-    abortBash() { this.session.abortBash(); }
-    async getSession() { return { ...await this.getSessionInfo(), leafId: this.session.sessionManager.getLeafId(), entries: this.session.sessionManager.getEntries(), tree: this.session.sessionManager.getTree(), userMessages: this.session.getUserMessagesForForking() }; }
-    async getSessionInfo() { return { sessionId: this.session.sessionId, sessionFile: this.session.sessionFile, sessionName: this.session.sessionName, stats: this.session.getSessionStats(), contextUsage: this.session.getContextUsage() }; }
-    compact(instructions) { return this.session.compact(instructions); }
-    async setModel(provider, modelId) { const model = this.session.modelRuntime.getModel(provider, modelId); if (!model)
-        throw Object.assign(new Error('Model not found'), { code: 'MODEL_NOT_FOUND' }); await this.session.setModel(model); }
-    async setThinkingLevel(level) { if (level !== 'off' && !this.session.getAvailableThinkingLevels().includes(level))
-        throw Object.assign(new Error('Invalid thinking level'), { code: 'INVALID_THINKING_LEVEL' }); this.session.setThinkingLevel(level); }
-    async setSessionName(name) { const value = name.trim(); if (!value || value.length > 200)
-        throw Object.assign(new Error('Session name must be 1-200 characters'), { code: 'INVALID_SESSION_NAME' }); this.session.setSessionName(value); }
-    navigate(entryId) { return this.session.navigateTree(entryId); }
-    async fork(entryId) { const entry = this.session.sessionManager.getEntry(entryId); if (!entry || entry.type !== 'message' || entry.message?.role !== 'user')
-        throw Object.assign(new Error('A user message entry is required'), { code: 'SESSION_ENTRY_NOT_FOUND' }); const content = entry.message.content; const selectedText = typeof content === 'string' ? content : Array.isArray(content) ? content.filter((part) => part.type === 'text').map((part) => part.text).join('\n') : ''; let sessionFile; if (entry.parentId) {
-        sessionFile = this.session.sessionManager.createBranchedSession(entry.parentId);
-    }
-    else {
-        const current = this.session.sessionFile;
-        if (!current)
-            throw Object.assign(new Error('Session persistence is disabled'), { code: 'SESSION_NOT_PERSISTED' });
-        sessionFile = SessionManager.create(this.cwd, this.session.sessionManager.getSessionDir(), { parentSession: current }).getSessionFile();
-    } return { sessionFile, selectedText }; }
+    abortBash() {
+        this.session.abortBash();
+    }
+    async getSession() {
+        return {
+            ...(await this.getSessionInfo()),
+            leafId: this.session.sessionManager.getLeafId(),
+            entries: this.session.sessionManager.getEntries(),
+            tree: this.session.sessionManager.getTree(),
+            userMessages: this.session.getUserMessagesForForking()
+        };
+    }
+    async getSessionInfo() {
+        return {
+            sessionId: this.session.sessionId,
+            sessionFile: this.session.sessionFile,
+            sessionName: this.session.sessionName,
+            stats: this.session.getSessionStats(),
+            contextUsage: this.session.getContextUsage()
+        };
+    }
+    compact(instructions) {
+        return this.session.compact(instructions);
+    }
+    async setModel(provider, modelId) {
+        const model = this.session.modelRuntime.getModel(provider, modelId);
+        if (!model)
+            throw Object.assign(new Error('Model not found'), { code: 'MODEL_NOT_FOUND' });
+        await this.session.setModel(model);
+    }
+    async setThinkingLevel(level) {
+        if (level !== 'off' && !this.session.getAvailableThinkingLevels().includes(level))
+            throw Object.assign(new Error('Invalid thinking level'), { code: 'INVALID_THINKING_LEVEL' });
+        this.session.setThinkingLevel(level);
+    }
+    async setSessionName(name) {
+        const value = name.trim();
+        if (!value || value.length > 200)
+            throw Object.assign(new Error('Session name must be 1-200 characters'), { code: 'INVALID_SESSION_NAME' });
+        this.session.setSessionName(value);
+    }
+    navigate(entryId) {
+        return this.session.navigateTree(entryId);
+    }
+    async fork(entryId) {
+        const entry = this.session.sessionManager.getEntry(entryId);
+        if (!entry || entry.type !== 'message' || entry.message?.role !== 'user')
+            throw Object.assign(new Error('A user message entry is required'), { code: 'SESSION_ENTRY_NOT_FOUND' });
+        const content = entry.message.content;
+        const selectedText = typeof content === 'string'
+            ? content
+            : Array.isArray(content)
+                ? content
+                    .filter((part) => part.type === 'text')
+                    .map((part) => part.text)
+                    .join('\n')
+                : '';
+        let sessionFile;
+        if (entry.parentId) {
+            sessionFile = this.session.sessionManager.createBranchedSession(entry.parentId);
+        }
+        else {
+            const current = this.session.sessionFile;
+            if (!current)
+                throw Object.assign(new Error('Session persistence is disabled'), { code: 'SESSION_NOT_PERSISTED' });
+            sessionFile = SessionManager.create(this.cwd, this.session.sessionManager.getSessionDir(), {
+                parentSession: current
+            }).getSessionFile();
+        }
+        return { sessionFile, selectedText };
+    }
     async extensionResponse(requestId, value) {
         if (!this.resolveUiRequest(requestId, value))
             throw Object.assign(new Error('Extension UI request not found'), { code: 'EXTENSION_REQUEST_NOT_FOUND' });
     }
-    subscribe(listener) { const fromSession = (event) => listener(event); const unsubscribe = this.session.subscribe(fromSession); this.events.on('event', listener); return () => { unsubscribe(); this.events.off('event', listener); }; }
+    subscribe(listener) {
+        const fromSession = (event) => listener(event);
+        const unsubscribe = this.session.subscribe(fromSession);
+        this.events.on('event', listener);
+        return () => {
+            unsubscribe();
+            this.events.off('event', listener);
+        };
+    }
     async dispose() {
         if (this.disposed)
             return;
@@ -109,7 +284,16 @@ export class SdkBackend {
         this.session.dispose();
         this.disposed = true;
     }
-    modelInfo(model) { return { provider: model.provider, id: model.id, name: model.name, reasoning: !!model.reasoning, contextWindow: model.contextWindow, maxTokens: model.maxTokens }; }
+    modelInfo(model) {
+        return {
+            provider: model.provider,
+            id: model.id,
+            name: model.name,
+            reasoning: !!model.reasoning,
+            contextWindow: model.contextWindow,
+            maxTokens: model.maxTokens
+        };
+    }
     resolveUiRequest(requestId, value) {
         const pending = this.pendingUi.get(requestId);
         if (!pending)
@@ -132,17 +316,37 @@ export class SdkBackend {
     }
     extensionUi() {
         return {
-            select: async (title, options, opts) => await this.request('select', { title, options, opts }),
+            select: async (title, options, opts) => (await this.request('select', { title, options, opts })),
             confirm: async (title, message, opts) => Boolean(await this.request('confirm', { title, message, opts })),
-            input: async (title, placeholder, opts) => await this.request('input', { title, placeholder, opts }),
-            editor: async (title, prefill) => await this.request('editor', { title, prefill }),
+            input: async (title, placeholder, opts) => (await this.request('input', { title, placeholder, opts })),
+            editor: async (title, prefill) => (await this.request('editor', { title, prefill })),
             notify: (message, type) => this.events.emit('event', { type: 'extension_ui_notify', message, notificationType: type ?? 'info' }),
             setStatus: (key, text) => this.events.emit('event', { type: 'extension_ui_status', key, text }),
-            setWidget: (key, content, options) => this.events.emit('event', { type: 'extension_ui_widget', key, content: Array.isArray(content) ? content : undefined, options }),
+            setWidget: (key, content, options) => this.events.emit('event', {
+                type: 'extension_ui_widget',
+                key,
+                content: Array.isArray(content) ? content : undefined,
+                options
+            }),
             setTitle: (title) => this.events.emit('event', { type: 'extension_ui_title', title }),
-            setWorkingMessage: (message) => this.events.emit('event', { type: 'extension_ui_working_message', message }), setWorkingVisible: () => { }, setWorkingIndicator: () => { }, setHiddenThinkingLabel: () => { },
-            onTerminalInput: () => () => { }, setFooter: () => { }, setHeader: () => { }, pasteToEditor: () => { }, setEditorText: () => { }, getEditorText: () => '', addAutocompleteProvider: () => { }, setEditorComponent: () => { }, custom: async () => { throw Object.assign(new Error('Custom extension components are unsupported'), { code: 'EXTENSION_CUSTOM_UI_UNSUPPORTED' }); }
+            setWorkingMessage: (message) => this.events.emit('event', { type: 'extension_ui_working_message', message }),
+            setWorkingVisible: () => { },
+            setWorkingIndicator: () => { },
+            setHiddenThinkingLabel: () => { },
+            onTerminalInput: () => () => { },
+            setFooter: () => { },
+            setHeader: () => { },
+            pasteToEditor: () => { },
+            setEditorText: () => { },
+            getEditorText: () => '',
+            addAutocompleteProvider: () => { },
+            setEditorComponent: () => { },
+            custom: async () => {
+                throw Object.assign(new Error('Custom extension components are unsupported'), {
+                    code: 'EXTENSION_CUSTOM_UI_UNSUPPORTED'
+                });
+            }
         };
     }
 }
-export const createSdkBackend = (agentId, cwd, sessionFile, profile = 'default', collabBridge) => SdkBackend.create(agentId, cwd, sessionFile, profile, collabBridge);
+export const createSdkBackend = (agentId, cwd, sessionFile, profile = 'default', collabBridge, options = {}) => SdkBackend.create(agentId, cwd, sessionFile, profile, collabBridge, options);