veryfront 0.1.128 → 0.1.129

package/src/src/channels/invoke.ts

@@ -206,12 +206,12 @@ export function normalizeConversationHistoryForRuntime(
 
 export function resolveChannelInvokeAgent(
   assistantId: string,
-  deps: Pick<ChannelInvokeDeps, "getAgent" | "getAllAgentIds">,
+  deps: Pick<ChannelInvokeDeps, "getAgent">,
 ): Agent | undefined {
   return deps.getAgent(assistantId);
 }
 
-function normalizeToolCallState(status: string): "pending" | "completed" | "error" {
+function toChannelToolCallState(status: string): "pending" | "completed" | "error" {
   switch (status) {
     case "completed":
       return "completed";
@@ -281,7 +281,7 @@ export function buildChannelResponseParts(response: AgentResponse): ChannelRespo
       id: toolCall.id,
       name: toolCall.name,
       input: toolCall.args,
-      state: normalizeToolCallState(toolCall.status),
+      state: toChannelToolCallState(toolCall.status),
     }));
 
     if (toolCall.status === "completed" || toolCall.status === "error") {
@@ -314,7 +314,7 @@ export function buildChannelResponseParts(response: AgentResponse): ChannelRespo
   return responseParts;
 }
 
-function classifyRuntimeError(error: unknown): ChannelInvokeResponse["error"] {
+function classifyChannelInvokeError(error: unknown): ChannelInvokeResponse["error"] {
   const veryfrontError = fromError(error);
 
   if (veryfrontError?.type === "no_ai_available") {
@@ -352,12 +352,12 @@ export async function executeChannelInvoke(
     };
   }
 
-  const messages = normalizeConversationHistoryForRuntime(payload.conversationHistory);
+  const normalizedHistory = normalizeConversationHistoryForRuntime(payload.conversationHistory);
   await agent.clearMemory();
 
   try {
     const result = await agent.generate({
-      input: messages,
+      input: normalizedHistory,
       context: {
         requestId: payload.dispatchId,
         dispatchId: payload.dispatchId,
@@ -395,7 +395,7 @@ export async function executeChannelInvoke(
 
     return {
       ignored: false,
-      error: classifyRuntimeError(error),
+      error: classifyChannelInvokeError(error),
     };
   }
 }

package/src/src/chat/index.ts

@@ -47,55 +47,39 @@
  * </Message.Root>
  * ```
  */
-
-// veryfront/chat — Chat UI components + hooks
-//
-// Merges components/ai (UI) and agent/react (hooks) into a single
-// product-oriented import path.
-
-// ---------------------------------------------------------------------------
-// Core preset + compound
-// ---------------------------------------------------------------------------
 import "../../_dnt.polyfills.js";
 
 
-export { Chat, ChatComponents } from "../react/components/ai/chat.js";
-export type { ChatProps } from "../react/components/ai/chat.js";
-
-// ---------------------------------------------------------------------------
-// Composition building blocks
-// ---------------------------------------------------------------------------
+export { Chat, ChatComponents, type ChatProps } from "../react/components/ai/chat.js";
 
 export {
   ChatComposer,
+  type ChatComposerProps,
   ChatEmpty,
+  type ChatEmptyProps,
   ChatIf,
+  type ChatIfProps,
   ChatMessageList,
+  type ChatMessageListProps,
   ChatRoot,
+  type ChatRootProps,
   ErrorBanner,
+  type ErrorBannerProps,
   Message,
+  type MessageRootProps,
   ModelAvatar,
+  type ModelAvatarProps,
 } from "../react/components/ai/chat.js";
-export type {
-  ChatComposerProps,
-  ChatEmptyProps,
-  ChatIfProps,
-  ChatMessageListProps,
-  ChatRootProps,
-  ErrorBannerProps,
-  MessageRootProps,
-  ModelAvatarProps,
-} from "../react/components/ai/chat.js";
-
-// ---------------------------------------------------------------------------
-// Contexts
-// ---------------------------------------------------------------------------
 
 export {
   ChatContextProvider,
+  type ChatContextValue,
   ComposerContextProvider,
+  type ComposerContextValue,
   MessageContextProvider,
+  type MessageContextValue,
   ThreadListContextProvider,
+  type ThreadListContextValue,
   useChatContext,
   useChatContextOptional,
   useComposerContext,
@@ -105,167 +89,147 @@ export {
   useThreadListContext,
   useThreadListContextOptional,
 } from "../react/components/ai/chat.js";
-export type {
-  ChatContextValue,
-  ComposerContextValue,
-  MessageContextValue,
-  ThreadListContextValue,
-} from "../react/components/ai/chat.js";
-
-// ---------------------------------------------------------------------------
-// Sub-components
-// ---------------------------------------------------------------------------
 
 export {
+  type AttachmentInfo,
   AttachmentPill,
+  type AttachmentPillProps,
   BranchPicker,
+  type BranchPickerProps,
   ChatSidebar,
+  type ChatSidebarProps,
+  type ChatTab,
   ChatWithSidebar,
+  type ChatWithSidebarAttachmentConfig,
+  type ChatWithSidebarChatController,
+  type ChatWithSidebarFeatureConfig,
+  type ChatWithSidebarGroupedProps,
+  type ChatWithSidebarMessageConfig,
+  type ChatWithSidebarModelConfig,
+  type ChatWithSidebarProps,
+  type ChatWithSidebarQuickActionsConfig,
+  type ChatWithSidebarSidebarConfig,
+  type ChatWithSidebarTabsConfig,
+  type ChatWithSidebarVoiceConfig,
+  type CodeBlockProps,
   ConversationEmptyState,
+  type ConversationEmptyStateProps,
   ConversationScrollButton,
+  type ConversationScrollButtonProps,
   downloadMarkdown,
   DropZoneOverlay,
+  type DropZoneOverlayProps,
   exportAsMarkdown,
   extractSourcesFromParts,
   FadeIn,
+  type FeedbackValue,
   getTextContent,
   groupPartsInOrder,
   InferenceBadge,
+  type InferenceBadgeProps,
   InlineCitation,
+  type InlineCitationProps,
   isReasoningPart,
   isSkillToolPart,
   isToolPart,
   Loader,
   MessageActions,
+  type MessageActionsProps,
   MessageEditForm,
+  type MessageEditFormProps,
   MessageFeedback,
+  type MessageFeedbackProps,
+  type ModelOption,
   ModelSelector,
+  type ModelSelectorProps,
+  type PartGroup,
+  type QuickAction,
   QuickActions,
+  type QuickActionsProps,
   ReasoningCard,
   RichCodeBlock,
   Shimmer,
   SkillBadge,
+  type SkillBadgeProps,
+  type Source,
   Sources,
+  type SourcesProps,
   StepIndicator,
+  type StepIndicatorProps,
   Suggestion,
+  type SuggestionProps,
   Suggestions,
+  type SuggestionsProps,
   TabSwitcher,
+  type TabSwitcherProps,
+  type Thread,
   ToolCallCard,
   ToolStatusBadge,
   UpgradeCTA,
+  type UpgradeCTAProps,
+  type UploadedFile,
   UploadsPanel,
+  type UploadsPanelProps,
   useThreads,
-} from "../react/components/ai/chat.js";
-export type {
-  AttachmentInfo,
-  AttachmentPillProps,
-  BranchPickerProps,
-  ChatSidebarProps,
-  ChatTab,
-  ChatWithSidebarAttachmentConfig,
-  ChatWithSidebarChatController,
-  ChatWithSidebarFeatureConfig,
-  ChatWithSidebarGroupedProps,
-  ChatWithSidebarMessageConfig,
-  ChatWithSidebarModelConfig,
-  ChatWithSidebarProps,
-  ChatWithSidebarQuickActionsConfig,
-  ChatWithSidebarSidebarConfig,
-  ChatWithSidebarTabsConfig,
-  ChatWithSidebarVoiceConfig,
-  CodeBlockProps,
-  ConversationEmptyStateProps,
-  ConversationScrollButtonProps,
-  DropZoneOverlayProps,
-  FeedbackValue,
-  InferenceBadgeProps,
-  InlineCitationProps,
-  MessageActionsProps,
-  MessageEditFormProps,
-  MessageFeedbackProps,
-  ModelOption,
-  ModelSelectorProps,
-  PartGroup,
-  QuickAction,
-  QuickActionsProps,
-  SkillBadgeProps,
-  Source,
-  SourcesProps,
-  StepIndicatorProps,
-  SuggestionProps,
-  SuggestionsProps,
-  TabSwitcherProps,
-  Thread,
-  UpgradeCTAProps,
-  UploadedFile,
-  UploadsPanelProps,
-  UseThreadsOptions,
-  UseThreadsResult,
+  type UseThreadsOptions,
+  type UseThreadsResult,
 } from "../react/components/ai/chat.js";
 
-// Message (standalone bubble, not the chat compound)
 export {
   Message as StandaloneMessage,
+  type MessageProps,
   StreamingMessage,
-} from "../react/components/ai/message.js";
-export type {
-  MessageProps,
-  StreamingMessageProps,
+  type StreamingMessageProps,
 } from "../react/components/ai/message.js";
 
-export { AgentCard } from "../react/components/ai/agent-card.js";
-export type { AgentCardProps } from "../react/components/ai/agent-card.js";
-
+export { AgentCard, type AgentCardProps } from "../react/components/ai/agent-card.js";
 export {
   AIErrorBoundary,
+  type AIErrorBoundaryProps,
   useAIErrorHandler,
 } from "../react/components/ai/error-boundary.js";
-export type { AIErrorBoundaryProps } from "../react/components/ai/error-boundary.js";
-
-// Types only from theme
 export type { AgentTheme, ChatTheme } from "../react/components/ai/theme.js";
 
-// ---------------------------------------------------------------------------
-// Hooks (from agent/react)
-// ---------------------------------------------------------------------------
-
-export { useChat } from "../agent/react/use-chat/index.js";
-export type {
-  BranchInfo,
-  BrowserInferenceStatus,
-  DynamicToolUIPart,
-  InferenceMode,
-  OnToolCallArg,
-  ReasoningUIPart,
-  StepUIPart,
-  TextUIPart,
-  ToolOutput,
-  ToolResultUIPart,
-  ToolState,
-  ToolUIPart,
-  UIMessage,
-  UIMessagePart,
-  UseChatOptions,
-  UseChatResult,
+export {
+  type BranchInfo,
+  type BrowserInferenceStatus,
+  type DynamicToolUIPart,
+  type InferenceMode,
+  type OnToolCallArg,
+  type ReasoningUIPart,
+  type StepUIPart,
+  type TextUIPart,
+  type ToolOutput,
+  type ToolResultUIPart,
+  type ToolState,
+  type ToolUIPart,
+  type UIMessage,
+  type UIMessagePart,
+  useChat,
+  type UseChatOptions,
+  type UseChatResult,
 } from "../agent/react/use-chat/index.js";
 
-export { useAgent } from "../agent/react/use-agent.js";
-export type { UseAgentOptions, UseAgentResult } from "../agent/react/use-agent.js";
+export {
+  useAgent,
+  type UseAgentOptions,
+  type UseAgentResult,
+} from "../agent/react/use-agent.js";
 
-export { useCompletion } from "../agent/react/use-completion.js";
-export type {
-  UseCompletionOptions,
-  UseCompletionResult,
+export {
+  useCompletion,
+  type UseCompletionOptions,
+  type UseCompletionResult,
 } from "../agent/react/use-completion.js";
 
-export { useStreaming } from "../agent/react/use-streaming.js";
-export type {
-  UseStreamingOptions,
-  UseStreamingResult,
+export {
+  useStreaming,
+  type UseStreamingOptions,
+  type UseStreamingResult,
 } from "../agent/react/use-streaming.js";
 
-export { useVoiceInput } from "../agent/react/use-voice-input.js";
-export type {
-  UseVoiceInputOptions,
-  UseVoiceInputResult,
+export {
+  useVoiceInput,
+  type UseVoiceInputOptions,
+  type UseVoiceInputResult,
 } from "../agent/react/use-voice-input.js";

package/src/src/config/env.ts

@@ -14,6 +14,24 @@
 import { type EnvironmentConfig, getEnvironmentConfig } from "./environment-config.js";
 import { getEnv } from "../platform/compat/process.js";
 
+function toEnabledFlag<T extends string>(enabled: boolean, truthyValue: T): T | undefined {
+  return enabled ? truthyValue : undefined;
+}
+
+function toCliBooleanFlag(enabled: boolean): "1" | undefined {
+  return toEnabledFlag(enabled, "1");
+}
+
+function getBaseOtelConfig(env: EnvironmentConfig): {
+  veryfrontFlag?: string;
+  endpoint?: string;
+} {
+  return {
+    veryfrontFlag: toCliBooleanFlag(env.otelEnabled),
+    endpoint: env.otelEndpoint,
+  };
+}
+
 export function getDisableLruIntervalEnv(env: EnvironmentConfig = getEnvironmentConfig()): boolean {
   return env.disableLruInterval;
 }
@@ -108,13 +126,13 @@ export function isDenoTestingEnv(env: EnvironmentConfig = getEnvironmentConfig()
 }
 
 export function getNoColorEnv(env: EnvironmentConfig = getEnvironmentConfig()): string | undefined {
-  return env.noColor ? "1" : undefined;
+  return toCliBooleanFlag(env.noColor);
 }
 
 export function getForceColorEnv(
   env: EnvironmentConfig = getEnvironmentConfig(),
 ): string | undefined {
-  return env.forceColor ? "1" : undefined;
+  return toCliBooleanFlag(env.forceColor);
 }
 
 export function isRscExperimentalEnabled(env: EnvironmentConfig = getEnvironmentConfig()): boolean {
@@ -143,14 +161,10 @@ export function getOtelTracingConfig(env: EnvironmentConfig = getEnvironmentConf
   headers?: string;
   tracesHeaders?: string;
 } {
-  const enabledFlag = env.otelEnabled ? "true" : undefined;
-  const veryfrontFlag = env.otelEnabled ? "1" : undefined;
-
   return {
-    enabledFlag,
-    veryfrontFlag,
+    enabledFlag: toEnabledFlag(env.otelEnabled, "true"),
+    ...getBaseOtelConfig(env),
     serviceName: env.otelServiceName,
-    endpoint: env.otelEndpoint,
     tracesEndpoint: env.otelTracesEndpoint,
     exporter: env.otelTracesExporter,
     headers: env.otelHeaders,
@@ -166,9 +180,8 @@ export function getOtelMetricsConfig(env: EnvironmentConfig = getEnvironmentConf
   exporter?: string;
 } {
   return {
-    enabledFlag: env.otelMetricsEnabled ? "1" : undefined,
-    veryfrontFlag: env.otelEnabled ? "1" : undefined,
-    endpoint: env.otelEndpoint,
+    enabledFlag: toCliBooleanFlag(env.otelMetricsEnabled),
+    ...getBaseOtelConfig(env),
     metricsEndpoint: env.otelMetricsEndpoint,
     exporter: env.otelMetricsExporter,
   };

package/src/src/data/static-data-fetcher.ts

@@ -47,24 +47,27 @@ function releaseRevalidationSlot(projectId: string): void {
   projectRevalidationCounts.set(projectId, current - 1);
 }
 
-function getProjectId(context: DataContext, fallback: string): string {
+function resolveProjectId(context: DataContext, fallback: string): string {
   return context.request?.headers?.get("x-project-id") ?? context.url?.hostname ?? fallback;
 }
 
+type StaticDataHandler = NonNullable<PageWithData["getStaticData"]>;
+
 export class StaticDataFetcher {
   private pendingRevalidations = new Map<string, Promise<void>>();
 
   constructor(private cacheManager: CacheManager) {}
 
   async fetch(pageModule: PageWithData, context: DataContext): Promise<DataResult> {
-    if (typeof pageModule.getStaticData !== "function") return { props: {} };
+    const getStaticData = pageModule.getStaticData;
+    if (typeof getStaticData !== "function") return { props: {} };
 
     const pathname = context.url?.pathname ?? "unknown";
     const cacheKey = this.cacheManager.createCacheKey(context);
 
     // No caching in preview mode (cacheKey is null)
     if (!cacheKey) {
-      return withSpan("data.fetch_static", () => this.fetchFreshNoCache(pageModule, context), {
+      return withSpan("data.fetch_static", () => this.fetchFreshNoCache(getStaticData, context), {
         "data.fetch_method": "getStaticData",
         "data.pathname": pathname,
         "data.cache": "disabled",
@@ -78,33 +81,65 @@ export class StaticDataFetcher {
     );
 
     if (!cached) {
-      return withSpan("data.fetch_static", () => this.fetchFresh(pageModule, context, cacheKey), {
-        "data.fetch_method": "getStaticData",
-        "data.pathname": pathname,
-        "data.cache": "miss",
-      });
+      return withSpan(
+        "data.fetch_static",
+        () => this.fetchFresh(getStaticData, context, cacheKey),
+        {
+          "data.fetch_method": "getStaticData",
+          "data.pathname": pathname,
+          "data.cache": "miss",
+        },
+      );
     }
 
     if (this.cacheManager.shouldRevalidate(cached) && !this.pendingRevalidations.has(cacheKey)) {
       this.pendingRevalidations.set(
         cacheKey,
-        this.revalidateInBackground(pageModule, context, cacheKey),
+        this.revalidateInBackground(getStaticData, context, cacheKey),
       );
     }
 
     return cached.data;
   }
 
+  private createStaticDataContext(
+    context: DataContext,
+  ): Omit<DataContext, "request" | "query"> {
+    return { params: context.params, url: context.url };
+  }
+
+  private executeStaticData(
+    getStaticData: StaticDataHandler,
+    context: DataContext,
+    timeoutMs: number,
+    label: string,
+  ): Promise<DataResult> {
+    return withTimeoutThrow(
+      Promise.resolve(getStaticData(this.createStaticDataContext(context))),
+      timeoutMs,
+      label,
+    );
+  }
+
+  private storeCacheEntry(cacheKey: string, result: DataResult): void {
+    this.cacheManager.set(cacheKey, {
+      data: result,
+      timestamp: Date.now(),
+      revalidate: result.revalidate,
+    });
+  }
+
   private async fetchFreshNoCache(
-    pageModule: PageWithData,
+    getStaticData: StaticDataHandler,
     context: DataContext,
   ): Promise<DataResult> {
     const pathname = context.url?.pathname ?? "unknown";
     const start = performance.now();
 
     try {
-      return await withTimeoutThrow(
-        Promise.resolve(pageModule.getStaticData!({ params: context.params, url: context.url })),
+      return await this.executeStaticData(
+        getStaticData,
+        context,
         DATA_FETCH_TIMEOUT_MS,
         `getStaticData for ${pathname}`,
       );
@@ -126,13 +161,13 @@ export class StaticDataFetcher {
   }
 
   private async fetchFresh(
-    pageModule: PageWithData,
+    getStaticData: StaticDataHandler,
     context: DataContext,
     cacheKey: string,
   ): Promise<DataResult> {
     const pathname = context.url?.pathname ?? "unknown";
     // Extract projectId from request headers (set by proxy) for proper circuit breaker isolation
-    const projectId = getProjectId(context, "default");
+    const projectId = resolveProjectId(context, "default");
     const start = performance.now();
 
     // Circuit breaker per project to prevent cascade failures
@@ -144,8 +179,9 @@ export class StaticDataFetcher {
 
     try {
       const result = await circuitBreaker.execute(() =>
-        withTimeoutThrow(
-          Promise.resolve(pageModule.getStaticData!({ params: context.params, url: context.url })),
+        this.executeStaticData(
+          getStaticData,
+          context,
           DATA_FETCH_TIMEOUT_MS,
           `getStaticData for ${pathname}`,
         )
@@ -154,11 +190,7 @@ export class StaticDataFetcher {
       await withSpan(
         SpanNames.DATA_CACHE_SET,
         () => {
-          this.cacheManager.set(cacheKey, {
-            data: result,
-            timestamp: Date.now(),
-            revalidate: result.revalidate,
-          });
+          this.storeCacheEntry(cacheKey, result);
           return Promise.resolve();
         },
         { "data.cache_key": cacheKey, "data.revalidate": result.revalidate ?? 0 },
@@ -198,15 +230,13 @@ export class StaticDataFetcher {
   }
 
   private async revalidateInBackground(
-    pageModule: PageWithData,
+    getStaticData: StaticDataHandler,
     context: DataContext,
     cacheKey: string,
   ): Promise<void> {
-    if (typeof pageModule.getStaticData !== "function") return;
-
     const pathname = context.url?.pathname ?? "unknown";
     // Use projectId from request headers for proper per-project fairness
-    const projectId = getProjectId(context, "unknown");
+    const projectId = resolveProjectId(context, "unknown");
 
     // Check per-project limit before acquiring global semaphore
     if (!acquireRevalidationSlot(projectId)) {
@@ -225,19 +255,14 @@ export class StaticDataFetcher {
         const start = performance.now();
 
         try {
-          const result = await withTimeoutThrow(
-            Promise.resolve(
-              pageModule.getStaticData!({ params: context.params, url: context.url }),
-            ),
+          const result = await this.executeStaticData(
+            getStaticData,
+            context,
             REVALIDATION_TIMEOUT_MS,
             `getStaticData revalidation for ${pathname}`,
           );
 
-          this.cacheManager.set(cacheKey, {
-            data: result,
-            timestamp: Date.now(),
-            revalidate: result.revalidate,
-          });
+          this.storeCacheEntry(cacheKey, result);
         } catch (error) {
           const durationMs = Math.round(performance.now() - start);
 

package/src/src/data/static-paths-fetcher.ts

@@ -4,6 +4,8 @@ import { withSpan } from "../observability/tracing/otlp-setup.js";
 import { SpanNames } from "../observability/tracing/span-names.js";
 import type { Span } from "@opentelemetry/api";
 
+const EMPTY_STATIC_PATHS_RESULT: StaticPathsResult = { paths: [], fallback: false };
+
 export class StaticPathsFetcher {
   fetch(pageModule: PageWithData): Promise<StaticPathsResult | null> {
     const getStaticPaths = pageModule.getStaticPaths;
@@ -16,14 +18,14 @@ export class StaticPathsFetcher {
       async (span?: Span) => {
         try {
           const result = await getStaticPaths();
-          const finalResult = result ?? { paths: [], fallback: false };
+          const finalResult = result ?? EMPTY_STATIC_PATHS_RESULT;
 
           span?.setAttribute("data.paths_count", finalResult.paths?.length ?? 0);
           span?.setAttribute("data.fallback", String(finalResult.fallback ?? false));
 
           return finalResult;
         } catch (error) {
-          serverLogger.error("Error in getStaticPaths:", error);
+          serverLogger.error("DATA_FETCH_STATIC_PATHS_ERROR getStaticPaths failed", {}, error);
           throw error;
         }
       },