@pi-chamber/web 0.2.2 → 0.3.1

package/server/lib/pi/session-daemon/session-daemon.js

@@ -18,6 +18,7 @@ import {
 
 import { createPiModelConfigStore } from '../model-config-store.js';
 import { clampThinkingLevel, getSupportedThinkingLevels, isPiThinkingLevel } from '../thinking-levels.js';
+import { createMessageEntryAliases } from './message-entry-aliases.js';
 import { createSessionRuntimeRegistry } from './runtime-registry.js';
 import {
   findPiSessionJsonlById,
@@ -136,9 +137,11 @@ export function createSessionDaemon({
   const messageStartedAt = new Map();
   const toolStartedAt = new Map();
   const latestUserMessageIds = new Map();
+  const retryStateBySession = new Map();
   const sendGenerationBySession = new Map();
   const streamingRedactionBuffers = new Map();
   const loginAttempts = new Map();
+  const messageEntryAliases = createMessageEntryAliases();
   const MAX_REPLAY_EVENTS = 1_024;
 
   const validateDirectoryPath = async (dir) => {
@@ -238,6 +241,7 @@ export function createSessionDaemon({
       : getSessionState();
     if (requestedSessionId && requestedSessionId !== session.sessionId) return;
     const activeSession = targetRuntime?.session || runtime?.session;
+    const retry = session.sessionId ? retryStateBySession.get(session.sessionId) : undefined;
     const targetDirectory = targetRuntime?.cwd || activeDirectory || cwd;
     const messages = activeSession ? projectMessageEntries(activeSession, targetDirectory) : [];
     const lastAssistant = [...messages].reverse().find((entry) => entry.message.role === 'assistant')?.message;
@@ -252,7 +256,8 @@ export function createSessionDaemon({
         ...(session.sessionId ? { sessionId: session.sessionId } : {}),
         directory: targetDirectory,
         isStreaming: session.isStreaming ?? false,
-        lifecycle: session.isStreaming ? 'busy' : 'idle',
+        lifecycle: retry ? 'retry' : session.isStreaming ? 'busy' : 'idle',
+        ...(retry ? { retry } : {}),
         queue: activeSession ? {
           steering: activeSession.getSteeringMessages?.().length ?? 0,
           followUp: activeSession.getFollowUpMessages?.().length ?? 0,
@@ -631,7 +636,11 @@ export function createSessionDaemon({
   };
 
   const projectMessageEntries = (session, targetDir = activeDirectory || cwd) => {
-    const persisted = session?.sessionManager?.getEntries?.();
+    // Use the active branch, not the full file. `getEntries()` returns every
+    // entry ever written, so a bare `branch()`/`resetLeaf()` would appear to
+    // do nothing. `getBranch()` follows the current leaf and is what
+    // `navigateTree` and `buildSessionContext` use for the model context.
+    const persisted = session?.sessionManager?.getBranch?.() ?? session?.sessionManager?.getEntries?.();
     const entries = liveProjectionEntries(session, Array.isArray(persisted) ? persisted : []);
     if (entries.length === 0) return [];
     const streaming = session?.isStreaming === true;
@@ -723,6 +732,7 @@ export function createSessionDaemon({
       ?? (model?.provider && model?.id ? { providerId: model.provider, modelId: model.id } : undefined);
     const sessionThinking = lastAssistant?.thinkingLevel || session.thinkingLevel;
     const isStreaming = session.isStreaming === true;
+    const retry = retryStateBySession.get(session.sessionId);
     return {
       session: {
         id: session.sessionId, directory: targetDir, createdAt, updatedAt: createdAt,
@@ -734,7 +744,8 @@ export function createSessionDaemon({
       messages,
       lastSequence: sequence,
       isStreaming,
-      lifecycle: isStreaming ? 'busy' : 'idle',
+      lifecycle: retry ? 'retry' : isStreaming ? 'busy' : 'idle',
+      ...(retry ? { retry } : {}),
     };
   };
 
@@ -820,6 +831,84 @@ export function createSessionDaemon({
     return { providers: [...providers.values()] };
   };
 
+  let refreshProvidersInflight = null;
+  const refreshProviders = async (requestedDirectory) => {
+    if (refreshProvidersInflight) return refreshProvidersInflight;
+    const task = (async () => {
+      const signal = typeof AbortSignal.timeout === 'function' ? AbortSignal.timeout(15_000) : undefined;
+      const runtimes = new Set();
+      for (const services of servicesCache.values()) {
+        const mr = services?.modelRuntime;
+        if (mr) runtimes.add(mr);
+      }
+      if (runtime?.session?.modelRuntime) runtimes.add(runtime.session.modelRuntime);
+      if (runtime?.services?.modelRuntime) runtimes.add(runtime.services.modelRuntime);
+      if (runtimeRegistry?.listAll) {
+        try {
+          for (const tracked of runtimeRegistry.listAll()) {
+            const mr = tracked?.session?.modelRuntime ?? tracked?.services?.modelRuntime;
+            if (mr) runtimes.add(mr);
+          }
+        } catch {}
+      }
+      if (runtimes.size === 0) {
+        const active = await ensureRuntime(requestedDirectory ? await resolveDirectory(requestedDirectory) : undefined);
+        const mr = active?.session?.modelRuntime ?? active?.services?.modelRuntime;
+        if (mr) runtimes.add(mr);
+      }
+      const dummyMap = new Map();
+      for (const mr of runtimes) {
+        try {
+          const providers = typeof mr.getProviders === 'function' ? mr.getProviders() : [];
+          for (const provider of providers) {
+            const auth = mr.getProviderAuthStatus?.(provider.id);
+            if (auth?.configured === true) continue;
+            try {
+              await mr.setRuntimeApiKey(provider.id, 'pichamber-catalog-refresh');
+              let list = dummyMap.get(mr);
+              if (!list) { list = []; dummyMap.set(mr, list); }
+              list.push(provider.id);
+            } catch {}
+          }
+        } catch {}
+      }
+      const errors = new Map();
+      let aborted = false;
+      try {
+        await Promise.all([...runtimes].map(async (mr) => {
+          try {
+            const result = await mr.refresh({ allowNetwork: true, force: true, ...(signal ? { signal } : {}) });
+            if (result?.aborted) aborted = true;
+            if (result?.errors) {
+              for (const [providerId, err] of result.errors) errors.set(providerId, err);
+            }
+          } catch (error) {
+            if (error?.code === 'PI_MODEL_CONFIG_INVALID') throw error;
+            errors.set('_global', error);
+          }
+        }));
+      } finally {
+        for (const [mr, ids] of dummyMap.entries()) {
+          for (const id of ids) {
+            try { await mr.removeRuntimeApiKey(id); } catch {}
+          }
+        }
+      }
+      if (errors.has('_global') && runtimes.size > 0) {
+        const globalError = errors.get('_global');
+        if (globalError?.code === 'PI_MODEL_CONFIG_INVALID') {
+          throw new SessionDaemonProtocolError('PI_MODEL_CONFIG_INVALID', 'Pi models configuration is invalid.');
+        }
+      }
+      const catalog = await listProviders(requestedDirectory);
+      return catalog;
+    })().finally(() => {
+      refreshProvidersInflight = null;
+    });
+    refreshProvidersInflight = task;
+    return task;
+  };
+
   const getProviderConfiguration = async (providerId) => {
     if (typeof providerId !== 'string' || providerId.length === 0 || providerId.length > 256) {
       throw new SessionDaemonProtocolError('INVALID_ARGUMENT', 'The requested provider is invalid.');
@@ -1101,9 +1190,21 @@ export function createSessionDaemon({
     if (!loader || typeof loader.getSkills !== 'function' || typeof loader.getPrompts !== 'function' || typeof loader.getAgentsFiles !== 'function') {
       throw new SessionDaemonProtocolError('DAEMON_REQUEST_FAILED', 'Pi resource discovery is unavailable.');
     }
-    const skills = loader.getSkills().skills.map((skill) => ({
-      id: resourceId('skill', skill.filePath),
-      kind: 'skill', name: skill.name, ...(skill.description ? { description: skill.description } : {}), location: resourceLocation(skill.sourceInfo), editable: false,
+    const skills = await Promise.all(loader.getSkills().skills.map(async (skill) => {
+      let content = '';
+      try {
+        content = await readFile(skill.filePath, 'utf8');
+      } catch {}
+      return {
+        id: resourceId('skill', skill.filePath),
+        kind: 'skill',
+        name: skill.name,
+        ...(skill.description ? { description: skill.description } : {}),
+        location: resourceLocation(skill.sourceInfo),
+        editable: false,
+        ...(content ? { content } : {}),
+        filePath: skill.filePath,
+      };
     }));
     const prompts = loader.getPrompts().prompts.map((prompt) => ({
       id: resourceId('prompt', prompt.filePath),
@@ -1508,6 +1609,10 @@ export function createSessionDaemon({
       targetDir = directory;
       await rm(target.path, { force: false });
     }
+    messageEntryAliases.clearSession({ cwd: active?.cwd || targetDir, sessionId });
+    retryStateBySession.delete(sessionId);
+    latestUserMessageIds.delete(sessionId);
+    latestAssistantMessageIds.delete(sessionId);
     publish('session.lifecycle', { state: 'idle', deleted: true }, sessionId, targetDir);
   };
 
@@ -1522,6 +1627,7 @@ export function createSessionDaemon({
               ? content.filter((part) => part?.type === 'text').map((part) => part.text).join('')
               : '');
           const messageId = `user-${sessionId}-${sequence + 1}`;
+          messageEntryAliases.retain({ cwd: directory, sessionId, syntheticMessageId: messageId, message: event.message });
           latestUserMessageIds.set(sessionId, messageId);
           publish('assistant.message.start', {
             messageId,
@@ -1531,6 +1637,7 @@ export function createSessionDaemon({
           }, sessionId, directory);
         } else if (event.message?.role === 'assistant') {
           const messageId = `assistant-${sessionId}-${sequence + 1}`;
+          messageEntryAliases.retain({ cwd: directory, sessionId, syntheticMessageId: messageId, message: event.message });
           clearStreamingRedactionBuffers(sessionId);
           streamingMessageIds.set(sessionId, messageId);
           latestAssistantMessageIds.set(sessionId, messageId);
@@ -1559,6 +1666,19 @@ export function createSessionDaemon({
         break;
       }
       case 'message_end': {
+        const eventRuntime = runtimeRegistry?.get({ cwd: directory, sessionId });
+        const syntheticMessageId = event.message?.role === 'assistant'
+          ? streamingMessageIds.get(sessionId) ?? latestAssistantMessageIds.get(sessionId)
+          : event.message?.role === 'user'
+            ? latestUserMessageIds.get(sessionId)
+            : undefined;
+        messageEntryAliases.observeMessageEnd({
+          cwd: directory,
+          sessionId,
+          syntheticMessageId,
+          message: event.message,
+          sessionManager: eventRuntime?.session?.sessionManager,
+        });
         if (event.message?.role === 'assistant') {
           const content = Array.isArray(event.message.content) ? event.message.content : [];
           const messageId = streamingMessageIds.get(sessionId) ?? latestAssistantMessageIds.get(sessionId) ?? `assistant-${sessionId}`;
@@ -1571,6 +1691,7 @@ export function createSessionDaemon({
             text: redactAttachmentPaths(content.filter((part) => part?.type === 'text').map((part) => part.text).join('')),
             thinking: redactAttachmentPaths(content.filter((part) => part?.type === 'thinking').map((part) => part.thinking).join('')),
             durationMs,
+            ...(content.some((part) => part?.type === 'toolCall') ? { continuing: true } : {}),
             ...(event.message.errorMessage ? { error: { code: 'ASSISTANT_ERROR', message: redactAttachmentPaths(event.message.errorMessage) } } : {}),
             ...(usage ? { usage } : {}),
           }, sessionId, directory);
@@ -1634,20 +1755,35 @@ export function createSessionDaemon({
         break;
       case 'agent_start':
         clearIdleDisposal(sessionId);
+        retryStateBySession.delete(sessionId);
         publish('session.lifecycle', { state: 'busy' }, sessionId, directory);
         break;
       case 'agent_end': {
-        latestUserMessageIds.delete(sessionId);
-        latestAssistantMessageIds.delete(sessionId);
         const finalMessage = event.messages?.at?.(-1);
         if (finalMessage?.role === 'assistant' && finalMessage.stopReason === 'aborted') {
           publish('session.interrupted', { reason: 'user-abort', streaming: false }, sessionId, directory);
-        } else if (finalMessage?.role === 'assistant' && typeof finalMessage.errorMessage === 'string') {
+        } else if (finalMessage?.role === 'assistant' && typeof finalMessage.errorMessage === 'string' && event.willRetry !== true) {
           publish('session.error', { code: 'ASSISTANT_ERROR', message: redactAttachmentPaths(finalMessage.errorMessage) }, sessionId, directory);
         }
         break;
       }
+      case 'auto_retry_start': {
+        const retry = {
+          attempt: event.attempt,
+          next: Date.now() + event.delayMs,
+          message: redactAttachmentPaths(event.errorMessage),
+        };
+        retryStateBySession.set(sessionId, retry);
+        publish('session.lifecycle', { state: 'retry', ...retry }, sessionId, directory);
+        break;
+      }
+      case 'auto_retry_end':
+        retryStateBySession.delete(sessionId);
+        break;
       case 'agent_settled':
+        retryStateBySession.delete(sessionId);
+        latestUserMessageIds.delete(sessionId);
+        latestAssistantMessageIds.delete(sessionId);
         publish('session.lifecycle', { state: 'idle' }, sessionId, directory);
         scheduleIdleDisposal(sessionId);
         break;
@@ -1684,7 +1820,7 @@ export function createSessionDaemon({
               'projects.list', 'projects.select', 'sessions.list', 'sessions.create', 'sessions.open', 'sessions.rename', 'sessions.delete',
               'sessions.tree', 'sessions.navigate', 'sessions.fork', 'sessions.clone', 'sessions.prompt',
               'sessions.steer', 'sessions.followUp', 'sessions.abort', 'sessions.setModel',
-              'sessions.setThinking', 'sessions.compact', 'providers.list', 'providers.config.get', 'providers.models.set', 'providers.status', 'providers.login',
+              'sessions.setThinking', 'sessions.compact', 'providers.list', 'providers.refresh', 'providers.config.get', 'providers.models.set', 'providers.status', 'providers.login',
               'providers.login.respond', 'providers.login.status', 'providers.logout', 'settings.get', 'settings.set',
               'resources.list', 'resources.update', 'resources.prompts.create', 'resources.prompts.delete',
             ],
@@ -1716,6 +1852,11 @@ export function createSessionDaemon({
         writeFrame(socket, { protocolVersion: PROTOCOL_VERSION, kind: 'response', requestId: message.requestId, result });
         return;
       }
+      case 'providers.refresh': {
+        const result = await refreshProviders(message.payload?.directory);
+        writeFrame(socket, { protocolVersion: PROTOCOL_VERSION, kind: 'response', requestId: message.requestId, result });
+        return;
+      }
       case 'providers.config.get': {
         const result = await getProviderConfiguration(message.payload?.providerId);
         writeFrame(socket, { protocolVersion: PROTOCOL_VERSION, kind: 'response', requestId: message.requestId, result });
@@ -1817,18 +1958,40 @@ export function createSessionDaemon({
       }
       case 'sessions.navigate': {
         const activeRuntime = await activateSession(message.payload?.sessionId, message.payload?.directory || message.payload?.cwd);
-        const messageId = message.payload?.messageId;
-        if (typeof messageId !== 'string' || messageId.length === 0) throw new SessionDaemonProtocolError('INVALID_ARGUMENT', 'The requested tree entry is invalid.');
+        const requestedId = message.payload?.messageId;
+        if (typeof requestedId !== 'string' || requestedId.length === 0) throw new SessionDaemonProtocolError('INVALID_ARGUMENT', 'The requested tree entry is invalid.');
+        const messageId = messageEntryAliases.resolve({
+          cwd: activeRuntime.cwd,
+          sessionId: message.payload.sessionId,
+          requestedId,
+          sessionManager: activeRuntime.session.sessionManager,
+        });
+        const previousLeafId = activeRuntime.session.sessionManager?.getLeafId?.() ?? null;
         const result = await activeRuntime.session.navigateTree(messageId);
-        if (result.cancelled) throw new SessionDaemonProtocolError('SESSION_TREE_NOT_FOUND', 'Pi cancelled tree navigation.');
-        writeFrame(socket, { protocolVersion: PROTOCOL_VERSION, kind: 'response', requestId: message.requestId, result: projectActiveSession(activeRuntime, activeRuntime.cwd) });
+        if (result?.cancelled) throw new SessionDaemonProtocolError('SESSION_TREE_NOT_FOUND', 'Pi cancelled tree navigation.');
+        const newLeafId = activeRuntime.session.sessionManager?.getLeafId?.() ?? null;
+        const navigation = {
+          targetEntryId: messageId,
+          previousLeafId: typeof previousLeafId === 'string' ? previousLeafId : null,
+          newLeafId: typeof newLeafId === 'string' ? newLeafId : null,
+          ...(typeof result?.editorText === 'string' && result.editorText.length > 0 ? { editorText: result.editorText } : {}),
+        };
+        writeFrame(socket, { protocolVersion: PROTOCOL_VERSION, kind: 'response', requestId: message.requestId, result: { ...projectActiveSession(activeRuntime, activeRuntime.cwd), navigation } });
         return;
       }
       case 'sessions.fork':
       case 'sessions.clone': {
         const activeRuntime = await activateSession(message.payload?.sessionId, message.payload?.directory || message.payload?.cwd);
-        const entryId = message.command === 'sessions.fork' ? message.payload?.messageId : activeRuntime.session.sessionManager?.getLeafId?.();
-        if (typeof entryId !== 'string' || entryId.length === 0) throw new SessionDaemonProtocolError('SESSION_TREE_NOT_FOUND', 'The Pi session has no fork point.');
+        const requestedId = message.command === 'sessions.fork' ? message.payload?.messageId : activeRuntime.session.sessionManager?.getLeafId?.();
+        if (typeof requestedId !== 'string' || requestedId.length === 0) throw new SessionDaemonProtocolError('SESSION_TREE_NOT_FOUND', 'The Pi session has no fork point.');
+        const entryId = message.command === 'sessions.fork'
+          ? messageEntryAliases.resolve({
+            cwd: activeRuntime.cwd,
+            sessionId: message.payload.sessionId,
+            requestedId,
+            sessionManager: activeRuntime.session.sessionManager,
+          })
+          : requestedId;
         const result = await activeRuntime.fork(entryId, { position: 'at' });
         if (result.cancelled) throw new SessionDaemonProtocolError('SESSION_CREATE_CANCELLED', 'Pi cancelled session creation.');
         rememberRuntimeSession();
@@ -1996,6 +2159,7 @@ export function createSessionDaemon({
         if (platform !== 'win32') await chmod(endpoint, 0o600);
         started = true;
       } catch (error) {
+        messageEntryAliases.clear();
         await disposeRuntime();
         server = undefined;
         throw error;
@@ -2009,8 +2173,12 @@ export function createSessionDaemon({
         clearTimeout(attempt.expiry);
       }
       loginAttempts.clear();
+      retryStateBySession.clear();
+      latestUserMessageIds.clear();
+      latestAssistantMessageIds.clear();
       for (const client of clients) client.destroy();
       clients.clear();
+      messageEntryAliases.clear();
       await new Promise((resolve, reject) => {
         server.close((error) => error ? reject(error) : resolve());
       });