actoviq-agent-sdk 0.4.21 → 0.4.22

package/dist/src/gui/hadamardGui.js

@@ -76,6 +76,10 @@ import { SqliteDurableChildStore } from '../node/sqliteDurableChildStore.js';
 import { SqliteStorageV2 } from '../storage-v2/sqliteStorage.js';
 import { emptyUsage, } from '../core/index.js';
 import { estimateCost } from '../team/pricing.js';
+import { SessionCostTracker } from '../extensions/sessionCostTracker.js';
+import { formatUsageBar, usageBarColorLevel } from '../extensions/usageBar.js';
+import { formatTaskSettledNotification } from '../extensions/taskNotifications.js';
+import { BUILT_IN_EXTENSIONS, resolveBuiltInExtensionStates, } from '../extensions/builtInExtensions.js';
 import { validateWorkflowSquad, } from '../team/workflowSquad.js';
 import { listPlanFiles, planDirFor, planFilePath, readPlanFile } from '../tools/planMode/PlanModeTools.js';
 import { isReadOnlyBashCommand } from '../runtime/bashClassification.js';
@@ -96,6 +100,8 @@ import { createUnsupportedAppUpdateController, } from '../update/appUpdateServic
 import { discoverHadamardPlugins } from '../tui/pluginCatalog.js';
 import { HADAMARD_GUI_INTERACTIVE_COMMANDS, interactiveCommandUsage, parseTeamAskArguments, } from '../ui/commandSurface.js';
 import { createAgentExecutionProjectView, createAgentExecutionRootView, } from '../ui/agentExecutionView.js';
+import { runExtensionsCommandView } from '../ui/extensionsCommandView.js';
+import { runLspCommandView } from '../ui/lspCommandView.js';
 import { createExternalCliAgentExecutionSnapshots } from './externalCliAgentMonitor.js';
 import { ContextRailReminderScheduler, normalizeContextRailStore, readContextRailStore, sortContextRailItems, writeContextRailStore, } from './contextRailStore.js';
 import { readWorkspaceNote, writeWorkspaceNote } from './workspaceNote.js';
@@ -116,6 +122,7 @@ import { registerGuiShellHttpController } from './guiShellHttpController.js';
 import { registerGuiChatHttpController } from './guiChatHttpController.js';
 import { rejectMismatchedGuiSession } from './guiSessionHttpGuard.js';
 import { registerGuiSettingsHttpController } from './guiSettingsHttpController.js';
+import { appendGuiLedgerUsage, createGuiUsageRoutingRuntime, runGuiUsageRoutingCommand } from './guiUsageRoutingRuntime.js';
 import { registerGuiTeamHttpController } from './guiTeamHttpController.js';
 import { registerGuiAgentHttpController } from './guiAgentHttpController.js';
 import { registerGuiReferenceHttpController } from './guiReferenceHttpController.js';
@@ -1760,6 +1767,24 @@ export async function startHadamardGuiServer(options = {}) {
         await railReminderScheduler.sync(targetWorkDir, homeDir, store);
     }
     await syncRailReminders().catch(() => undefined);
+    // notifications extension: push background-task settlements into the rail
+    // notification channel (drained into /api/state and /api/rail-live).
+    // Enablement is checked at fire time so toggling applies immediately.
+    let unsubscribeTaskNotifications = null;
+    function subscribeSdkTaskNotifications() {
+        unsubscribeTaskNotifications?.();
+        unsubscribeTaskNotifications = sdk?.onBackgroundTaskSettled(task => {
+            if (!sdk?.builtInExtensions.isEnabled('notifications'))
+                return;
+            const notification = formatTaskSettledNotification(task);
+            railReminderScheduler.enqueueNotification({
+                title: notification.title,
+                text: notification.body || notification.title,
+                kind: 'task',
+            });
+        }) ?? null;
+    }
+    subscribeSdkTaskNotifications();
     const pendingPermissions = new Map();
     // Terminal engine (plan phase 3). node-pty is probed once; terminalCapable
     // tells the renderer whether to show the terminal tab (false hides it even when
@@ -1785,6 +1810,7 @@ export async function startHadamardGuiServer(options = {}) {
     // to reference the same model.
     let activeAgentSelectionName = null;
     let activeBridgeModelApi = null;
+    let activeKeywayRouteAlias = null;
     let bridgeModelLabel = null;
     const externalCliRuntimeManager = options.externalCliRuntimeManager
         ?? new ExternalCliRuntimeManager();
@@ -1903,14 +1929,22 @@ export async function startHadamardGuiServer(options = {}) {
     let totalInputTokens = 0;
     let totalOutputTokens = 0;
     let totalCostUsd = 0;
+    // costTracker extension: per-model accumulation + durable JSONL ledger
+    // (mirrors the TUI). Token totals always count; cost + ledger are gated.
+    const costTracker = new SessionCostTracker(resolveGuiHomeDir());
+    // usageBar extension: live context estimate from the last request.started.
+    let lastContextTokenEstimate;
     const configUsage = new Map();
-    function recordUsage(model, usage) {
+    function recordUsage(model, usage, runId) {
         const inT = usage?.input_tokens ?? 0;
         const outT = usage?.output_tokens ?? 0;
         totalInputTokens += inT;
         totalOutputTokens += outT;
-        const cost = estimateCost(model, inT, outT, resolveGuiHomeDir());
-        totalCostUsd = cost === null ? null : (totalCostUsd === null ? cost : totalCostUsd + cost);
+        if (sdk?.builtInExtensions.isEnabled('costTracker')) {
+            costTracker.record(model, usage ?? {}, { sessionId: session?.id, runId, configurationId: activeBridgeConfig?.name, source: bridgeMode ? 'bridge' : 'hadamard' });
+            const cost = estimateCost(model, inT, outT, resolveGuiHomeDir());
+            totalCostUsd = cost === null ? null : (totalCostUsd === null ? cost : totalCostUsd + cost);
+        }
         if (bridgeMode && activeBridgeConfig) {
             const rec = configUsage.get(activeBridgeConfig.name) ?? { inputTokens: 0, outputTokens: 0, turns: 0 };
             rec.inputTokens += inT;
@@ -1926,6 +1960,32 @@ export async function startHadamardGuiServer(options = {}) {
         const cost = estimateCost(cfg.model, rec.inputTokens, rec.outputTokens, resolveGuiHomeDir());
         return cost !== null ? `$${cost.toFixed(4)}` : null;
     }
+    // usageBar extension: pre-formatted statusbar widget (renderer just paints it).
+    function usageBarState() {
+        if (!sdk?.builtInExtensions.isEnabled('usageBar'))
+            return {};
+        const contextWindowTokens = currentContextWindow()
+            ?? sdk.config.compact.contextWindowTokens
+            ?? 200_000;
+        const contextUsedTokens = lastContextTokenEstimate ?? 0;
+        const pct = contextWindowTokens > 0
+            ? Math.min(100, Math.round((contextUsedTokens / contextWindowTokens) * 100))
+            : 0;
+        return {
+            usageBarText: formatUsageBar({
+                contextUsedTokens,
+                contextWindowTokens,
+                ...(sdk.builtInExtensions.isEnabled('costTracker') && totalCostUsd !== null
+                    ? { sessionCostUsd: totalCostUsd }
+                    : {}),
+                inputTokens: totalInputTokens,
+                outputTokens: totalOutputTokens,
+            }),
+            usageBarLevel: usageBarColorLevel(pct),
+            contextUsedTokens,
+            contextWindowTokens,
+        };
+    }
     let heavyStateCache = null;
     const invalidateHeavyState = () => {
         heavyStateCache = null;
@@ -1937,15 +1997,28 @@ export async function startHadamardGuiServer(options = {}) {
         try {
             // When recovering from a no-credential state the session is a stub (id: ''),
             // so create a fresh session instead of trying to resume an empty id.
-            session = needsCredentials
-                ? await nextSdk.createSession({ model: options.model, permissionMode })
-                : await nextSdk.resumeSession(session.id, {
-                    model: options.model,
-                    permissionMode: options.permissionMode,
-                });
+            if (needsCredentials) {
+                session = await nextSdk.createSession({ model: options.model, permissionMode });
+            }
+            else {
+                try {
+                    session = await nextSdk.resumeSession(session.id, {
+                        model: options.model,
+                        permissionMode: options.permissionMode,
+                    });
+                }
+                catch (error) {
+                    if (error?.code !== 'SESSION_NOT_FOUND')
+                        throw error;
+                    // Empty sessions are intentionally not persisted. A settings reload
+                    // must still apply immediately while the untouched chat is open.
+                    session = await nextSdk.createSession({ model: options.model, permissionMode });
+                }
+            }
             toolMetadata = await nextSdk.listToolMetadata();
             sdk = nextSdk;
             needsCredentials = false;
+            subscribeSdkTaskNotifications();
             await restoreSessionRuntimeSelection();
         }
         catch (error) {
@@ -2525,6 +2598,9 @@ export async function startHadamardGuiServer(options = {}) {
             : await listArchivedSessionsForWorkDir(workDir, homeDir);
         const railStore = await readContextRailStore(workDir, homeDir);
         const activeProject = heavy.projects.find(project => project.active);
+        const extensionStates = sdk?.builtInExtensions.list()
+            ?? resolveBuiltInExtensionStates(store?.raw);
+        const extensionStateById = new Map(extensionStates.map(item => [item.id, item]));
         return {
             workDir,
             platform: process.platform,
@@ -2581,6 +2657,23 @@ export async function startHadamardGuiServer(options = {}) {
                 apiKey: env.HADAMARD_API_KEY ?? env.HADAMARD_AUTH_TOKEN ?? '',
                 apiKeyMasked: maskApiKey(env.HADAMARD_API_KEY ?? env.HADAMARD_AUTH_TOKEN ?? ''),
                 preferences: store ? readGuiPreferences(store.raw) : DEFAULT_GUI_PREFERENCES,
+                extensions: BUILT_IN_EXTENSIONS.map(definition => ({
+                    id: definition.id,
+                    title: definition.title,
+                    description: definition.description,
+                    kind: definition.kind,
+                    defaultEnabled: definition.defaultEnabled,
+                    enabled: extensionStateById.get(definition.id)?.enabled ?? definition.defaultEnabled,
+                })),
+                autoDetectLanguageServers: sdk?.config.autoDetectLanguageServers
+                    ?? (typeof store?.raw.autoDetectLanguageServers === 'boolean'
+                        ? store.raw.autoDetectLanguageServers
+                        : true),
+                languageServers: (sdk?.config.languageServers ?? []).map(server => ({
+                    id: server.id,
+                    languages: [...server.languages],
+                    command: server.command,
+                })),
                 browser: readHadamardBrowserSettings(store?.raw ?? {}),
                 bridge: store?.raw?.bridge ?? {},
                 sandbox: sdk
@@ -2597,7 +2690,7 @@ export async function startHadamardGuiServer(options = {}) {
             },
             bridgeState: {
                 mode: bridgeMode,
-                enabled: bridgeModeEnabled,
+                enabled: bridgeModeEnabled, activeKeywayRouteAlias,
                 activeConfig: activeBridgeConfig
                     ? {
                         name: activeBridgeConfig.name,
@@ -2705,6 +2798,7 @@ export async function startHadamardGuiServer(options = {}) {
                     costUsd: configCost(cfgName, rec),
                 })),
             },
+            ...usageBarState(),
             ...liveRunState(),
             terminalCapable,
             railItems: sortContextRailItems(railStore.items),
@@ -2801,6 +2895,23 @@ export async function startHadamardGuiServer(options = {}) {
                 allowEvaluate: browserBody.allowEvaluate === true,
             });
         }
+        if (typeof body.autoDetectLanguageServers === 'boolean') {
+            raw.autoDetectLanguageServers = body.autoDetectLanguageServers;
+        }
+        if (isPlainRecord(body.extensions)) {
+            const existingExtensions = isPlainRecord(raw.extensions) ? { ...raw.extensions } : {};
+            for (const definition of BUILT_IN_EXTENSIONS) {
+                const requested = body.extensions[definition.id];
+                if (!isPlainRecord(requested) || typeof requested.enabled !== 'boolean')
+                    continue;
+                const existingValue = existingExtensions[definition.id];
+                const existing = isPlainRecord(existingValue)
+                    ? { ...existingValue }
+                    : {};
+                existingExtensions[definition.id] = { ...existing, enabled: requested.enabled };
+            }
+            raw.extensions = existingExtensions;
+        }
         const preferences = isPlainRecord(body.preferences)
             ? readGuiPreferences({ gui: body.preferences })
             : readGuiPreferences(raw);
@@ -3506,7 +3617,7 @@ export async function startHadamardGuiServer(options = {}) {
             }
             const result = await stream.result;
             desc.status = 'done';
-            recordUsage(desc.model ?? session.model, result.usage);
+            recordUsage(desc.model ?? session.model, result.usage, result.runId);
             return result.text ?? '';
         }
         catch (error) {
@@ -3649,7 +3760,7 @@ export async function startHadamardGuiServer(options = {}) {
         try {
             let routed;
             const configActive = !!activeBridgeConfig;
-            const effectiveBridgeMode = bridgeMode && bridgeModeEnabled;
+            const effectiveBridgeMode = bridgeMode && (bridgeModeEnabled || Boolean(activeKeywayRouteAlias));
             if (activeRouter && !effectiveBridgeMode && !configActive) {
                 const decision = await resolveRoutedRun(activeRouter, input, runAbort.signal, {
                     projectDir: workDir,
@@ -3700,7 +3811,7 @@ export async function startHadamardGuiServer(options = {}) {
                 events.push({ type: 'command.result', title: `Automation result - ${task.name}`, text });
             }
             const effectiveModel = hadamardModel ?? routed?.model ?? activeBridgeModelApi?.model ?? session.model;
-            recordUsage(effectiveModel, result.usage);
+            recordUsage(effectiveModel, result.usage, result.runId);
             if (result.usage) {
                 desc.tokenUsage = {
                     input: result.usage.input_tokens ?? 0,
@@ -3736,6 +3847,7 @@ export async function startHadamardGuiServer(options = {}) {
     // it; streamRun injects {model, modelApi} per-run on the SAME session, so
     // context survives switching bridge↔hadamard. No child process anywhere.
     async function activateBridgeConfig(config) {
+        activeKeywayRouteAlias = null;
         if (!bridgeModeEnabled) {
             throw new GuiRuntimeMutationConflictError('Bridge mode is disabled. Enable it from the main Configuration tab before selecting a bridge config.');
         }
@@ -3780,6 +3892,7 @@ export async function startHadamardGuiServer(options = {}) {
         activeBridgeConfig = null;
         activeAgentSelectionName = null;
         activeBridgeModelApi = null;
+        activeKeywayRouteAlias = null;
         bridgeModelLabel = null;
         // session context stays intact — switching back to the default provider.
     }
@@ -4283,6 +4396,9 @@ export async function startHadamardGuiServer(options = {}) {
         const spaceIndex = raw.indexOf(' ');
         const name = (spaceIndex === -1 ? raw.slice(1) : raw.slice(1, spaceIndex)).toLowerCase();
         const args = spaceIndex === -1 ? '' : raw.slice(spaceIndex + 1).trim();
+        const usageRoutingResult = await runGuiUsageRoutingCommand(usageRoutingRuntime.admin, name, args, usageRoutingRuntime.activateRoute);
+        if (usageRoutingResult)
+            return [usageRoutingResult];
         switch (name) {
             case 'help':
                 return [{
@@ -4689,6 +4805,26 @@ export async function startHadamardGuiServer(options = {}) {
                     return [{ type: 'error', message: error instanceof Error ? error.message : String(error) }];
                 }
             }
+            case 'extensions': {
+                if (!sdk)
+                    return [{ type: 'error', message: 'Extensions require a configured Hadamard provider.' }];
+                try {
+                    const result = await runExtensionsCommandView(sdk.builtInExtensions, args);
+                    return [
+                        { type: 'command.result', title: 'Extensions', text: result.message, items: result.items },
+                        ...(args.trim() ? [{ type: 'state' }] : []),
+                    ];
+                }
+                catch (error) {
+                    return [{ type: 'error', message: error instanceof Error ? error.message : String(error) }];
+                }
+            }
+            case 'lsp': {
+                if (!sdk)
+                    return [{ type: 'error', message: 'Language server status requires a configured Hadamard provider.' }];
+                const result = await runLspCommandView(sdk.codeIntelligence);
+                return [{ type: 'command.result', title: 'Language servers', text: result.message, items: result.items }];
+            }
             case 'automation': {
                 if (args === 'new') {
                     return [{ type: 'notice', message: 'Open Automation and select New task.' }];
@@ -5283,6 +5419,7 @@ export async function startHadamardGuiServer(options = {}) {
                         lines.push(`  ${cfgName}${star} — ${rec.turns} turns, ${(rec.inputTokens + rec.outputTokens).toLocaleString()} tokens${cost ? ', ' + cost : ''}`);
                     }
                 }
+                await appendGuiLedgerUsage(lines, !!sdk?.builtInExtensions.isEnabled('costTracker'), resolveGuiHomeDir());
                 return [{ type: 'command.result', title: 'Usage', text: lines.join('\n') }];
             }
             case 'doctor': {
@@ -6160,6 +6297,7 @@ export async function startHadamardGuiServer(options = {}) {
         const runBridgeMode = bridgeMode;
         const runBridgeConfig = activeBridgeConfig;
         const runBridgeModelApi = activeBridgeModelApi;
+        const runKeywayRouteAlias = activeKeywayRouteAlias;
         const runRouter = activeRouter;
         const runAgentOptions = currentEffectiveAgentRunOptions();
         const runTools = currentRunTools();
@@ -6397,8 +6535,8 @@ export async function startHadamardGuiServer(options = {}) {
                 stream = createExternalCliAgentStream(input, externalCliConfig, runId, runAbort.signal, runSession, runWorkDir);
             }
             else if (runBridgeMode && runBridgeModelApi) {
-                const bridgeName = runBridgeConfig?.name ?? 'bridge';
-                send({ type: 'notice', message: `bridge -> ${bridgeName} (${runBridgeModelApi.model})` });
+                const routeLabel = runKeywayRouteAlias ? `keyway route ${runKeywayRouteAlias}` : `bridge ${runBridgeConfig?.name ?? 'bridge'}`;
+                send({ type: 'notice', message: `${routeLabel} -> ${runBridgeModelApi.model}` });
                 stream = runSession.stream(expandImageRefs(input, runWorkDir), {
                     ...effectiveAgentOptions,
                     signal: withAgentRunTimeout(runAbort.signal),
@@ -6433,6 +6571,9 @@ export async function startHadamardGuiServer(options = {}) {
             const toolCallInputs = new Map();
             for await (const event of stream) {
                 forwardAgentEvent(event, send, runId);
+                if (event.type === 'request.started' && typeof event.requestTokenEstimate === 'number') {
+                    lastContextTokenEstimate = event.requestTokenEstimate;
+                }
                 if (event.type === 'error')
                     errorEventSeen = true;
                 if (event.type === 'tool.call') {
@@ -6475,7 +6616,7 @@ export async function startHadamardGuiServer(options = {}) {
                 ?? routed?.model
                 ?? runBridgeModelApi?.model
                 ?? runSession.model;
-            recordUsage(effectiveModel, result.usage);
+            recordUsage(effectiveModel, result.usage, result.runId);
             desc.status = 'done';
             const runUsage = result.usage;
             if (runUsage)
@@ -7102,6 +7243,7 @@ export async function startHadamardGuiServer(options = {}) {
             body: runtimeMutationErrorBody(error),
         }),
     });
+    const usageRoutingRuntime = await createGuiUsageRoutingRuntime({ router: httpRouter, homeDir: resolveGuiHomeDir(), workDir, secretStore: options.keywaySecretStore, admin: options.usageRoutingAdmin, onRouteSelected: selection => withRuntimeMutation(async () => { disableBridge(); activeRouter = null; routedModelLabel = null; activeBridgeModelApi = { model: selection.model, modelApi: selection.modelApi, maxTokens: 32000 }; bridgeModelLabel = selection.model; bridgeMode = true; activeKeywayRouteAlias = selection.routeAlias; await persistSessionRuntimeMetadata(); }) });
     function parseDeleteStrategy(raw) {
         if (!isPlainRecord(raw))
             return { type: 'leave' };
@@ -10168,6 +10310,7 @@ export async function startHadamardGuiServer(options = {}) {
         await automationScheduler.dispose();
         terminalManager.closeAll();
         await externalCliRuntimeManager.close().catch(() => undefined);
+        await usageRoutingRuntime?.close();
         if (sdk) {
             for (let attempt = 1; attempt <= 2; attempt += 1) {
                 try {