@tenex-chat/backend 0.9.5 → 0.9.6

package/src/llm/utils/provider-setup.ts

@@ -1,50 +1,97 @@
-import inquirer from "inquirer";
-
+import password from "@inquirer/password";
+import input from "@inquirer/input";
+import chalk from "chalk";
 import { AI_SDK_PROVIDERS } from "@/llm/types";
 import type { ProviderCredentials, TenexProviders } from "@/services/config/types";
-import { hasApiKey } from "@/llm/providers/key-manager";
+import { PROVIDER_IDS } from "@/llm/providers/provider-ids";
+import providerSelectPrompt, {
+    getKeys,
+    isOllama,
+    type PromptState,
+    type ProviderSelectConfig,
+} from "@/llm/utils/provider-select-prompt";
 import { ProviderConfigUI } from "@/llm/utils/ProviderConfigUI";
+import { inquirerTheme } from "@/utils/cli-theme";
+
+interface ProviderSetupOptions {
+    providerHints?: Record<string, string>;
+}
 
 /**
  * Interactive flow for configuring provider credentials.
- * Returns an updated TenexProviders object (merges into the existing map).
+ * Uses a two-level prompt: a provider list (browse/keys) and a separate
+ * password prompt for entering API keys.
  */
 export async function runProviderSetup(
-    existingProviders: TenexProviders
+    existingProviders: TenexProviders,
+    options: ProviderSetupOptions = {},
 ): Promise<TenexProviders> {
-    const providers: Record<string, ProviderCredentials> = {
-        ...existingProviders.providers,
-    };
-
-    const choices = AI_SDK_PROVIDERS.map((provider) => {
-        const isConfigured = hasApiKey(providers[provider]?.apiKey);
-        const name = ProviderConfigUI.getProviderDisplayName(provider);
-        return {
-            name: isConfigured ? `${name} (configured)` : name,
-            value: provider,
+    const providerIds = AI_SDK_PROVIDERS.filter((p) => p !== PROVIDER_IDS.CLAUDE_CODE);
+    const { providerHints } = options;
+
+    let resumeState: PromptState | undefined;
+
+    while (true) {
+        const baseConfig: ProviderSelectConfig = {
+            message: "Configure providers:",
+            providerIds: [...providerIds],
+            initialProviders: { ...existingProviders.providers },
+            providerHints,
+            resumeState,
+            theme: inquirerTheme,
         };
-    });
 
-    const { selected } = await inquirer.prompt([
-        {
-            type: "checkbox",
-            name: "selected",
-            message: "Select providers to configure:",
-            choices,
-        },
-    ]);
-
-    if (!selected || selected.length === 0) {
-        return existingProviders;
-    }
+        const result = await providerSelectPrompt(baseConfig);
+
+        if (result.action === "done") {
+            return { providers: result.providers };
+        }
 
-    for (const provider of selected) {
-        const providerConfig = await ProviderConfigUI.configureProvider(provider, providers);
-        providers[provider] = {
-            ...providers[provider],
-            apiKey: providerConfig.apiKey,
+        // add-key: ask for the key via a separate prompt
+        const { providerId, returnTo, state } = result;
+        const name = ProviderConfigUI.getProviderDisplayName(providerId);
+        const apiKey = await askForKey(providerId, name, providerHints?.[providerId]);
+
+        if (apiKey) {
+            const existing = getKeys(state.providers[providerId]?.apiKey);
+            if (existing.length > 0) {
+                state.providers[providerId] = {
+                    ...state.providers[providerId],
+                    apiKey: [...existing, apiKey],
+                } as ProviderCredentials;
+            } else {
+                state.providers[providerId] = { apiKey };
+            }
+        }
+
+        // Restore the prompt in the mode we came from
+        resumeState = {
+            ...state,
+            mode: returnTo,
+            keysTarget: returnTo === "keys" ? providerId : null,
+            keysActive: 0,
         };
     }
+}
+
+async function askForKey(providerId: string, displayName: string, hint?: string): Promise<string | undefined> {
+    if (isOllama(providerId)) {
+        const url = await input({
+            message: `${displayName} URL:`,
+            default: "http://localhost:11434",
+            theme: inquirerTheme,
+        });
+        return url.trim() || undefined;
+    }
+
+    if (hint) {
+        console.log(chalk.dim(`  Run ${chalk.bold("claude setup-token")} in another terminal, then paste the key (sk-ant-...) here.`));
+    }
 
-    return { providers };
+    const key = await password({
+        message: `${displayName} API key:`,
+        mask: "*",
+        theme: inquirerTheme,
+    });
+    return key.trim() || undefined;
 }

package/src/llm/utils/variant-list-prompt.ts

@@ -0,0 +1,361 @@
+import {
+    createPrompt,
+    useState,
+    useKeypress,
+    usePrefix,
+    isUpKey,
+    isDownKey,
+    isEnterKey,
+    isBackspaceKey,
+    makeTheme,
+    type Theme,
+} from "@inquirer/core";
+import type { PartialDeep } from "@inquirer/type";
+import { cursorHide } from "@inquirer/ansi";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { inquirerTheme } from "@/utils/cli-theme";
+import type { MetaModelConfiguration, MetaModelVariant } from "@/services/config/types";
+import * as display from "@/commands/setup/display";
+
+type VariantListAction =
+    | { action: "edit"; variantName: string }
+    | { action: "add" }
+    | { action: "done" };
+
+type VariantListResult = VariantListAction & {
+    variants: Record<string, MetaModelVariant>;
+    defaultVariant: string;
+};
+
+type VariantListConfig = {
+    message: string;
+    variants: Record<string, MetaModelVariant>;
+    defaultVariant: string;
+    theme?: PartialDeep<Theme>;
+};
+
+const variantListRawPrompt = createPrompt<VariantListResult, VariantListConfig>(
+    (config, done) => {
+        const theme = makeTheme(config.theme);
+        const prefix = usePrefix({ status: "idle", theme });
+
+        const [active, setActive] = useState(0);
+        const [variants, setVariants] = useState<Record<string, MetaModelVariant>>(
+            () => ({ ...config.variants }),
+        );
+        const [defaultVariant, setDefaultVariant] = useState(config.defaultVariant);
+
+        const variantNames = Object.keys(variants);
+        const addIndex = variantNames.length;
+        const doneIndex = variantNames.length + 1;
+        const itemCount = variantNames.length + 2;
+
+        useKeypress((key, rl) => {
+            rl.clearLine(0);
+
+            if (isUpKey(key)) {
+                setActive(Math.max(0, active - 1));
+            } else if (isDownKey(key)) {
+                setActive(Math.min(itemCount - 1, active + 1));
+            } else if (isEnterKey(key)) {
+                if (active < variantNames.length) {
+                    const name = variantNames[active];
+                    if (name) {
+                        done({
+                            action: "edit",
+                            variantName: name,
+                            variants: { ...variants },
+                            defaultVariant,
+                        });
+                    }
+                } else if (active === addIndex) {
+                    done({
+                        action: "add",
+                        variants: { ...variants },
+                        defaultVariant,
+                    });
+                } else if (active === doneIndex) {
+                    if (variantNames.length < 2) return;
+                    done({
+                        action: "done",
+                        variants: { ...variants },
+                        defaultVariant,
+                    });
+                }
+            } else if (key.name === "d" && active < variantNames.length) {
+                const name = variantNames[active];
+                if (name) setDefaultVariant(name);
+            } else if (
+                (isBackspaceKey(key) || key.name === "delete") &&
+                active < variantNames.length
+            ) {
+                if (variantNames.length <= 2) return;
+
+                const nameToDelete = variantNames[active];
+                if (!nameToDelete) return;
+
+                const updated = { ...variants };
+                delete updated[nameToDelete];
+                setVariants(updated);
+
+                if (defaultVariant === nameToDelete) {
+                    const remaining = Object.keys(updated);
+                    setDefaultVariant(remaining[0] ?? "");
+                }
+
+                const newCount = Object.keys(updated).length;
+                if (active >= newCount) {
+                    setActive(Math.max(0, newCount - 1));
+                }
+            }
+        });
+
+        // Render
+        const cursor = chalk.hex("#FFC107")("›");
+        const lines: string[] = [];
+
+        lines.push(`${prefix} ${theme.style.message(config.message, "idle")}`);
+        lines.push("");
+        lines.push(chalk.dim("  Variants:"));
+
+        for (let i = 0; i < variantNames.length; i++) {
+            const name = variantNames[i]!;
+            const variant = variants[name]!;
+            const isDefault = name === defaultVariant;
+            const pfx = i === active ? `${cursor} ` : "  ";
+            const defaultTag = isDefault ? chalk.dim(" (default)") : "";
+            const modelDisplay = chalk.gray(`[${variant.model}]`);
+
+            lines.push(`${pfx}${name} ${modelDisplay}${defaultTag}`);
+        }
+
+        lines.push(`  ${"─".repeat(40)}`);
+
+        // Add variant
+        const addPfx = active === addIndex ? `${cursor} ` : "  ";
+        lines.push(`${addPfx}${chalk.cyan("Add variant")}`);
+
+        // Done
+        const donePfx = active === doneIndex ? `${cursor} ` : "  ";
+        if (variantNames.length < 2) {
+            lines.push(`${donePfx}${chalk.dim("Done (need at least 2 variants)")}`);
+        } else {
+            lines.push(`${donePfx}${display.doneLabel()}`);
+        }
+
+        // Help line
+        const helpParts = [
+            `${chalk.bold("↑↓")} ${chalk.dim("navigate")}`,
+            `${chalk.bold("⏎")} ${chalk.dim("edit")}`,
+            `${chalk.bold("d")} ${chalk.dim("set default")}`,
+            `${chalk.bold("⌫")} ${chalk.dim("remove")}`,
+        ];
+        lines.push(chalk.dim(`  ${helpParts.join(chalk.dim(" • "))}`));
+
+        return `${lines.join("\n")}${cursorHide}`;
+    },
+);
+
+async function editVariantDetail(
+    variantName: string,
+    state: { variants: Record<string, MetaModelVariant>; defaultVariant: string },
+    standardConfigs: string[],
+): Promise<void> {
+    const variant = state.variants[variantName];
+    if (!variant) return;
+
+    while (true) {
+        const isDefault = variantName === state.defaultVariant;
+        const defaultTag = isDefault ? " (default)" : "";
+
+        display.blank();
+        display.context(`Variant: ${variantName} → ${variant.model}${defaultTag}`);
+        display.blank();
+
+        const { field } = await inquirer.prompt([{
+            type: "select",
+            name: "field",
+            message: `Edit ${variantName}:`,
+            choices: [
+                {
+                    name: `Model              ${chalk.dim(variant.model)}`,
+                    value: "model",
+                },
+                {
+                    name: `Trigger keyword    ${chalk.dim(variant.keywords?.join(", ") || "(none)")}`,
+                    value: "keywords",
+                },
+                {
+                    name: `When to use        ${chalk.dim(variant.description || "(none)")}`,
+                    value: "description",
+                },
+                {
+                    name: `Behavior when active  ${chalk.dim(variant.systemPrompt || "(none)")}`,
+                    value: "systemPrompt",
+                    description: "Extra instructions given to the agent when this variant is selected, e.g. 'Reason step by step'",
+                },
+                {
+                    name: "Back",
+                    value: "back",
+                },
+            ],
+            theme: inquirerTheme,
+        }]);
+
+        if (field === "back") break;
+
+        if (field === "model") {
+            const { model } = await inquirer.prompt([{
+                type: "select",
+                name: "model",
+                message: "Select model:",
+                choices: standardConfigs.map((n) => ({ name: n, value: n })),
+                theme: inquirerTheme,
+            }]);
+            variant.model = model;
+        } else if (field === "keywords") {
+            const { keywordsInput } = await inquirer.prompt([{
+                type: "input",
+                name: "keywordsInput",
+                message: "Trigger keywords (comma-separated):",
+                default: variant.keywords?.join(", ") || "",
+                theme: inquirerTheme,
+            }]);
+            const keywords = keywordsInput
+                ? keywordsInput.split(",").map((k: string) => k.trim().toLowerCase()).filter((k: string) => k.length > 0)
+                : [];
+            if (keywords.length > 0) {
+                variant.keywords = keywords;
+            } else {
+                delete variant.keywords;
+            }
+        } else if (field === "description") {
+            const { desc } = await inquirer.prompt([{
+                type: "input",
+                name: "desc",
+                message: "When to use this variant:",
+                default: variant.description || "",
+                theme: inquirerTheme,
+            }]);
+            if (desc) {
+                variant.description = desc;
+            } else {
+                delete variant.description;
+            }
+        } else if (field === "systemPrompt") {
+            const { prompt } = await inquirer.prompt([{
+                type: "input",
+                name: "prompt",
+                message: "Behavior when active:",
+                default: variant.systemPrompt || "",
+                theme: inquirerTheme,
+            }]);
+            if (prompt) {
+                variant.systemPrompt = prompt;
+            } else {
+                delete variant.systemPrompt;
+            }
+        }
+    }
+}
+
+async function addVariant(
+    state: { variants: Record<string, MetaModelVariant>; defaultVariant: string },
+    standardConfigs: string[],
+): Promise<void> {
+    const { name } = await inquirer.prompt([{
+        type: "input",
+        name: "name",
+        message: "Variant name:",
+        validate: (input: string) => {
+            if (!input.trim()) return "Name is required";
+            if (state.variants[input]) return "Variant already exists";
+            return true;
+        },
+        theme: inquirerTheme,
+    }]);
+
+    const { model } = await inquirer.prompt([{
+        type: "select",
+        name: "model",
+        message: "Select model for this variant:",
+        choices: standardConfigs.map((n) => ({ name: n, value: n })),
+        theme: inquirerTheme,
+    }]);
+
+    const isFirst = Object.keys(state.variants).length === 0;
+
+    state.variants[name] = { model };
+
+    // First variant auto-becomes default
+    if (!state.defaultVariant || isFirst) {
+        state.defaultVariant = name;
+    }
+
+    // For non-first variants, ask "when to use" so the system prompt is useful
+    if (!isFirst) {
+        const { desc } = await inquirer.prompt([{
+            type: "input",
+            name: "desc",
+            message: "When to use this variant:",
+            theme: inquirerTheme,
+        }]);
+        if (desc) {
+            state.variants[name]!.description = desc;
+        }
+    }
+}
+
+/**
+ * Interactive variant list prompt for multi-modal configuration.
+ * Shows variants in a navigable list with add/edit/delete/set-default actions.
+ * Returns a complete MetaModelConfiguration when done.
+ */
+export async function variantListPrompt(
+    configName: string,
+    standardConfigs: string[],
+): Promise<MetaModelConfiguration> {
+    let variants: Record<string, MetaModelVariant> = {};
+    let defaultVariant = "";
+
+    // No variants yet — go straight to adding the first one
+    const initialState = { variants, defaultVariant };
+    await addVariant(initialState, standardConfigs);
+    variants = initialState.variants;
+    defaultVariant = initialState.defaultVariant;
+
+    while (true) {
+        const result = await variantListRawPrompt({
+            message: configName,
+            variants,
+            defaultVariant,
+            theme: inquirerTheme,
+        });
+
+        variants = result.variants;
+        defaultVariant = result.defaultVariant;
+
+        if (result.action === "done") {
+            return {
+                provider: "meta",
+                variants,
+                default: defaultVariant,
+            };
+        }
+
+        if (result.action === "edit" && result.variantName) {
+            const state = { variants, defaultVariant };
+            await editVariantDetail(result.variantName, state, standardConfigs);
+            variants = state.variants;
+            defaultVariant = state.defaultVariant;
+        }
+
+        if (result.action === "add") {
+            const state = { variants, defaultVariant };
+            await addVariant(state, standardConfigs);
+            variants = state.variants;
+            defaultVariant = state.defaultVariant;
+        }
+    }
+}

package/src/nostr/AgentEventDecoder.ts

@@ -209,6 +209,7 @@ export class AgentEventDecoder {
         NDKKind.Contacts, // kind:3 - contact list
         NDKKind.TenexProjectStatus,
         NDKKind.TenexOperationsStatus,
+        NDKKind.TenexStreamTextDelta,
     ];
 
     /**

package/src/nostr/AgentEventEncoder.ts

@@ -17,6 +17,7 @@ import type {
     EventContext,
     InterventionReviewIntent,
     LessonIntent,
+    StreamTextDeltaIntent,
     ToolUseIntent,
 } from "./types";
 
@@ -561,6 +562,42 @@ export class AgentEventEncoder {
         return event;
     }
 
+    /**
+     * Encode an ephemeral stream text-delta event.
+     * These events are best-effort live updates and do not replace kind:1 snapshots.
+     */
+    encodeStreamTextDelta(intent: StreamTextDeltaIntent, context: EventContext): NDKEvent {
+        const event = new NDKEvent(getNDK());
+        event.kind = NDKKind.TenexStreamTextDelta;
+        event.content = intent.delta;
+
+        // Keep thread association via root conversation e-tag.
+        this.addConversationTags(event, context);
+
+        // Required project association for project-scoped filtering.
+        this.aTagProject(event);
+
+        // Include model when available for diagnostics/client metadata.
+        if (context.model) {
+            const modelString =
+                typeof context.model === "string"
+                    ? context.model
+                    : (context.model as { model?: string }).model;
+            if (modelString) {
+                event.tag(["llm-model", modelString]);
+            }
+        }
+
+        // Preserve RAL and strict delta ordering for client reconstruction.
+        event.tag(["llm-ral", context.ralNumber.toString()]);
+        event.tag(["stream-seq", intent.sequence.toString()]);
+
+        // Forward branch tag when present to preserve worktree context.
+        this.forwardBranchTag(event, context);
+
+        return event;
+    }
+
     /**
      * Encode an intervention review request event.
      * This is used by the InterventionService when a user hasn't responded

package/src/nostr/AgentProfilePublisher.ts

@@ -4,6 +4,7 @@ import { NDKKind } from "@/nostr/kinds";
 import { getNDK } from "@/nostr/ndkClient";
 import { config } from "@/services/ConfigService";
 import { Nip46SigningService, Nip46SigningLog } from "@/services/nip46";
+import { getSystemPubkeyListService } from "@/services/trust-pubkeys/SystemPubkeyListService";
 import { logger } from "@/utils/logger";
 import {
     NDKEvent,
@@ -291,6 +292,10 @@ export class AgentProfilePublisher {
         let profileEvent: NDKEvent;
 
         try {
+            await getSystemPubkeyListService().syncWhitelistFile({
+                additionalPubkeys: [signer.pubkey, ...(whitelistedPubkeys ?? [])],
+            });
+
             // Check if there are other agents with the same slug (name) in this project
             // If so, append pubkey prefix for disambiguation
             const projectDTag = projectEvent.dTag;
@@ -493,6 +498,10 @@ export class AgentProfilePublisher {
         whitelistedPubkeys?: string[]
     ): Promise<void> {
         try {
+            await getSystemPubkeyListService().syncWhitelistFile({
+                additionalPubkeys: [signer.pubkey, ...(whitelistedPubkeys ?? [])],
+            });
+
             const avatarUrl = AgentProfilePublisher.buildAvatarUrl(signer.pubkey);
 
             const profile = {
@@ -583,6 +592,10 @@ export class AgentProfilePublisher {
         projectTitle: string
     ): Promise<void> {
         try {
+            await getSystemPubkeyListService().syncWhitelistFile({
+                additionalPubkeys: [signer.pubkey],
+            });
+
             // Hash-based deduplication: skip if instructions haven't changed
             const instructionHash = crypto
                 .createHash("sha256")

package/src/nostr/AgentPublisher.ts

@@ -16,6 +16,7 @@ import type {
     ErrorIntent,
     EventContext,
     LessonIntent,
+    StreamTextDeltaIntent,
     ToolUseIntent,
 } from "./types";
 
@@ -418,6 +419,31 @@ export class AgentPublisher {
         return event;
     }
 
+    /**
+     * Publish an ephemeral stream text-delta event.
+     * Best-effort only: failures are logged and swallowed to avoid disrupting execution.
+     *
+     * IMPORTANT: This path intentionally does NOT consume RAL runtime counters.
+     * Runtime accounting remains tied to persistent kind:1 publications.
+     */
+    async streamTextDelta(intent: StreamTextDeltaIntent, context: EventContext): Promise<void> {
+        try {
+            const event = this.encoder.encodeStreamTextDelta(intent, context);
+            injectTraceContext(event);
+            await this.agent.sign(event);
+            await event.publish();
+        } catch (error) {
+            logger.warn("[AgentPublisher.streamTextDelta] Failed to publish stream delta (best-effort)", {
+                error: error instanceof Error ? error.message : String(error),
+                agent: this.agent.slug,
+                conversationId: context.conversationId.substring(0, 12),
+                ralNumber: context.ralNumber,
+                sequence: intent.sequence,
+                deltaLength: intent.delta.length,
+            });
+        }
+    }
+
     /**
      * Publish a delegation marker event.
      * Delegation markers track the lifecycle of delegation conversations.

package/src/nostr/kinds.ts

@@ -32,6 +32,7 @@ export const NDKKind = {
     TenexConfigUpdate: 25000 as BaseNDKKind, // Encrypted config updates (e.g., APNs device tokens)
     TenexOperationsStatus: 24133 as BaseNDKKind,
     TenexStopCommand: 24134 as BaseNDKKind,
+    TenexStreamTextDelta: 24135 as BaseNDKKind,
 } as const;
 
 export type NDKKind = (typeof NDKKind)[keyof typeof NDKKind];

package/src/nostr/ndkClient.ts

@@ -4,7 +4,7 @@ import { logger } from "@/utils/logger";
  * TENEX CLI: NDK Singleton
  * Manages a single NDK instance for the CLI
  */
-import NDK from "@nostr-dev-kit/ndk";
+import NDK, { NDKRelayAuthPolicies } from "@nostr-dev-kit/ndk";
 
 let ndk: NDK | undefined;
 
@@ -31,6 +31,9 @@ export async function initNDK(): Promise<void> {
         autoConnectUserRelays: true,
     });
 
+    // Auto-authenticate with relays that require NIP-42 auth
+    ndk.relayAuthDefaultPolicy = NDKRelayAuthPolicies.signIn({ ndk });
+
     // Connect with timeout - don't block daemon startup if relays are unreachable
     const connectionTimeout = 5000; // 5 seconds
     try {

package/src/nostr/types.ts

@@ -110,6 +110,17 @@ export interface ToolUseIntent {
     usage?: LanguageModelUsageWithCostUsd; // Cumulative usage from previous steps
 }
 
+/**
+ * Intent for ephemeral stream text-delta events.
+ * These events are best-effort live updates and do not replace kind:1 snapshots.
+ */
+export interface StreamTextDeltaIntent {
+    /** Delta text payload (coalesced by throttle interval) */
+    delta: string;
+    /** Strictly monotonic sequence number for client-side reordering */
+    sequence: number;
+}
+
 /**
  * Intent for intervention review requests.
  * Used when the InterventionService detects that a user hasn't responded
@@ -160,6 +171,7 @@ export type AgentIntent =
     | LessonIntent
     | StatusIntent
     | ToolUseIntent
+    | StreamTextDeltaIntent
     | InterventionReviewIntent
     | DelegationMarkerIntent;