@chat-js/cli 0.1.4 → 0.2.1

package/templates/chat-app/lib/config-schema.ts

@@ -3,6 +3,7 @@ import type {
   GatewayImageModelIdMap,
   GatewayModelIdMap,
   GatewayType,
+  GatewayVideoModelIdMap,
 } from "@/lib/ai/gateways/registry";
 import type { ToolName } from "./ai/types";
 
@@ -12,7 +13,7 @@ const DEFAULT_GATEWAY = "vercel" as const satisfies GatewayType;
 const toolName = () => z.custom<ToolName>();
 
 // =====================================================
-// Models config — discriminated union keyed on gateway
+// AI config — discriminated union keyed on gateway
 // =====================================================
 
 function gatewayModelId<G extends GatewayType>() {
@@ -23,7 +24,37 @@ function gatewayImageModelId<G extends GatewayType>() {
   return z.custom<GatewayImageModelIdMap[G]>((v) => typeof v === "string");
 }
 
-function createModelsSchema<G extends GatewayType>(g: G) {
+function gatewayVideoModelId<G extends GatewayType>() {
+  return z.custom<GatewayVideoModelIdMap[G]>((v) => typeof v === "string");
+}
+
+const deepResearchToolConfigSchema = z.object({
+  defaultModel: z.string(),
+  finalReportModel: z.string(),
+  allowClarification: z
+    .boolean()
+    .describe("Whether to ask clarifying questions before starting research"),
+  maxResearcherIterations: z
+    .number()
+    .int()
+    .min(1)
+    .max(10)
+    .describe("Maximum supervisor loop iterations"),
+  maxConcurrentResearchUnits: z
+    .number()
+    .int()
+    .min(1)
+    .max(20)
+    .describe("Topics researched in parallel per iteration"),
+  maxSearchQueries: z
+    .number()
+    .int()
+    .min(1)
+    .max(10)
+    .describe("Max search queries per research topic"),
+});
+
+function createAiSchema<G extends GatewayType>(g: G) {
   return z.object({
     gateway: z.literal(g),
     providerOrder: z
@@ -38,39 +69,71 @@ function createModelsSchema<G extends GatewayType>(g: G) {
     anonymousModels: z
       .array(gatewayModelId<G>())
       .describe("Models available to anonymous users"),
-    defaults: z
+    workflows: z
       .object({
         chat: gatewayModelId<G>(),
         title: gatewayModelId<G>(),
         pdf: gatewayModelId<G>(),
-        artifact: gatewayModelId<G>(),
-        artifactSuggestion: gatewayModelId<G>(),
-        followupSuggestions: gatewayModelId<G>(),
-        suggestions: gatewayModelId<G>(),
-        polishText: gatewayModelId<G>(),
-        formatSheet: gatewayModelId<G>(),
-        analyzeSheet: gatewayModelId<G>(),
-        codeEdits: gatewayModelId<G>(),
         chatImageCompatible: gatewayModelId<G>(),
-        image: gatewayImageModelId<G>(),
-        deepResearch: gatewayModelId<G>(),
-        deepResearchFinalReport: gatewayModelId<G>(),
       })
-      .describe("Default model for each task type"),
+      .describe("Default model for shared app workflows"),
+    tools: z
+      .object({
+        webSearch: z.object({
+          enabled: z.boolean(),
+        }),
+        urlRetrieval: z.object({
+          enabled: z.boolean(),
+        }),
+        codeExecution: z.object({
+          enabled: z.boolean(),
+        }),
+        mcp: z.object({
+          enabled: z.boolean(),
+        }),
+        followupSuggestions: z.object({
+          enabled: z.boolean(),
+          default: gatewayModelId<G>(),
+        }),
+        text: z.object({
+          polish: gatewayModelId<G>(),
+        }),
+        sheet: z.object({
+          format: gatewayModelId<G>(),
+          analyze: gatewayModelId<G>(),
+        }),
+        code: z.object({
+          edits: gatewayModelId<G>(),
+        }),
+        image: z.object({
+          enabled: z.boolean(),
+          default: gatewayImageModelId<G>(),
+        }),
+        video: z.object({
+          enabled: z.boolean(),
+          default: gatewayVideoModelId<G>(),
+        }),
+        deepResearch: deepResearchToolConfigSchema.extend({
+          enabled: z.boolean(),
+          defaultModel: gatewayModelId<G>(),
+          finalReportModel: gatewayModelId<G>(),
+        }),
+      })
+      .describe("Default model and runtime configuration grouped by tool"),
   });
 }
 
 // Record ensures a compile error if a new gateway is added but not here.
 const gatewaySchemaMap: {
-  [G in GatewayType]: ReturnType<typeof createModelsSchema<G>>;
+  [G in GatewayType]: ReturnType<typeof createAiSchema<G>>;
 } = {
-  vercel: createModelsSchema("vercel"),
-  openrouter: createModelsSchema("openrouter"),
-  openai: createModelsSchema("openai"),
-  "openai-compatible": createModelsSchema("openai-compatible"),
+  vercel: createAiSchema("vercel"),
+  openrouter: createAiSchema("openrouter"),
+  openai: createAiSchema("openai"),
+  "openai-compatible": createAiSchema("openai-compatible"),
 };
 
-export const modelsConfigSchema = z
+export const aiConfigSchema = z
   .discriminatedUnion("gateway", [
     gatewaySchemaMap.vercel,
     gatewaySchemaMap.openrouter,
@@ -99,22 +162,56 @@ export const modelsConfigSchema = z
       "xai/grok-4",
     ],
     anonymousModels: ["google/gemini-2.5-flash-lite", "openai/gpt-5-nano"],
-    defaults: {
+    workflows: {
       chat: "openai/gpt-5-mini",
       title: "openai/gpt-5-nano",
       pdf: "openai/gpt-5-mini",
-      artifact: "openai/gpt-5-nano",
-      artifactSuggestion: "openai/gpt-5-mini",
-      followupSuggestions: "google/gemini-2.5-flash-lite",
-      suggestions: "openai/gpt-5-mini",
-      polishText: "openai/gpt-5-mini",
-      formatSheet: "openai/gpt-5-mini",
-      analyzeSheet: "openai/gpt-5-mini",
-      codeEdits: "openai/gpt-5-mini",
       chatImageCompatible: "openai/gpt-4o-mini",
-      image: "google/gemini-3-pro-image",
-      deepResearch: "google/gemini-2.5-flash-lite",
-      deepResearchFinalReport: "google/gemini-3-flash",
+    },
+    tools: {
+      webSearch: {
+        enabled: false,
+      },
+      urlRetrieval: {
+        enabled: false,
+      },
+      codeExecution: {
+        enabled: false,
+      },
+      mcp: {
+        enabled: false,
+      },
+      followupSuggestions: {
+        enabled: false,
+        default: "google/gemini-2.5-flash-lite",
+      },
+      text: {
+        polish: "openai/gpt-5-mini",
+      },
+      sheet: {
+        format: "openai/gpt-5-mini",
+        analyze: "openai/gpt-5-mini",
+      },
+      code: {
+        edits: "openai/gpt-5-mini",
+      },
+      image: {
+        enabled: false,
+        default: "google/gemini-3-pro-image",
+      },
+      video: {
+        enabled: false,
+        default: "xai/grok-imagine-video",
+      },
+      deepResearch: {
+        enabled: false,
+        defaultModel: "google/gemini-2.5-flash-lite",
+        finalReportModel: "google/gemini-3-flash",
+        allowClarification: true,
+        maxResearcherIterations: 1,
+        maxConcurrentResearchUnits: 2,
+        maxSearchQueries: 2,
+      },
     },
   });
 
@@ -179,67 +276,14 @@ export const attachmentsConfigSchema = z
     },
   });
 
-export const deepResearchConfigSchema = z
-  .object({
-    allowClarification: z
-      .boolean()
-      .describe("Whether to ask clarifying questions before starting research"),
-    maxResearcherIterations: z
-      .number()
-      .int()
-      .min(1)
-      .max(10)
-      .describe("Maximum supervisor loop iterations"),
-    maxConcurrentResearchUnits: z
-      .number()
-      .int()
-      .min(1)
-      .max(20)
-      .describe("Topics researched in parallel per iteration"),
-    maxSearchQueries: z
-      .number()
-      .int()
-      .min(1)
-      .max(10)
-      .describe("Max search queries per research topic"),
-  })
-  .default({
-    allowClarification: true,
-    maxResearcherIterations: 1,
-    maxConcurrentResearchUnits: 2,
-    maxSearchQueries: 2,
-  });
-
 export const featuresConfigSchema = z
   .object({
-    sandbox: z.boolean().describe("Code sandbox execution (Vercel-native)"),
-    webSearch: z.boolean().describe("Web search (requires TAVILY_API_KEY)"),
-    urlRetrieval: z
-      .boolean()
-      .describe("URL content retrieval (requires FIRECRAWL_API_KEY)"),
-    deepResearch: z
-      .boolean()
-      .describe("Deep research agent (requires webSearch)"),
-    mcp: z.boolean().describe("MCP tool servers (requires MCP_ENCRYPTION_KEY)"),
-    imageGeneration: z
-      .boolean()
-      .describe("AI image generation (requires BLOB_READ_WRITE_TOKEN)"),
     attachments: z
       .boolean()
       .describe("File attachments (requires BLOB_READ_WRITE_TOKEN)"),
-    followupSuggestions: z
-      .boolean()
-      .describe("Follow-up question suggestions after AI responses"),
   })
   .default({
-    sandbox: false,
-    webSearch: false,
-    urlRetrieval: false,
-    deepResearch: false,
-    mcp: false,
-    imageGeneration: false,
     attachments: false,
-    followupSuggestions: false,
   });
 
 export const authenticationConfigSchema = z
@@ -334,22 +378,19 @@ export const configSchema = z.object({
 
   authentication: authenticationConfigSchema,
 
-  models: modelsConfigSchema,
+  ai: aiConfigSchema,
 
   anonymous: anonymousConfigSchema,
 
   attachments: attachmentsConfigSchema,
-
-  deepResearch: deepResearchConfigSchema,
 });
 
 // Output types (after defaults applied)
 export type Config = z.infer<typeof configSchema>;
 export type PricingConfig = z.infer<typeof pricingConfigSchema>;
-export type ModelsConfig = z.infer<typeof modelsConfigSchema>;
+export type AiConfig = z.infer<typeof aiConfigSchema>;
 export type AnonymousConfig = z.infer<typeof anonymousConfigSchema>;
 export type AttachmentsConfig = z.infer<typeof attachmentsConfigSchema>;
-export type DeepResearchConfig = z.infer<typeof deepResearchConfigSchema>;
 export type FeaturesConfig = z.infer<typeof featuresConfigSchema>;
 export type AuthenticationConfig = z.infer<typeof authenticationConfigSchema>;
 
@@ -357,27 +398,72 @@ export type AuthenticationConfig = z.infer<typeof authenticationConfigSchema>;
 type ZodConfigInput = z.input<typeof configSchema>;
 
 // Use vercel variant as shape reference (all variants share the same structure)
-type ModelsShape = z.input<typeof gatewaySchemaMap.vercel>;
+type AiShape = z.input<typeof gatewaySchemaMap.vercel>;
+type AiToolsShape = AiShape["tools"];
+type DeepResearchToolInputFor<G extends GatewayType> = Omit<
+  AiToolsShape["deepResearch"],
+  "defaultModel" | "finalReportModel"
+> & {
+  defaultModel: GatewayModelIdMap[G];
+  finalReportModel: GatewayModelIdMap[G];
+};
+type ImageToolInputFor<G extends GatewayType> = Omit<
+  AiToolsShape["image"],
+  "default"
+> & {
+  default: GatewayImageModelIdMap[G];
+};
+type VideoToolInputFor<G extends GatewayType> = Omit<
+  AiToolsShape["video"],
+  "default"
+> & {
+  default: GatewayVideoModelIdMap[G];
+};
+type FollowupSuggestionsToolInputFor<G extends GatewayType> = Omit<
+  AiToolsShape["followupSuggestions"],
+  "default"
+> & {
+  default: GatewayModelIdMap[G];
+};
+interface AiToolsInputFor<G extends GatewayType> {
+  code: {
+    [P in keyof AiToolsShape["code"]]: GatewayModelIdMap[G];
+  };
+  codeExecution: AiToolsShape["codeExecution"];
+  deepResearch: DeepResearchToolInputFor<G>;
+  followupSuggestions: FollowupSuggestionsToolInputFor<G>;
+  image: ImageToolInputFor<G>;
+  mcp: AiToolsShape["mcp"];
+  sheet: {
+    [P in keyof AiToolsShape["sheet"]]: GatewayModelIdMap[G];
+  };
+  text: {
+    [P in keyof AiToolsShape["text"]]: GatewayModelIdMap[G];
+  };
+  urlRetrieval: AiToolsShape["urlRetrieval"];
+  video: VideoToolInputFor<G>;
+  webSearch: AiToolsShape["webSearch"];
+}
 
-type ModelsInputFor<G extends GatewayType> = {
-  [K in keyof ModelsShape]: K extends "gateway"
+type AiInputFor<G extends GatewayType> = {
+  [K in keyof AiShape]: K extends "gateway"
     ? G
-    : K extends "defaults"
+    : K extends "workflows"
       ? {
-          [D in keyof ModelsShape["defaults"]]: D extends "image"
-            ? GatewayImageModelIdMap[G]
-            : GatewayModelIdMap[G];
+          [W in keyof AiShape["workflows"]]: GatewayModelIdMap[G];
         }
-      : K extends "disabledModels" | "curatedDefaults" | "anonymousModels"
-        ? GatewayModelIdMap[G][]
-        : ModelsShape[K];
+      : K extends "tools"
+        ? AiToolsInputFor<G>
+        : K extends "disabledModels" | "curatedDefaults" | "anonymousModels"
+          ? GatewayModelIdMap[G][]
+          : AiShape[K];
 };
 
 type ConfigInputForGateway<G extends GatewayType> = Omit<
   ZodConfigInput,
-  "models"
+  "ai"
 > & {
-  models?: ModelsInputFor<G>;
+  ai?: AiInputFor<G>;
 };
 
 export type ConfigInput = {

package/templates/chat-app/lib/config.ts

@@ -1,11 +1,11 @@
 import userConfig from "@/chat.config";
 import type { ActiveGatewayType } from "./ai/app-model-id";
-import { type Config, configSchema, type ModelsConfig } from "./config-schema";
+import { type AiConfig, type Config, configSchema } from "./config-schema";
 
-type ActiveModelsConfig = Extract<ModelsConfig, { gateway: ActiveGatewayType }>;
+type ActiveAiConfig = Extract<AiConfig, { gateway: ActiveGatewayType }>;
 
-/** Config with the `models` field narrowed to the active gateway. */
-type ActiveConfig = Omit<Config, "models"> & { models: ActiveModelsConfig };
+/** Config with the `ai` field narrowed to the active gateway. */
+type ActiveConfig = Omit<Config, "ai"> & { ai: ActiveAiConfig };
 
 /**
  * Parsed configuration with defaults applied.

package/templates/chat-app/lib/credits/cost-accumulator.ts

@@ -2,7 +2,10 @@ import type { AppModelDefinition, AppModelId } from "../ai/app-models";
 import { getAppModelDefinition } from "../ai/app-models";
 
 /** Minimal usage info needed for cost calculation */
-export type UsageInfo = { inputTokens?: number; outputTokens?: number };
+export interface UsageInfo {
+  inputTokens?: number;
+  outputTokens?: number;
+}
 
 /**
  * Calculate LLM cost in CENTS from AI SDK usage data and model pricing.
@@ -18,18 +21,18 @@ function calculateLLMCost(
   return (inputCost + outputCost) * 100;
 }
 
-type LLMCostEntry = {
-  type: "llm";
+interface LLMCostEntry {
   modelId: AppModelId;
-  usage: UsageInfo;
   source: string;
-};
+  type: "llm";
+  usage: UsageInfo;
+}
 
-type APICostEntry = {
-  type: "api";
+interface APICostEntry {
   apiName: string;
   cost: number;
-};
+  type: "api";
+}
 
 type CostEntry = LLMCostEntry | APICostEntry;
 

package/templates/chat-app/lib/env-schema.ts

@@ -44,7 +44,7 @@ export const serverEnvSchema = {
     .optional()
     .describe("Vercel OAuth integration client secret"),
 
-  // AI Gateway keys (one required depending on config.models.gateway)
+  // AI Gateway keys (one required depending on config.ai.gateway)
   AI_GATEWAY_API_KEY: z
     .string()
     .optional()

package/templates/chat-app/lib/features-config.ts

@@ -1,14 +1,14 @@
 import type { LucideIcon } from "lucide-react";
 import { Brain, Eye, FileText, Image, Mic, Zap } from "lucide-react";
 
-type FeatureConfig = {
-  key: string;
-  name: string;
+interface FeatureConfig {
+  category: "capability" | "input" | "output";
   description: string;
-  icon: LucideIcon;
   enabled: boolean;
-  category: "capability" | "input" | "output";
-};
+  icon: LucideIcon;
+  key: string;
+  name: string;
+}
 
 export const AVAILABLE_FEATURES: Record<string, FeatureConfig> = {
   reasoning: {

package/templates/chat-app/lib/stores/with-threads.ts

@@ -14,10 +14,10 @@ import {
   findLeafDfsToRightFromMessageId,
 } from "@/lib/thread-utils";
 
-export type MessageSiblingInfo<UM> = {
-  siblings: UM[];
+export interface MessageSiblingInfo<UM> {
   siblingIndex: number;
-};
+  siblings: UM[];
+}
 
 export type ThreadAugmentedState<UM extends UIMessage> =
   BaseChatStoreState<UM> & {

package/templates/chat-app/lib/thread-utils.ts

@@ -1,11 +1,11 @@
 // Generic message type that works for both DB and anonymous messages
-export type MessageNode = {
+export interface MessageNode {
   id: string;
   metadata?: {
     parentMessageId: string | null;
     createdAt: Date;
   };
-};
+}
 
 /** Safely extract a numeric timestamp from a Date object or ISO string. */
 function toTimestamp(value: Date | string | undefined | null): number {

package/templates/chat-app/lib/types/anonymous.ts

@@ -1,17 +1,17 @@
 import type { ToolName } from "../ai/types";
 import { config } from "../config";
 
-export type AnonymousSession = {
+export interface AnonymousSession {
+  createdAt: Date;
   id: string;
   remainingCredits: number;
-  createdAt: Date;
-};
+}
 
 const anonConfig = config.anonymous;
 
 export const ANONYMOUS_LIMITS = {
   CREDITS: anonConfig.credits,
-  AVAILABLE_MODELS: config.models.anonymousModels,
+  AVAILABLE_MODELS: config.ai.anonymousModels,
   AVAILABLE_TOOLS: anonConfig.availableTools as ToolName[],
   SESSION_DURATION: 2_147_483_647, // Max session time
   RATE_LIMIT: {

package/templates/chat-app/lib/types/ui-chat.ts

@@ -1,10 +1,10 @@
-export type UIChat = {
-  id: string;
+export interface UIChat {
   createdAt: Date;
-  updatedAt: Date;
-  title: string;
-  visibility: "private" | "public";
-  userId: string;
+  id: string;
   isPinned: boolean;
   projectId: string | null;
-};
+  title: string;
+  updatedAt: Date;
+  userId: string;
+  visibility: "private" | "public";
+}

package/templates/chat-app/lib/utils/download-assets.ts

@@ -8,10 +8,10 @@ import type {
 
 // Minimal utilities to download assets from URL-based parts and inline them.
 
-type DownloadResult = {
-  mediaType: string | undefined;
+interface DownloadResult {
   data: Uint8Array;
-};
+  mediaType: string | undefined;
+}
 
 export type DownloadImplementation = (args: {
   url: URL;

package/templates/chat-app/lib/utils/rate-limit.ts

@@ -2,20 +2,20 @@ import "server-only";
 import { config } from "@/lib/config";
 import { ANONYMOUS_LIMITS } from "@/lib/types/anonymous";
 
-type RateLimitResult = {
-  success: boolean;
+interface RateLimitResult {
+  error?: string;
   remaining: number;
   resetTime: number;
-  error?: string;
-};
+  success: boolean;
+}
 
-type RateLimitOptions = {
+interface RateLimitOptions {
   identifier: string;
+  keyPrefix: string;
   limit: number;
-  windowSize: number;
   redisClient: any;
-  keyPrefix: string;
-};
+  windowSize: number;
+}
 
 async function checkRateLimit({
   identifier,

package/templates/chat-app/next.config.ts

@@ -1,11 +1,8 @@
 import type { NextConfig } from "next";
 
-const MODEL_REGISTRY_URL = "airegistry.app";
-
 const nextConfig: NextConfig = {
   typedRoutes: true,
   cacheComponents: true,
-
   experimental: {
     optimizePackageImports: [
       "react-tweet",
@@ -36,28 +33,6 @@ const nextConfig: NextConfig = {
       },
     ],
   },
-  redirects: async () => [
-    {
-      source: "/models",
-      destination: `https://${MODEL_REGISTRY_URL}`,
-      permanent: true,
-    },
-    {
-      source: "/models/:path*",
-      destination: `https://${MODEL_REGISTRY_URL}/models/:path*`,
-      permanent: true,
-    },
-    {
-      source: "/compare",
-      destination: `https://${MODEL_REGISTRY_URL}/compare`,
-      permanent: true,
-    },
-    {
-      source: "/compare/:path*",
-      destination: `https://${MODEL_REGISTRY_URL}/compare/:path*`,
-      permanent: true,
-    },
-  ],
 };
 
 export default nextConfig;