@chat-js/cli 0.2.1 → 0.4.0

package/templates/chat-app/lib/ai/tools/generate-image.ts

@@ -41,6 +41,9 @@ async function resolveImageModel(selectedModel?: string): Promise<{
   }
 
   // Fall back to the configured default image model
+  if (!config.ai.tools.image.enabled) {
+    throw new Error("Image generation is not enabled");
+  }
   const defaultId = config.ai.tools.image.default;
   try {
     const model = await getAppModelDefinition(defaultId as AppModelId);
@@ -134,6 +137,10 @@ async function runGenerateImageTraditional({
   startMs: number;
   costAccumulator?: CostAccumulator;
 }): Promise<{ imageUrl: string; prompt: string }> {
+  if (!config.ai.tools.image.enabled) {
+    throw new Error("Image generation is not enabled");
+  }
+  const imageDefault = config.ai.tools.image.default;
   let promptInput:
     | string
     | {
@@ -161,7 +168,7 @@ async function runGenerateImageTraditional({
   }
 
   const res = await generateImage({
-    model: getImageModel(config.ai.tools.image.default),
+    model: getImageModel(imageDefault),
     prompt: promptInput,
     n: 1,
     providerOptions: {
@@ -184,7 +191,7 @@ async function runGenerateImageTraditional({
 
   if (res.usage) {
     costAccumulator?.addLLMCost(
-      config.ai.tools.image.default as AppModelId,
+      imageDefault as AppModelId,
       {
         inputTokens: res.usage.inputTokens,
         outputTokens: res.usage.outputTokens,

package/templates/chat-app/lib/ai/tools/generate-video.ts

@@ -48,6 +48,9 @@ async function resolveVideoModel(selectedModel?: string): Promise<string> {
       // Not in app models registry, fall through
     }
   }
+  if (!config.ai.tools.video.enabled) {
+    throw new Error("Video generation is not enabled");
+  }
   return config.ai.tools.video.default;
 }
 

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

@@ -59,10 +59,83 @@ const frontendToolsSchema = z.enum([
 const __ = frontendToolsSchema.options satisfies ToolNameInternal[];
 
 export type UiToolName = z.infer<typeof frontendToolsSchema>;
+
+export type SelectedModelCounts = Partial<Record<AppModelId, number>>;
+export type SelectedModelValue = AppModelId | SelectedModelCounts;
+
+export function isSelectedModelCounts(
+  value: unknown
+): value is SelectedModelCounts {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+
+  if (Object.keys(value).length === 0) {
+    return false;
+  }
+
+  return Object.entries(value).every(
+    ([modelId, count]) =>
+      typeof modelId === "string" &&
+      typeof count === "number" &&
+      Number.isInteger(count) &&
+      count > 0
+  );
+}
+
+export function isSelectedModelValue(
+  value: unknown
+): value is SelectedModelValue {
+  return typeof value === "string" || isSelectedModelCounts(value);
+}
+
+export function getPrimarySelectedModelId(
+  selectedModel: SelectedModelValue | null | undefined
+): AppModelId | null {
+  if (!selectedModel) {
+    return null;
+  }
+
+  if (typeof selectedModel === "string") {
+    return selectedModel;
+  }
+
+  const [firstSelectedModelId] = Object.entries(selectedModel).find(
+    ([, count]) => typeof count === "number" && count > 0
+  ) ?? [null];
+
+  return firstSelectedModelId as AppModelId | null;
+}
+
+export function expandSelectedModelValue(
+  selectedModel: SelectedModelValue
+): AppModelId[] {
+  if (typeof selectedModel === "string") {
+    return [selectedModel];
+  }
+
+  const expanded: AppModelId[] = [];
+
+  for (const [modelId, count] of Object.entries(selectedModel)) {
+    if (!(typeof count === "number" && Number.isInteger(count) && count > 0)) {
+      continue;
+    }
+
+    for (let index = 0; index < count; index += 1) {
+      expanded.push(modelId as AppModelId);
+    }
+  }
+
+  return expanded;
+}
+
 const messageMetadataSchema = z.object({
   createdAt: z.date(),
   parentMessageId: z.string().nullable(),
-  selectedModel: z.custom<AppModelId>((val) => typeof val === "string"),
+  parallelGroupId: z.string().nullable().optional(),
+  parallelIndex: z.number().int().nullable().optional(),
+  isPrimaryParallel: z.boolean().nullable().optional(),
+  selectedModel: z.custom<SelectedModelValue>(isSelectedModelValue),
   activeStreamId: z.string().nullable(),
   selectedTool: frontendToolsSchema.optional(),
   usage: z.custom<LanguageModelUsage | undefined>((_val) => true).optional(),
@@ -101,7 +174,6 @@ type webSearchTool = InferUITool<ReturnType<typeof tavilyWebSearch>>;
 type codeExecutionTool = InferUITool<ReturnType<typeof codeExecution>>;
 type retrieveUrlTool = InferUITool<typeof retrieveUrl>;
 
-// biome-ignore lint/style/useConsistentTypeDefinitions: <explanation>
 export type ChatTools = {
   codeExecution: codeExecutionTool;
   createCodeDocument: createCodeDocumentToolType;
@@ -123,7 +195,6 @@ interface FollowupSuggestions {
   suggestions: string[];
 }
 
-// biome-ignore lint/style/useConsistentTypeDefinitions: <explanation>
 export type CustomUIDataTypes = {
   appendMessage: string;
   chatConfirmed: {

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

@@ -5,6 +5,7 @@ import type {
   GatewayType,
   GatewayVideoModelIdMap,
 } from "@/lib/ai/gateways/registry";
+import { GATEWAY_MODEL_DEFAULTS } from "./ai/gateway-model-defaults";
 import type { ToolName } from "./ai/types";
 
 const DEFAULT_GATEWAY = "vercel" as const satisfies GatewayType;
@@ -105,14 +106,26 @@ function createAiSchema<G extends GatewayType>(g: 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>(),
-        }),
+        image: z.discriminatedUnion("enabled", [
+          z.object({
+            enabled: z.literal(true),
+            default: gatewayImageModelId<G>(),
+          }),
+          z.object({
+            enabled: z.literal(false),
+            default: gatewayImageModelId<G>().optional(),
+          }),
+        ]),
+        video: z.discriminatedUnion("enabled", [
+          z.object({
+            enabled: z.literal(true),
+            default: gatewayVideoModelId<G>(),
+          }),
+          z.object({
+            enabled: z.literal(false),
+            default: gatewayVideoModelId<G>().optional(),
+          }),
+        ]),
         deepResearch: deepResearchToolConfigSchema.extend({
           enabled: z.boolean(),
           defaultModel: gatewayModelId<G>(),
@@ -142,77 +155,7 @@ export const aiConfigSchema = z
   ])
   .default({
     gateway: DEFAULT_GATEWAY,
-    providerOrder: ["openai", "google", "anthropic"],
-    disabledModels: [],
-    curatedDefaults: [
-      // OpenAI
-      "openai/gpt-5-nano",
-      "openai/gpt-5-mini",
-      "openai/gpt-5.2",
-      "openai/gpt-5.2-chat",
-
-      // Google
-      "google/gemini-2.5-flash-lite",
-      "google/gemini-3-flash",
-      "google/gemini-3-pro-preview",
-      // Anthropic
-      "anthropic/claude-sonnet-4.5",
-      "anthropic/claude-opus-4.5",
-      // xAI
-      "xai/grok-4",
-    ],
-    anonymousModels: ["google/gemini-2.5-flash-lite", "openai/gpt-5-nano"],
-    workflows: {
-      chat: "openai/gpt-5-mini",
-      title: "openai/gpt-5-nano",
-      pdf: "openai/gpt-5-mini",
-      chatImageCompatible: "openai/gpt-4o-mini",
-    },
-    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,
-      },
-    },
+    ...GATEWAY_MODEL_DEFAULTS[DEFAULT_GATEWAY],
   });
 
 export const pricingConfigSchema = z.object({
@@ -281,9 +224,14 @@ export const featuresConfigSchema = z
     attachments: z
       .boolean()
       .describe("File attachments (requires BLOB_READ_WRITE_TOKEN)"),
+    parallelResponses: z
+      .boolean()
+      .default(true)
+      .describe("Send one message to multiple models simultaneously"),
   })
   .default({
     attachments: false,
+    parallelResponses: true,
   });
 
 export const authenticationConfigSchema = z
@@ -400,63 +348,58 @@ type ZodConfigInput = z.input<typeof configSchema>;
 // Use vercel variant as shape reference (all variants share the same structure)
 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"
-> & {
+
+// All helper types are Partial — fields not provided are filled by applyDefaults
+type DeepResearchToolInputFor<G extends GatewayType> = Partial<
+  Omit<AiToolsShape["deepResearch"], "defaultModel" | "finalReportModel"> & {
+    defaultModel: GatewayModelIdMap[G];
+    finalReportModel: GatewayModelIdMap[G];
+  }
+>;
+type ImageToolInputFor<G extends GatewayType> = [
+  GatewayImageModelIdMap[G],
+] extends [never]
+  ? { enabled?: false }
+  :
+      | { enabled: true; default: GatewayImageModelIdMap[G] }
+      | { enabled?: false; default?: GatewayImageModelIdMap[G] };
+type VideoToolInputFor<G extends GatewayType> = [
+  GatewayVideoModelIdMap[G],
+] extends [never]
+  ? { enabled?: false }
+  :
+      | { enabled: true; default: GatewayVideoModelIdMap[G] }
+      | { enabled?: false; default?: GatewayVideoModelIdMap[G] };
+type FollowupSuggestionsToolInputFor<G extends GatewayType> = Partial<{
+  enabled: boolean;
   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"];
+  code?: Partial<{ [P in keyof AiToolsShape["code"]]: GatewayModelIdMap[G] }>;
+  codeExecution?: Partial<AiToolsShape["codeExecution"]>;
+  deepResearch?: DeepResearchToolInputFor<G>;
+  followupSuggestions?: FollowupSuggestionsToolInputFor<G>;
+  image?: ImageToolInputFor<G>;
+  mcp?: Partial<AiToolsShape["mcp"]>;
+  sheet?: Partial<{ [P in keyof AiToolsShape["sheet"]]: GatewayModelIdMap[G] }>;
+  text?: Partial<{ [P in keyof AiToolsShape["text"]]: GatewayModelIdMap[G] }>;
+  urlRetrieval?: Partial<AiToolsShape["urlRetrieval"]>;
+  video?: VideoToolInputFor<G>;
+  webSearch?: Partial<AiToolsShape["webSearch"]>;
 }
 
+// Only gateway is required; everything else is an override on top of GATEWAY_MODEL_DEFAULTS
+// biome-ignore lint/style/useConsistentTypeDefinitions: type is used intentionally here
 type AiInputFor<G extends GatewayType> = {
-  [K in keyof AiShape]: K extends "gateway"
-    ? G
-    : K extends "workflows"
-      ? {
-          [W in keyof AiShape["workflows"]]: GatewayModelIdMap[G];
-        }
-      : K extends "tools"
-        ? AiToolsInputFor<G>
-        : K extends "disabledModels" | "curatedDefaults" | "anonymousModels"
-          ? GatewayModelIdMap[G][]
-          : AiShape[K];
+  gateway: G;
+  providerOrder?: AiShape["providerOrder"];
+  disabledModels?: GatewayModelIdMap[G][];
+  curatedDefaults?: GatewayModelIdMap[G][];
+  anonymousModels?: GatewayModelIdMap[G][];
+  workflows?: Partial<{
+    [W in keyof AiShape["workflows"]]: GatewayModelIdMap[G];
+  }>;
+  tools?: AiToolsInputFor<G>;
 };
 
 type ConfigInputForGateway<G extends GatewayType> = Omit<
@@ -470,7 +413,63 @@ export type ConfigInput = {
   [G in GatewayType]: ConfigInputForGateway<G>;
 }[GatewayType];
 
+/**
+ * Type-safe config helper. Infers the gateway type from `ai.gateway` so
+ * autocomplete and error messages are scoped to the chosen gateway's model IDs.
+ * Only `ai.gateway` is required — all other `ai` fields are optional overrides
+ * on top of the gateway defaults supplied by `applyDefaults`.
+ */
+export function defineConfig<G extends GatewayType>(
+  config: ConfigInputForGateway<G>
+): ConfigInput {
+  return config as ConfigInput;
+}
+
+function mergeToolsConfig<T extends Record<string, unknown>>(
+  defaults: T,
+  user: Record<string, unknown> | undefined
+): T {
+  if (!user) {
+    return defaults;
+  }
+  const result: Record<string, unknown> = { ...defaults };
+  for (const [key, val] of Object.entries(user)) {
+    const defVal = result[key];
+    if (
+      val !== null &&
+      typeof val === "object" &&
+      !Array.isArray(val) &&
+      defVal !== null &&
+      typeof defVal === "object" &&
+      !Array.isArray(defVal)
+    ) {
+      result[key] = { ...defVal, ...(val as object) };
+    } else {
+      result[key] = val;
+    }
+  }
+  return result as T;
+}
+
 // Apply defaults to partial config
 export function applyDefaults(input: ConfigInput): Config {
-  return configSchema.parse(input);
+  const gateway = input.ai?.gateway ?? DEFAULT_GATEWAY;
+  const gatewayDefaults = GATEWAY_MODEL_DEFAULTS[gateway];
+  const aiInput = input.ai as Record<string, unknown> | undefined;
+
+  const mergedAi = {
+    gateway,
+    ...gatewayDefaults,
+    ...aiInput,
+    workflows: {
+      ...gatewayDefaults.workflows,
+      ...(aiInput?.workflows as Record<string, unknown> | undefined),
+    },
+    tools: mergeToolsConfig(
+      gatewayDefaults.tools,
+      aiInput?.tools as Record<string, unknown> | undefined
+    ),
+  };
+
+  return configSchema.parse({ ...input, ai: mergedAi });
 }

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

@@ -1,6 +1,6 @@
 import userConfig from "@/chat.config";
 import type { ActiveGatewayType } from "./ai/app-model-id";
-import { type AiConfig, type Config, configSchema } from "./config-schema";
+import { type AiConfig, applyDefaults, type Config } from "./config-schema";
 
 type ActiveAiConfig = Extract<AiConfig, { gateway: ActiveGatewayType }>;
 
@@ -15,6 +15,6 @@ type ActiveConfig = Omit<Config, "ai"> & { ai: ActiveAiConfig };
  * import { config } from "@/lib/config";
  * console.log(config.appName);
  */
-export const config = configSchema.parse(userConfig) as ActiveConfig;
+export const config = applyDefaults(userConfig) as ActiveConfig;
 
 export type { Config } from "./config-schema";

package/templates/chat-app/lib/db/migrations/0044_gray_red_shift.sql

@@ -0,0 +1,5 @@
+ALTER TABLE "Message" ALTER COLUMN "selectedModel" DROP DEFAULT;--> statement-breakpoint
+ALTER TABLE "Message" ALTER COLUMN "selectedModel" SET DATA TYPE json USING to_json("selectedModel");--> statement-breakpoint
+ALTER TABLE "Message" ADD COLUMN "parallelGroupId" uuid;--> statement-breakpoint
+ALTER TABLE "Message" ADD COLUMN "parallelIndex" integer;--> statement-breakpoint
+ALTER TABLE "Message" ADD COLUMN "isPrimaryParallel" boolean;--> statement-breakpoint