praxis-agent 0.16.0 → 0.17.0

package/dist/application/subagent-service.d.ts

@@ -1,6 +1,6 @@
 import { type ClaudeSidechainPermissionMode } from '../compatibility/claude/sidechain.js';
 import { type ContextAssembler } from '../core/context.js';
-import { type ModelProvider, type ModelToolCall, type ModelToolDefinition, type ModelUsage, type PermissionResolver, type PermissionApproval, type PermissionDecision, type PermissionUpdate, type RuntimeEventSink, type ToolExecutionContext, type ToolExecutionResult, type ToolRegistry } from '../core/runtime.js';
+import { type ModelProvider, type ModelToolCall, type ModelToolDefinition, type ModelUsage, type ModelUsageByModel, type PermissionResolver, type PermissionApproval, type PermissionDecision, type PermissionUpdate, type RuntimeEventSink, type ToolExecutionContext, type ToolExecutionResult, type ToolRegistry } from '../core/runtime.js';
 import { type ClaudeAgentRuntimeDefinition, type ClaudeExtensionCatalog } from '../extensions/claude-extensions.js';
 import type { ClaudeHookRunner } from '../hooks/claude-hooks.js';
 import type { ClaudeMcpRuntime } from '../mcp/claude-mcp-tools.js';
@@ -23,6 +23,9 @@ export interface WorkflowAgentRunOptions {
 export interface WorkflowAgentRunResult {
     result: unknown;
     usage: ModelUsage;
+    modelUsage?: ModelUsageByModel;
+    durationApiMs?: number;
+    durationApiWithoutRetriesMs?: number;
     toolUseCount: number;
     durationMs: number;
     resolvedModel: string;
@@ -71,6 +74,10 @@ export interface ClaudeSubagentExecutorOptions {
     toolNames?: readonly string[];
     backgroundTaskNotifications?: (waitForRunning: boolean) => Promise<string[]>;
     persistence?: 'disk' | 'memory';
+    onLineChanges?: (changes: {
+        readonly linesAdded: number;
+        readonly linesRemoved: number;
+    }) => void | Promise<void>;
 }
 export declare class ClaudeSubagentExecutor {
     private readonly options;
@@ -100,6 +107,9 @@ export declare class ClaudeSubagentExecutor {
     notifications(waitForRunning: boolean): Promise<{
         messages: string[];
         usage: ModelUsage;
+        modelUsage?: ModelUsageByModel;
+        durationApiMs?: number;
+        durationApiWithoutRetriesMs?: number;
     }>;
     private hydrateCompletedTask;
     private resolvePersistedAgentId;

package/dist/application/subagent-service.js

@@ -673,6 +673,15 @@ export class ClaudeSubagentExecutor {
             ].join('\n\n'),
             isError: false,
             usage: result.usage,
+            ...(result.modelUsage ? { modelUsage: { ...result.modelUsage } } : {}),
+            ...(result.durationApiMs === undefined
+                ? {}
+                : { durationApiMs: result.durationApiMs }),
+            ...(result.durationApiWithoutRetriesMs === undefined
+                ? {}
+                : {
+                    durationApiWithoutRetriesMs: result.durationApiWithoutRetriesMs,
+                }),
             nativeToolUseResult: {
                 ...createClaudeAgentToolUseResult({
                     prompt: input.prompt,
@@ -863,6 +872,15 @@ export class ClaudeSubagentExecutor {
         return {
             result: options.schema ? structured.value : run.text,
             usage: run.usage,
+            ...(run.modelUsage ? { modelUsage: { ...run.modelUsage } } : {}),
+            ...(run.durationApiMs === undefined
+                ? {}
+                : { durationApiMs: run.durationApiMs }),
+            ...(run.durationApiWithoutRetriesMs === undefined
+                ? {}
+                : {
+                    durationApiWithoutRetriesMs: run.durationApiWithoutRetriesMs,
+                }),
             toolUseCount: run.toolUseCount,
             durationMs: Date.now() - startedAt,
             resolvedModel: provider.model ?? 'praxis/provider',
@@ -1253,6 +1271,13 @@ export class ClaudeSubagentExecutor {
                 await append(toClaudeSidechainEntry(entry, options.agentId, options.input.subagentType));
             },
             toolCompleted: async (call, result) => {
+                if (result.isError === false) {
+                    const linesAdded = result.linesAdded ?? 0;
+                    const linesRemoved = result.linesRemoved ?? 0;
+                    if (linesAdded !== 0 || linesRemoved !== 0) {
+                        await this.options.onLineChanges?.({ linesAdded, linesRemoved });
+                    }
+                }
                 const nestedToolUseCount = result.nativeToolUseResult?.totalToolUseCount;
                 if (call.name === 'Agent' &&
                     typeof nestedToolUseCount === 'number' &&
@@ -1357,6 +1382,7 @@ export class ClaudeSubagentExecutor {
             const effectiveEffort = options.effort ?? configuredEffort;
             const result = await runtime.run({
                 messages: await assembleMessages(),
+                collectMetrics: true,
                 reloadMessages: assembleMessages,
                 cwd,
                 ...(effectiveEffort ? { effort: effectiveEffort } : {}),
@@ -1395,7 +1421,21 @@ export class ClaudeSubagentExecutor {
                             });
                             messages.push(...background.messages);
                             messages.push(...((await this.options.backgroundTaskNotifications?.(true)) ?? []));
-                            return { messages, usage: background.usage };
+                            return {
+                                messages,
+                                usage: background.usage,
+                                ...(background.modelUsage
+                                    ? { modelUsage: background.modelUsage }
+                                    : {}),
+                                ...(background.durationApiMs === undefined
+                                    ? {}
+                                    : { durationApiMs: background.durationApiMs }),
+                                ...(background.durationApiWithoutRetriesMs === undefined
+                                    ? {}
+                                    : {
+                                        durationApiWithoutRetriesMs: background.durationApiWithoutRetriesMs,
+                                    }),
+                            };
                         },
                     }
                     : {}),

package/dist/application/tool-use-summary.d.ts

@@ -1,8 +1,13 @@
-import type { ModelProvider } from '../core/runtime.js';
+import type { ModelProvider, ModelUsage, ToolUseSummaryOutcome } from '../core/runtime.js';
 export interface ToolUseSummaryInput {
     name: string;
     input: Record<string, unknown>;
     output: string;
 }
-export declare function generateToolUseSummary(provider: ModelProvider, tools: readonly ToolUseSummaryInput[], signal: AbortSignal, lastAssistantText?: string): Promise<string | null>;
+export declare function generateToolUseSummary(provider: ModelProvider, tools: readonly ToolUseSummaryInput[], signal: AbortSignal, lastAssistantText?: string, onMetrics?: (metrics: {
+    usage: ModelUsage;
+    model?: string;
+    durationApiMs: number;
+    durationApiWithoutRetriesMs: number;
+}) => void): Promise<ToolUseSummaryOutcome | null>;
 //# sourceMappingURL=tool-use-summary.d.ts.map

package/dist/application/tool-use-summary.js

@@ -1,3 +1,4 @@
+import { completeMeteredModelRequest, } from './metered-model-completion.js';
 const TOOL_USE_SUMMARY_SYSTEM_PROMPT = `Write a short summary label describing what these tool calls accomplished. It appears as a single-line row in a mobile app and truncates around 30 characters, so think git-commit-subject, not sentence.
 
 Keep the verb in past tense and the most distinctive noun. Drop articles, connectors, and long location context first.
@@ -20,7 +21,14 @@ function truncateJson(value, maxLength) {
         return serialized;
     return `${serialized.slice(0, maxLength - 3)}...`;
 }
-export async function generateToolUseSummary(provider, tools, signal, lastAssistantText) {
+function hasNonZeroUsage(usage) {
+    return (usage.inputTokens > 0 ||
+        usage.outputTokens > 0 ||
+        (usage.cacheReadInputTokens ?? 0) > 0 ||
+        (usage.cacheCreationInputTokens ?? 0) > 0 ||
+        (usage.webSearchRequests ?? 0) > 0);
+}
+export async function generateToolUseSummary(provider, tools, signal, lastAssistantText, onMetrics) {
     if (tools.length === 0 || signal.aborted)
         return null;
     const toolSummaries = tools
@@ -36,18 +44,42 @@ export async function generateToolUseSummary(provider, tools, signal, lastAssist
             content: `${contextPrefix}Tools completed:\n\n${toolSummaries}\n\nLabel:`,
         },
     ];
-    let summary = '';
+    let metrics;
+    let summary = null;
     try {
-        for await (const event of provider.complete({ messages, signal })) {
-            if (signal.aborted)
-                return null;
-            if (event.type === 'text-delta')
-                summary += event.delta;
-        }
+        const completed = await completeMeteredModelRequest(provider, { messages, signal }, {
+            onMetrics: (recorded) => {
+                metrics = recorded;
+            },
+        });
+        summary =
+            completed.toolCalls.length === 0 ? completed.text.trim() || null : null;
     }
     catch {
-        return null;
+        // Provider/validation/abort errors keep the captured metrics but yield no
+        // summary, preserving the auxiliary-failure semantics.
+        summary = null;
+    }
+    // Invoke the external callback exactly once when the provider call started.
+    // Callback/tracker errors are intentionally not caught so cost accounting
+    // fails closed. Without an external callback nothing was committed, so the
+    // outcome stays unrecorded.
+    let meteredExternally = false;
+    if (metrics) {
+        onMetrics?.(metrics);
+        meteredExternally = onMetrics !== undefined;
     }
-    return summary.trim() || null;
+    const usage = metrics?.usage ?? { inputTokens: 0, outputTokens: 0 };
+    const model = metrics?.model !== undefined && metrics.model.trim() !== ''
+        ? metrics.model
+        : 'praxis/provider';
+    return {
+        summary,
+        usage,
+        ...(hasNonZeroUsage(usage) ? { modelUsage: { [model]: usage } } : {}),
+        durationApiMs: metrics?.durationApiMs ?? 0,
+        durationApiWithoutRetriesMs: metrics?.durationApiWithoutRetriesMs ?? 0,
+        meteredExternally,
+    };
 }
 //# sourceMappingURL=tool-use-summary.js.map

package/dist/application/workflow-manager.d.ts

@@ -1,3 +1,4 @@
+import type { ModelUsage, ModelUsageByModel } from '../core/runtime.js';
 import { ClaudeWorkflowStore } from '../persistence/claude-workflow-store.js';
 import type { WorkflowAgentRunOptions, WorkflowAgentRunResult } from './subagent-service.js';
 import { parseWorkflowScript, type ParsedWorkflowScript, type WorkflowMeta } from './workflow-meta.js';
@@ -74,6 +75,10 @@ interface WorkflowTask {
     totalTokens: number;
     totalInputTokens: number;
     totalToolCalls: number;
+    usage: ModelUsage;
+    modelUsage: Map<string, ModelUsage>;
+    durationApiMs: number;
+    durationApiWithoutRetriesMs: number;
     controller: AbortController;
     promise: Promise<void>;
     notificationPending: boolean;
@@ -107,10 +112,10 @@ export declare class WorkflowManager {
     stopAndWait(taskId: string): Promise<void>;
     notifications(waitForRunning: boolean): Promise<{
         messages: string[];
-        usage: {
-            inputTokens: number;
-            outputTokens: number;
-        };
+        usage: ModelUsage;
+        modelUsage?: ModelUsageByModel;
+        durationApiMs?: number;
+        durationApiWithoutRetriesMs?: number;
     }>;
     list(sessionId?: string): readonly WorkflowTaskSnapshot[];
     abortAll(): void;

package/dist/application/workflow-manager.js

@@ -81,6 +81,117 @@ function validateAgentOptions(options) {
         throw new Error('agent schema must be an object');
     }
 }
+const workflowUsageCounterFields = [
+    'inputTokens',
+    'outputTokens',
+    'cacheReadInputTokens',
+    'cacheCreationInputTokens',
+    'webSearchRequests',
+];
+const workflowUsageMetadataFields = [
+    'contextWindow',
+    'maxOutputTokens',
+];
+function assertValidWorkflowUsage(usage) {
+    for (const field of workflowUsageCounterFields) {
+        const value = usage[field];
+        if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) {
+            throw new Error(`Workflow agent usage has an invalid ${field} counter`);
+        }
+    }
+}
+function addWorkflowApiDuration(value, total, field) {
+    if (!Number.isFinite(value) || value < 0) {
+        throw new TypeError(`Workflow ${field} must be a finite nonnegative number`);
+    }
+    const next = total + value;
+    if (!Number.isFinite(next) || next < 0) {
+        throw new TypeError(`Workflow ${field} total overflow`);
+    }
+    return next;
+}
+function addWorkflowUsageChecked(model, left, right) {
+    assertValidWorkflowUsage(right);
+    const inputTokens = left.inputTokens + right.inputTokens;
+    const outputTokens = left.outputTokens + right.outputTokens;
+    const cacheReadInputTokens = (left.cacheReadInputTokens ?? 0) + (right.cacheReadInputTokens ?? 0);
+    const cacheCreationInputTokens = (left.cacheCreationInputTokens ?? 0) + (right.cacheCreationInputTokens ?? 0);
+    const webSearchRequests = (left.webSearchRequests ?? 0) + (right.webSearchRequests ?? 0);
+    if (!Number.isSafeInteger(inputTokens) ||
+        !Number.isSafeInteger(outputTokens) ||
+        !Number.isSafeInteger(cacheReadInputTokens) ||
+        !Number.isSafeInteger(cacheCreationInputTokens) ||
+        !Number.isSafeInteger(webSearchRequests)) {
+        throw new Error('Workflow model usage total overflow');
+    }
+    // Aggregates without a model stay counter-only; per-model rows merge their
+    // capability metadata with conflict rejection.
+    const metadata = model === undefined ? {} : mergeWorkflowUsageMetadata(model, left, right);
+    return {
+        inputTokens,
+        outputTokens,
+        ...(cacheReadInputTokens === 0 ? {} : { cacheReadInputTokens }),
+        ...(cacheCreationInputTokens === 0 ? {} : { cacheCreationInputTokens }),
+        ...(webSearchRequests === 0 ? {} : { webSearchRequests }),
+        ...metadata,
+    };
+}
+function mergeWorkflowUsageMetadata(model, left, right) {
+    const contextWindow = mergeWorkflowUsageMetadataField(model, 'contextWindow', left.contextWindow, right.contextWindow);
+    const maxOutputTokens = mergeWorkflowUsageMetadataField(model, 'maxOutputTokens', left.maxOutputTokens, right.maxOutputTokens);
+    return {
+        ...(contextWindow === undefined ? {} : { contextWindow }),
+        ...(maxOutputTokens === undefined ? {} : { maxOutputTokens }),
+    };
+}
+function mergeWorkflowUsageMetadataField(model, field, left, right) {
+    if (left === undefined)
+        return right;
+    if (right === undefined)
+        return left;
+    if (left !== right) {
+        throw new Error(`Workflow model usage for "${model}" has conflicting ${field} values: ${left} vs ${right}`);
+    }
+    return left;
+}
+function assertValidWorkflowModelUsageEntry(model, usage) {
+    if (model.trim() === '') {
+        throw new Error('Workflow model usage breakdown contains a blank model name');
+    }
+    assertValidWorkflowUsage(usage);
+    for (const field of workflowUsageMetadataFields) {
+        const value = usage[field];
+        if (value !== undefined && (!Number.isSafeInteger(value) || value < 1)) {
+            throw new Error(`Workflow model usage for "${model}" has an invalid ${field} metadata value`);
+        }
+    }
+}
+function mergeWorkflowModelUsageEntry(map, model, usage) {
+    assertValidWorkflowModelUsageEntry(model, usage);
+    const existing = map.get(model);
+    if (existing === undefined) {
+        map.set(model, { ...usage });
+        return;
+    }
+    map.set(model, addWorkflowUsageChecked(model, existing, usage));
+}
+function mergeWorkflowModelUsage(map, breakdown) {
+    const entries = Object.entries(breakdown);
+    if (entries.length === 0)
+        return;
+    // Validate every key, counter, metadata, and merged sum before adding any
+    // entry from this agent result so a malformed or conflicting breakdown never
+    // merges partially.
+    for (const [model, usage] of entries) {
+        assertValidWorkflowModelUsageEntry(model, usage);
+        const existing = map.get(model);
+        if (existing !== undefined)
+            addWorkflowUsageChecked(model, existing, usage);
+    }
+    for (const [model, usage] of entries) {
+        mergeWorkflowModelUsageEntry(map, model, usage);
+    }
+}
 export class WorkflowManager {
     configRoot;
     cwd;
@@ -140,6 +251,10 @@ export class WorkflowManager {
             totalTokens: 0,
             totalInputTokens: 0,
             totalToolCalls: 0,
+            usage: { inputTokens: 0, outputTokens: 0 },
+            modelUsage: new Map(),
+            durationApiMs: 0,
+            durationApiWithoutRetriesMs: 0,
             controller,
             promise: Promise.resolve(),
             notificationPending: false,
@@ -219,20 +334,39 @@ export class WorkflowManager {
                 .map(({ promise }) => promise));
         }
         const messages = [];
-        let inputTokens = 0;
-        let outputTokens = 0;
+        let usage = { inputTokens: 0, outputTokens: 0 };
+        const modelUsage = new Map();
+        let durationApiMs = 0;
+        let durationApiWithoutRetriesMs = 0;
+        let durationSeen = false;
+        const consumedTasks = [];
         for (const task of this.tasks.values()) {
             if (task.status === 'running' || !task.notificationPending)
                 continue;
-            task.notificationPending = false;
             messages.push(this.notification(task));
-            inputTokens += task.totalInputTokens;
-            outputTokens += task.totalTokens;
+            usage = addWorkflowUsageChecked(undefined, usage, task.usage);
+            for (const [model, entry] of task.modelUsage) {
+                mergeWorkflowModelUsageEntry(modelUsage, model, entry);
+            }
+            if (task.durationApiMs !== 0 || task.durationApiWithoutRetriesMs !== 0) {
+                durationSeen = true;
+                durationApiMs = addWorkflowApiDuration(task.durationApiMs, durationApiMs, 'durationApiMs');
+                durationApiWithoutRetriesMs = addWorkflowApiDuration(task.durationApiWithoutRetriesMs, durationApiWithoutRetriesMs, 'durationApiWithoutRetriesMs');
+            }
+            consumedTasks.push(task);
         }
-        return {
+        const modelUsageByModel = modelUsage.size === 0 ? undefined : Object.fromEntries(modelUsage);
+        const result = {
             messages,
-            usage: { inputTokens, outputTokens },
+            usage,
+            ...(modelUsageByModel === undefined
+                ? {}
+                : { modelUsage: modelUsageByModel }),
+            ...(durationSeen ? { durationApiMs, durationApiWithoutRetriesMs } : {}),
         };
+        for (const task of consumedTasks)
+            task.notificationPending = false;
+        return result;
     }
     list(sessionId) {
         return [...this.tasks.values()]
@@ -409,6 +543,16 @@ export class WorkflowManager {
                     task.totalTokens += progress.totalTokens;
                     task.totalInputTokens += result.usage.inputTokens;
                     task.totalToolCalls += result.toolUseCount;
+                    task.usage = addWorkflowUsageChecked(undefined, task.usage, result.usage);
+                    if (result.modelUsage !== undefined) {
+                        mergeWorkflowModelUsage(task.modelUsage, result.modelUsage);
+                    }
+                    if (result.durationApiMs !== undefined ||
+                        result.durationApiWithoutRetriesMs !== undefined) {
+                        const total = result.durationApiMs ?? 0;
+                        task.durationApiMs = addWorkflowApiDuration(total, task.durationApiMs, 'durationApiMs');
+                        task.durationApiWithoutRetriesMs = addWorkflowApiDuration(result.durationApiWithoutRetriesMs ?? total, task.durationApiWithoutRetriesMs, 'durationApiWithoutRetriesMs');
+                    }
                     await task.store.append({
                         type: 'result',
                         key,

package/dist/cli/interactive.d.ts

@@ -1,4 +1,5 @@
 import type { ForkResult, ManualCompactResult, ManualCompactSelection, RewindPoint, SessionForkCheckpoint, SessionRunResult, SessionSummary, SideQuestionForkResult, SideQuestionResult } from '../application/session-service.js';
+import type { ClaudeSessionCostSnapshot } from '../application/session-cost-tracker.js';
 import type { ModelImage, ModelToolCall, PermissionApproval, PermissionDecision, RuntimeEventSink } from '../core/runtime.js';
 import type { CliElicitationRequest, CliElicitationResult, CliRuntimeInfo } from './protocol.js';
 import type { ClaudeInteractiveToolCallbacks } from '../tools/claude-interactive-tools.js';
@@ -13,6 +14,7 @@ import type { AgentColorName } from '../compatibility/claude/agent-color.js';
 import type { ClaudeResourceScope } from '../compatibility/claude/shared-resources.js';
 import type { TuiHookConfiguration } from './tui/hook-settings.js';
 import { type TuiSlashCommand } from './tui/slash-commands.js';
+import { type DoctorReport } from '../maintenance/doctor.js';
 import { type TuiAgentEntry, type TuiFileEntry } from './tui/file-picker.js';
 import { type TuiEditorOptions, type TuiEditorResult } from './tui/external-editor.js';
 import { type TuiClipboardContent } from './tui/clipboard.js';
@@ -34,6 +36,7 @@ interface InteractiveSessionCommands {
     fork(sessionId: string, targetSessionId?: string, resumeSessionAt?: string): Promise<ForkResult>;
     sessions(): Promise<SessionSummary[]>;
     transcript?(sessionId: string): Promise<TranscriptItem[]>;
+    costSnapshot?(sessionId: string): Promise<ClaudeSessionCostSnapshot>;
     compact?(sessionId: string, signal?: AbortSignal, selection?: ManualCompactSelection): Promise<ManualCompactResult>;
     rewindFiles?(sessionId: string, userMessageId: string): Promise<void>;
     rewindPoints?(sessionId: string): Promise<RewindPoint[]>;
@@ -132,6 +135,7 @@ interface InteractiveAppProps {
     allowDangerouslySkipPermissions?: boolean;
     additionalDirectories?: readonly string[];
     diffLoader?: () => Promise<TuiDiffSnapshot>;
+    doctorLoader?: () => Promise<DoctorReport>;
     fileLoader?: () => Promise<readonly TuiFileEntry[]>;
     externalEditor?: (prompt: string, options: TuiEditorOptions) => Promise<TuiEditorResult>;
     keybindingsConfigRoot?: string;
@@ -184,7 +188,7 @@ interface InteractiveAppProps {
     releaseNotesLoader?: (configRoot: string) => Promise<string>;
     settingSources?: readonly ClaudeResourceScope[];
 }
-export declare function InteractiveApp({ factory, initialSessions, initialPrompt, initialHistory, initialSessionColor, signal, onCancel, onTurnChange, onCleanup, onRendererChange, onBackground, axScreenReader, allowNewSession, resume, display, terminalWidth, slashCommands, agents, allowDangerouslySkipPermissions, additionalDirectories, diffLoader, fileLoader, externalEditor, keybindingsConfigRoot, keybindingsFile, keybindingsLoader, keybindingsEditor, memoryFilesLoader, memoryEditor, memoryFolderOpener, suspendProcess, clipboardReader, clipboardWriter, sideQuestionClipboardWriter, exportWriter, permissionRuleStore, sandboxStore: suppliedSandboxStore, recentlyDeniedStore: suppliedRecentlyDeniedStore, terminalSetup: terminalSetupOverride, themeStore, initialThemeSettings, initialThemeLoadError, workspaceDirectoryResolver, workspaceDirectoryCompleter, runtimeSettings: suppliedRuntimeSettings, runtimeSettingsTarget, notificationWriter, elicitationUrlOpener, releaseNotesLoader, settingSources, }: InteractiveAppProps): import("react").JSX.Element;
+export declare function InteractiveApp({ factory, initialSessions, initialPrompt, initialHistory, initialSessionColor, signal, onCancel, onTurnChange, onCleanup, onRendererChange, onBackground, axScreenReader, allowNewSession, resume, display, terminalWidth, slashCommands, agents, allowDangerouslySkipPermissions, additionalDirectories, diffLoader, doctorLoader, fileLoader, externalEditor, keybindingsConfigRoot, keybindingsFile, keybindingsLoader, keybindingsEditor, memoryFilesLoader, memoryEditor, memoryFolderOpener, suspendProcess, clipboardReader, clipboardWriter, sideQuestionClipboardWriter, exportWriter, permissionRuleStore, sandboxStore: suppliedSandboxStore, recentlyDeniedStore: suppliedRecentlyDeniedStore, terminalSetup: terminalSetupOverride, themeStore, initialThemeSettings, initialThemeLoadError, workspaceDirectoryResolver, workspaceDirectoryCompleter, runtimeSettings: suppliedRuntimeSettings, runtimeSettingsTarget, notificationWriter, elicitationUrlOpener, releaseNotesLoader, settingSources, }: InteractiveAppProps): import("react").JSX.Element;
 export declare function runInteractive(options: {
     factory: InteractiveServiceFactory;
     initialPrompt?: string;