@promptbook/cli 0.113.0-1 → 0.113.0-11

package/src/execution/LlmExecutionTools.ts

@@ -4,12 +4,7 @@ import type { Prompt } from '../types/Prompt';
 import type { string_markdown, string_markdown_text } from '../types/string_markdown';
 import type { string_title } from '../types/string_title';
 import type { AvailableModel } from './AvailableModel';
-import type {
-    ChatPromptResult,
-    CompletionPromptResult,
-    EmbeddingPromptResult,
-    ImagePromptResult,
-} from './PromptResult';
+import type { ChatPromptResult, CompletionPromptResult, EmbeddingPromptResult, ImagePromptResult } from './PromptResult';
 
 /**
  * Container for all the tools needed to execute prompts to large language models like GPT-4

package/src/execution/createPipelineExecutor/getReservedParametersForTask.ts

@@ -1,10 +1,6 @@
 import { spaceTrim } from 'spacetrim';
 import type { ReadonlyDeep } from 'type-fest';
-import {
-    RESERVED_PARAMETER_MISSING_VALUE,
-    RESERVED_PARAMETER_NAMES,
-    RESERVED_PARAMETER_RESTRICTED,
-} from '../../constants';
+import { RESERVED_PARAMETER_MISSING_VALUE, RESERVED_PARAMETER_NAMES, RESERVED_PARAMETER_RESTRICTED } from '../../constants';
 import { UnexpectedError } from '../../errors/UnexpectedError';
 import type { PipelineJson } from '../../pipeline/PipelineJson/PipelineJson';
 import type { TaskJson } from '../../pipeline/PipelineJson/TaskJson';

package/src/llm-providers/_common/register/$registeredLlmToolsMessage/RegisteredLlmToolsMessageContext.ts

@@ -0,0 +1,51 @@
+import type { string_name } from '../../../../types/string_name';
+import type { Registered } from '../../../../utils/misc/$Register';
+import type { LlmToolsMetadata } from '../LlmToolsMetadata';
+
+/**
+ * Environment variables available for provider resolution.
+ *
+ * @private type of `$registeredLlmToolsMessage`
+ */
+export type AvailableEnvironmentVariables = Record<string_name, string>;
+
+/**
+ * Mixed provider entry assembled from both provider registers.
+ *
+ * @private type of `$registeredLlmToolsMessage`
+ */
+export type RegisteredLlmToolEntry = Registered & Partial<Pick<LlmToolsMetadata, 'title' | 'envVariables'>>;
+
+/**
+ * Provider entry enriched with runtime availability and configuration flags.
+ *
+ * @private type of `$registeredLlmToolsMessage`
+ */
+export type RegisteredLlmToolStatus = RegisteredLlmToolEntry & {
+    readonly isMetadataAvailable: boolean;
+    readonly isInstalled: boolean;
+    readonly isFullyConfigured: boolean;
+    readonly isPartiallyConfigured: boolean;
+};
+
+/**
+ * Provider register snapshots used to build the summary.
+ *
+ * @private type of `$registeredLlmToolsMessage`
+ */
+export type RegisteredLlmToolRegisters = {
+    readonly registeredMetadata: ReadonlyArray<LlmToolsMetadata>;
+    readonly registeredTools: ReadonlyArray<Registered>;
+};
+
+/**
+ * Message-rendering context for the registered providers summary.
+ *
+ * @private type of `$registeredLlmToolsMessage`
+ */
+export type RegisteredLlmToolsMessageContext = {
+    readonly env: AvailableEnvironmentVariables;
+    readonly llmToolStatuses: ReadonlyArray<RegisteredLlmToolStatus>;
+    readonly usedEnvMessage: string;
+    readonly isRunningInNode: boolean;
+};

package/src/llm-providers/_common/register/$registeredLlmToolsMessage/USED_ENV_FILENAME.ts

@@ -0,0 +1,30 @@
+import { spaceTrim } from 'spacetrim';
+import type { string_filename } from '../../../../types/string_filename';
+import type { $side_effect } from '../../../../utils/organization/$side_effect';
+
+/**
+ * Path to the `.env` file which was used to configure LLM tools
+ *
+ * Note: `$` is used to indicate that this variable is changed by side effect in `$provideLlmToolsConfigurationFromEnv` through `$setUsedEnvFilename`
+ */
+let $usedEnvFilename: string | null = null;
+
+/**
+ * Shared state for the `.env` file used to configure LLM tools.
+ *
+ * @private internal state of `$registeredLlmToolsMessage`
+ */
+export const USED_ENV_FILENAME = {
+    set(filepath: string_filename): $side_effect {
+        $usedEnvFilename = filepath;
+    },
+
+    createMessage(): string {
+        return $usedEnvFilename === null
+            ? `Unknown \`.env\` file`
+            : spaceTrim(`
+                  Used \`.env\` file:
+                  ${$usedEnvFilename}
+              `);
+    },
+};

package/src/llm-providers/_common/register/$registeredLlmToolsMessage/createRegisteredLlmToolConfigurationStatusMessage.ts

@@ -0,0 +1,62 @@
+import type {
+    AvailableEnvironmentVariables,
+    RegisteredLlmToolStatus,
+} from './RegisteredLlmToolsMessageContext';
+
+/**
+ * Creates the configuration-status sentence for one provider.
+ *
+ * @private function of `$registeredLlmToolsMessage`
+ */
+export function createRegisteredLlmToolConfigurationStatusMessage(
+    { envVariables, isFullyConfigured, isPartiallyConfigured }: RegisteredLlmToolStatus,
+    env: AvailableEnvironmentVariables,
+): string {
+    if (isFullyConfigured) {
+        return `Configured`;
+    }
+
+    if (isPartiallyConfigured) {
+        return createPartiallyConfiguredStatusMessage(envVariables, env);
+    }
+
+    if (envVariables !== null) {
+        return createNotConfiguredStatusMessage(envVariables);
+    }
+
+    return `Not configured`;
+    // <- Note: Can not be configured via environment variables
+}
+
+/**
+ * Creates the partial-configuration sentence including missing variables.
+ *
+ * @private function of `$registeredLlmToolsMessage`
+ */
+function createPartiallyConfiguredStatusMessage(
+    envVariables: RegisteredLlmToolStatus['envVariables'],
+    env: AvailableEnvironmentVariables,
+): string {
+    return `Partially confugured, missing ${listMissingEnvironmentVariables(envVariables, env).join(' + ')}`;
+}
+
+/**
+ * Creates the not-configured sentence including the expected environment variables.
+ *
+ * @private function of `$registeredLlmToolsMessage`
+ */
+function createNotConfiguredStatusMessage(envVariables: RegisteredLlmToolStatus['envVariables']): string {
+    return `Not configured, to configure set env ${envVariables?.join(' + ')}`;
+}
+
+/**
+ * Lists environment variables that are required but currently missing.
+ *
+ * @private function of `$registeredLlmToolsMessage`
+ */
+function listMissingEnvironmentVariables(
+    envVariables: RegisteredLlmToolStatus['envVariables'],
+    env: AvailableEnvironmentVariables,
+): Array<string> {
+    return envVariables?.filter((envVariable) => env[envVariable] === undefined) || [];
+}

package/src/llm-providers/_common/register/$registeredLlmToolsMessage/createRegisteredLlmToolEntryKey.ts

@@ -0,0 +1,10 @@
+import type { Registered } from '../../../../utils/misc/$Register';
+
+/**
+ * Creates a deduplication key for a provider entry.
+ *
+ * @private function of `$registeredLlmToolsMessage`
+ */
+export function createRegisteredLlmToolEntryKey({ packageName, className }: Registered): string {
+    return `${packageName}::${className}`;
+}

package/src/llm-providers/_common/register/$registeredLlmToolsMessage/createRegisteredLlmToolInstallationStatusMessage.ts

@@ -0,0 +1,75 @@
+import { just } from '../../../../utils/organization/just';
+import type { RegisteredLlmToolStatus } from './RegisteredLlmToolsMessageContext';
+
+/**
+ * Stable installation-state key from metadata and constructor availability.
+ *
+ * @private type of `$registeredLlmToolsMessage`
+ */
+type RegisteredLlmToolInstallationStatusKey =
+    | 'missing-metadata-and-installation'
+    | 'metadata-without-installation'
+    | 'installation-without-metadata'
+    | 'metadata-and-installation'
+    | 'unknown';
+
+/**
+ * Creates the installation-status sentence for one provider.
+ *
+ * @private function of `$registeredLlmToolsMessage`
+ */
+export function createRegisteredLlmToolInstallationStatusMessage({
+    isMetadataAvailable,
+    isInstalled,
+}: Pick<RegisteredLlmToolStatus, 'isMetadataAvailable' | 'isInstalled'>): string {
+    const installationStatusKey = createRegisteredLlmToolInstallationStatusKey(isMetadataAvailable, isInstalled);
+
+    if (just(false)) {
+        // Keep for prettier formatting
+    }
+
+    switch (installationStatusKey) {
+        case 'missing-metadata-and-installation':
+            return `Not installed and no metadata, looks like a unexpected behavior`;
+
+        case 'metadata-without-installation':
+            return `Not installed`;
+
+        case 'installation-without-metadata':
+            return `No metadata but installed, looks like a unexpected behavior`;
+
+        case 'metadata-and-installation':
+            return `Installed`;
+
+        default:
+            return `unknown state, looks like a unexpected behavior`;
+    }
+}
+
+/**
+ * Creates a stable installation-state key from metadata and constructor availability.
+ *
+ * @private function of `$registeredLlmToolsMessage`
+ */
+function createRegisteredLlmToolInstallationStatusKey(
+    isMetadataAvailable: boolean,
+    isInstalled: boolean,
+): RegisteredLlmToolInstallationStatusKey {
+    if (!isMetadataAvailable && !isInstalled) {
+        return 'missing-metadata-and-installation';
+    }
+
+    if (isMetadataAvailable && !isInstalled) {
+        return 'metadata-without-installation';
+    }
+
+    if (!isMetadataAvailable && isInstalled) {
+        return 'installation-without-metadata';
+    }
+
+    if (isMetadataAvailable && isInstalled) {
+        return 'metadata-and-installation';
+    }
+
+    return 'unknown';
+}

package/src/llm-providers/_common/register/$registeredLlmToolsMessage/createRegisteredLlmToolStatus.ts

@@ -0,0 +1,101 @@
+import type { Registered } from '../../../../utils/misc/$Register';
+import type { LlmToolsMetadata } from '../LlmToolsMetadata';
+import { hasRegisteredLlmToolEntry } from './hasRegisteredLlmToolEntry';
+import type {
+    AvailableEnvironmentVariables,
+    RegisteredLlmToolEntry,
+    RegisteredLlmToolStatus,
+} from './RegisteredLlmToolsMessageContext';
+
+/**
+ * Builds the runtime status for one provider entry.
+ *
+ * @private function of `$registeredLlmToolsMessage`
+ */
+export function createRegisteredLlmToolStatus({
+    registeredLlmToolEntry,
+    registeredMetadata,
+    registeredTools,
+    env,
+}: {
+    readonly registeredLlmToolEntry: RegisteredLlmToolEntry;
+    readonly registeredMetadata: ReadonlyArray<LlmToolsMetadata>;
+    readonly registeredTools: ReadonlyArray<Registered>;
+    readonly env: AvailableEnvironmentVariables;
+}): RegisteredLlmToolStatus {
+    const availabilityStatus = createRegisteredLlmToolAvailabilityStatus(
+        registeredLlmToolEntry,
+        registeredMetadata,
+        registeredTools,
+    );
+    const configurationStatus = createRegisteredLlmToolConfigurationStatus(registeredLlmToolEntry, env);
+
+    return {
+        ...registeredLlmToolEntry,
+        ...availabilityStatus,
+        ...configurationStatus,
+    };
+}
+
+/**
+ * Resolves whether the provider has metadata and a registered constructor.
+ *
+ * @private function of `$registeredLlmToolsMessage`
+ */
+function createRegisteredLlmToolAvailabilityStatus(
+    registeredLlmToolEntry: RegisteredLlmToolEntry,
+    registeredMetadata: ReadonlyArray<LlmToolsMetadata>,
+    registeredTools: ReadonlyArray<Registered>,
+): Pick<RegisteredLlmToolStatus, 'isMetadataAvailable' | 'isInstalled'> {
+    return {
+        isMetadataAvailable: hasRegisteredLlmToolEntry(registeredMetadata, registeredLlmToolEntry),
+        isInstalled: hasRegisteredLlmToolEntry(registeredTools, registeredLlmToolEntry),
+    };
+}
+
+/**
+ * Resolves whether the provider has enough environment variables to be configured.
+ *
+ * @private function of `$registeredLlmToolsMessage`
+ */
+function createRegisteredLlmToolConfigurationStatus(
+    { envVariables }: RegisteredLlmToolEntry,
+    env: AvailableEnvironmentVariables,
+): Pick<RegisteredLlmToolStatus, 'isFullyConfigured' | 'isPartiallyConfigured'> {
+    return {
+        isFullyConfigured: isRegisteredLlmToolFullyConfigured(envVariables, env),
+        isPartiallyConfigured: isRegisteredLlmToolPartiallyConfigured(envVariables, env),
+    };
+}
+
+/**
+ * Checks whether all required environment variables are present for a provider.
+ *
+ * @private function of `$registeredLlmToolsMessage`
+ */
+function isRegisteredLlmToolFullyConfigured(
+    envVariables: RegisteredLlmToolEntry['envVariables'],
+    env: AvailableEnvironmentVariables,
+): boolean {
+    if (envVariables === undefined || envVariables === null) {
+        return false;
+    }
+
+    return envVariables.every((envVariableName) => env[envVariableName] !== undefined);
+}
+
+/**
+ * Checks whether at least one required environment variable is present for a provider.
+ *
+ * @private function of `$registeredLlmToolsMessage`
+ */
+function isRegisteredLlmToolPartiallyConfigured(
+    envVariables: RegisteredLlmToolEntry['envVariables'],
+    env: AvailableEnvironmentVariables,
+): boolean {
+    if (envVariables === undefined || envVariables === null) {
+        return false;
+    }
+
+    return envVariables.some((envVariableName) => env[envVariableName] !== undefined);
+}

package/src/llm-providers/_common/register/$registeredLlmToolsMessage/createRegisteredLlmToolsMessageContext.ts

@@ -0,0 +1,24 @@
+import { $isRunningInNode } from '../../../../utils/environment/$isRunningInNode';
+import { USED_ENV_FILENAME } from './USED_ENV_FILENAME';
+import { getAvailableRegisteredLlmToolsEnvironmentVariables } from './getAvailableRegisteredLlmToolsEnvironmentVariables';
+import { getRegisteredLlmToolRegisters } from './getRegisteredLlmToolRegisters';
+import { listRegisteredLlmToolStatuses } from './listRegisteredLlmToolStatuses';
+import type { RegisteredLlmToolsMessageContext } from './RegisteredLlmToolsMessageContext';
+
+/**
+ * Collects all state needed to render the provider summary.
+ *
+ * @private function of `$registeredLlmToolsMessage`
+ */
+export function createRegisteredLlmToolsMessageContext(): RegisteredLlmToolsMessageContext {
+    const isRunningInNode = $isRunningInNode();
+    const env = getAvailableRegisteredLlmToolsEnvironmentVariables(isRunningInNode);
+    const registeredLlmToolRegisters = getRegisteredLlmToolRegisters();
+
+    return {
+        env,
+        llmToolStatuses: listRegisteredLlmToolStatuses(registeredLlmToolRegisters, env),
+        usedEnvMessage: USED_ENV_FILENAME.createMessage(),
+        isRunningInNode,
+    };
+}

package/src/llm-providers/_common/register/$registeredLlmToolsMessage/getAvailableRegisteredLlmToolsEnvironmentVariables.ts

@@ -0,0 +1,17 @@
+import type { AvailableEnvironmentVariables } from './RegisteredLlmToolsMessageContext';
+
+/**
+ * Reads environment variables relevant for provider configuration.
+ *
+ * @private function of `$registeredLlmToolsMessage`
+ */
+export function getAvailableRegisteredLlmToolsEnvironmentVariables(
+    isRunningInNode: boolean,
+): AvailableEnvironmentVariables {
+    if (isRunningInNode) {
+        return process.env as AvailableEnvironmentVariables;
+        // <- TODO: [⚛] Some DRY way how to get to `process.env` and pass it into functions - ACRY search for `env`
+    }
+
+    return {};
+}

package/src/llm-providers/_common/register/$registeredLlmToolsMessage/getRegisteredLlmToolRegisters.ts

@@ -0,0 +1,15 @@
+import { $llmToolsMetadataRegister } from '../$llmToolsMetadataRegister';
+import { $llmToolsRegister } from '../$llmToolsRegister';
+import type { RegisteredLlmToolRegisters } from './RegisteredLlmToolsMessageContext';
+
+/**
+ * Takes stable snapshots of both LLM provider registers.
+ *
+ * @private function of `$registeredLlmToolsMessage`
+ */
+export function getRegisteredLlmToolRegisters(): RegisteredLlmToolRegisters {
+    return {
+        registeredMetadata: $llmToolsMetadataRegister.list(),
+        registeredTools: $llmToolsRegister.list(),
+    };
+}

package/src/llm-providers/_common/register/$registeredLlmToolsMessage/hasRegisteredLlmToolEntry.ts

@@ -0,0 +1,19 @@
+import type { Registered } from '../../../../utils/misc/$Register';
+import { createRegisteredLlmToolEntryKey } from './createRegisteredLlmToolEntryKey';
+
+/**
+ * Checks whether the given provider entry already exists in the target register list.
+ *
+ * @private function of `$registeredLlmToolsMessage`
+ */
+export function hasRegisteredLlmToolEntry(
+    registeredLlmToolEntries: ReadonlyArray<Registered>,
+    registeredLlmToolEntry: Registered,
+): boolean {
+    const registeredLlmToolEntryKey = createRegisteredLlmToolEntryKey(registeredLlmToolEntry);
+
+    return registeredLlmToolEntries.some(
+        (listedRegisteredLlmToolEntry) =>
+            createRegisteredLlmToolEntryKey(listedRegisteredLlmToolEntry) === registeredLlmToolEntryKey,
+    );
+}

package/src/llm-providers/_common/register/$registeredLlmToolsMessage/listRegisteredLlmToolEntries.ts

@@ -0,0 +1,44 @@
+import type { Registered } from '../../../../utils/misc/$Register';
+import type { LlmToolsMetadata } from '../LlmToolsMetadata';
+import { createRegisteredLlmToolEntryKey } from './createRegisteredLlmToolEntryKey';
+import type { RegisteredLlmToolEntry } from './RegisteredLlmToolsMessageContext';
+
+/**
+ * Merges provider entries from the metadata and constructor registers.
+ *
+ * @private function of `$registeredLlmToolsMessage`
+ */
+export function listRegisteredLlmToolEntries(
+    registeredMetadata: ReadonlyArray<LlmToolsMetadata>,
+    registeredTools: ReadonlyArray<Registered>,
+): Array<RegisteredLlmToolEntry> {
+    const registeredLlmToolEntries = new Map<string, RegisteredLlmToolEntry>();
+
+    for (const { title, packageName, className, envVariables } of registeredMetadata) {
+        addRegisteredLlmToolEntry(registeredLlmToolEntries, { title, packageName, className, envVariables });
+    }
+
+    for (const { packageName, className } of registeredTools) {
+        addRegisteredLlmToolEntry(registeredLlmToolEntries, { packageName, className });
+    }
+
+    return [...registeredLlmToolEntries.values()];
+}
+
+/**
+ * Adds a provider entry only when the provider is not already present.
+ *
+ * @private function of `$registeredLlmToolsMessage`
+ */
+function addRegisteredLlmToolEntry(
+    registeredLlmToolEntries: Map<string, RegisteredLlmToolEntry>,
+    registeredLlmToolEntry: RegisteredLlmToolEntry,
+): void {
+    const registeredLlmToolEntryKey = createRegisteredLlmToolEntryKey(registeredLlmToolEntry);
+
+    if (registeredLlmToolEntries.has(registeredLlmToolEntryKey)) {
+        return;
+    }
+
+    registeredLlmToolEntries.set(registeredLlmToolEntryKey, registeredLlmToolEntry);
+}

package/src/llm-providers/_common/register/$registeredLlmToolsMessage/listRegisteredLlmToolStatuses.ts

@@ -0,0 +1,21 @@
+import { createRegisteredLlmToolStatus } from './createRegisteredLlmToolStatus';
+import { listRegisteredLlmToolEntries } from './listRegisteredLlmToolEntries';
+import type {
+    AvailableEnvironmentVariables,
+    RegisteredLlmToolRegisters,
+    RegisteredLlmToolStatus,
+} from './RegisteredLlmToolsMessageContext';
+
+/**
+ * Lists provider entries enriched with installation and configuration state.
+ *
+ * @private function of `$registeredLlmToolsMessage`
+ */
+export function listRegisteredLlmToolStatuses(
+    { registeredMetadata, registeredTools }: RegisteredLlmToolRegisters,
+    env: AvailableEnvironmentVariables,
+): Array<RegisteredLlmToolStatus> {
+    return listRegisteredLlmToolEntries(registeredMetadata, registeredTools).map((registeredLlmToolEntry) =>
+        createRegisteredLlmToolStatus({ registeredLlmToolEntry, registeredMetadata, registeredTools, env }),
+    );
+}

package/src/llm-providers/_common/register/$registeredLlmToolsMessage/renderAvailableRegisteredLlmTools.ts

@@ -0,0 +1,97 @@
+import colors from 'colors';
+import { spaceTrim } from 'spacetrim';
+import type {
+    AvailableEnvironmentVariables,
+    RegisteredLlmToolStatus,
+} from './RegisteredLlmToolsMessageContext';
+import { createRegisteredLlmToolConfigurationStatusMessage } from './createRegisteredLlmToolConfigurationStatusMessage';
+import { createRegisteredLlmToolInstallationStatusMessage } from './createRegisteredLlmToolInstallationStatusMessage';
+
+/**
+ * Renders all provider lines in the status summary.
+ *
+ * @private function of `$registeredLlmToolsMessage`
+ */
+export function renderAvailableRegisteredLlmTools(
+    llmToolStatuses: ReadonlyArray<RegisteredLlmToolStatus>,
+    env: AvailableEnvironmentVariables,
+    isRunningInNode: boolean,
+): string {
+    return llmToolStatuses
+        .map((llmToolStatus, index) => renderAvailableRegisteredLlmTool(llmToolStatus, index, env, isRunningInNode))
+        .join('\n');
+}
+
+/**
+ * Renders one provider line in the status summary.
+ *
+ * @private function of `$registeredLlmToolsMessage`
+ */
+function renderAvailableRegisteredLlmTool(
+    llmToolStatus: RegisteredLlmToolStatus,
+    index: number,
+    env: AvailableEnvironmentVariables,
+    isRunningInNode: boolean,
+): string {
+    const providerMessage = createAvailableRegisteredLlmToolMessage(llmToolStatus, index, env);
+
+    if (!isRunningInNode) {
+        return providerMessage;
+    }
+
+    return colorizeAvailableRegisteredLlmToolMessage(providerMessage, llmToolStatus);
+}
+
+/**
+ * Creates the plain-text provider line before optional colorization.
+ *
+ * @private function of `$registeredLlmToolsMessage`
+ */
+function createAvailableRegisteredLlmToolMessage(
+    llmToolStatus: RegisteredLlmToolStatus,
+    index: number,
+    env: AvailableEnvironmentVariables,
+): string {
+    const { title, packageName, className } = llmToolStatus;
+    const providerStatusMessages = createRegisteredLlmToolStatusMessages(llmToolStatus, env);
+
+    return spaceTrim(`
+        ${index + 1}) **${title}** \`${className}\` from \`${packageName}\`
+            ${providerStatusMessages.join('; ')}
+    `);
+}
+
+/**
+ * Creates the install and configuration fragments for one provider line.
+ *
+ * @private function of `$registeredLlmToolsMessage`
+ */
+function createRegisteredLlmToolStatusMessages(
+    llmToolStatus: RegisteredLlmToolStatus,
+    env: AvailableEnvironmentVariables,
+): Array<string> {
+    return [
+        createRegisteredLlmToolInstallationStatusMessage(llmToolStatus),
+        createRegisteredLlmToolConfigurationStatusMessage(llmToolStatus, env),
+    ];
+}
+
+/**
+ * Applies the same terminal coloring rules as the original summary renderer.
+ *
+ * @private function of `$registeredLlmToolsMessage`
+ */
+function colorizeAvailableRegisteredLlmToolMessage(
+    providerMessage: string,
+    { isInstalled, isFullyConfigured, isPartiallyConfigured }: RegisteredLlmToolStatus,
+): string {
+    if (isInstalled && isFullyConfigured) {
+        return colors.green(providerMessage);
+    }
+
+    if (isInstalled && isPartiallyConfigured) {
+        return colors.yellow(providerMessage);
+    }
+
+    return colors.gray(providerMessage);
+}

package/src/llm-providers/_common/register/$registeredLlmToolsMessage/renderNoRegisteredLlmToolsMessage.ts

@@ -0,0 +1,17 @@
+import { spaceTrim } from 'spacetrim';
+import type { string_markdown } from '../../../../types/string_markdown';
+
+/**
+ * Renders the fallback message for environments with no registered providers.
+ *
+ * @private function of `$registeredLlmToolsMessage`
+ */
+export function renderNoRegisteredLlmToolsMessage(usedEnvMessage: string): string_markdown {
+    return spaceTrim(
+        (block) => `
+            No LLM providers are available.
+
+            ${block(usedEnvMessage)}
+      `,
+    );
+}

package/src/llm-providers/_common/register/$registeredLlmToolsMessage/renderRegisteredLlmToolsMessage.ts

@@ -0,0 +1,30 @@
+import { spaceTrim } from 'spacetrim';
+import type { string_markdown } from '../../../../types/string_markdown';
+import { renderAvailableRegisteredLlmTools } from './renderAvailableRegisteredLlmTools';
+import { renderRelevantRegisteredLlmToolsEnvironmentVariables } from './renderRelevantRegisteredLlmToolsEnvironmentVariables';
+import type { RegisteredLlmToolsMessageContext } from './RegisteredLlmToolsMessageContext';
+
+/**
+ * Renders the full provider status summary.
+ *
+ * @private function of `$registeredLlmToolsMessage`
+ */
+export function renderRegisteredLlmToolsMessage({
+    env,
+    llmToolStatuses,
+    usedEnvMessage,
+    isRunningInNode,
+}: RegisteredLlmToolsMessageContext): string_markdown {
+    return spaceTrim(
+        (block) => `
+
+            ${block(usedEnvMessage)}
+
+            Relevant environment variables:
+            ${block(renderRelevantRegisteredLlmToolsEnvironmentVariables(env, llmToolStatuses))}
+
+            Available LLM providers are:
+            ${block(renderAvailableRegisteredLlmTools(llmToolStatuses, env, isRunningInNode))}
+        `,
+    );
+}