@chat-js/cli 0.1.4 → 0.2.0

package/templates/chat-app/lib/ai/app-model-id.ts

@@ -8,7 +8,7 @@ import type {
 
 /** The gateway type actively selected in chat.config.ts */
 export type ActiveGatewayType = typeof chatConfig extends {
-  models: { gateway: infer G extends GatewayType };
+  ai: { gateway: infer G extends GatewayType };
 }
   ? G
   : DefaultGateway;

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

@@ -15,8 +15,8 @@ export type AppModelDefinition = Omit<ModelData, "id"> & {
   apiModelId: ModelId;
 };
 
-const DISABLED_MODELS = new Set(config.models.disabledModels);
-const PROVIDER_ORDER = config.models.providerOrder;
+const DISABLED_MODELS = new Set(config.ai.disabledModels);
+const PROVIDER_ORDER = config.ai.providerOrder;
 
 function buildAppModels(models: ModelData[]): AppModelDefinition[] {
   return models
@@ -116,7 +116,7 @@ export async function getAppModelDefinition(
  * so we fall back to an empty set (which auto-enables all models).
  */
 const KNOWN_MODEL_IDS = new Set<string>(
-  generatedForGateway === config.models.gateway
+  generatedForGateway === config.ai.gateway
     ? generatedModels.map((m) => m.id)
     : []
 );
@@ -128,7 +128,7 @@ const KNOWN_MODEL_IDS = new Set<string>(
 export function getDefaultEnabledModels(
   appModels: AppModelDefinition[]
 ): Set<AppModelId> {
-  const enabled = new Set<AppModelId>(config.models.curatedDefaults);
+  const enabled = new Set<AppModelId>(config.ai.curatedDefaults);
 
   // If a curated default has a -reasoning variant, enable it too
   for (const model of appModels) {

package/templates/chat-app/lib/ai/eval-agent.ts

@@ -20,17 +20,17 @@ function createNoOpStreamWriter(): StreamWriter {
   } as unknown as StreamWriter;
 }
 
-export type EvalAgentResult = {
-  finalText: string;
+export interface EvalAgentResult {
   assistantMessage: ChatMessage;
-  usage: LanguageModelUsage | undefined;
+  finalText: string;
+  followupSuggestions: string[];
   toolResults: Array<{
     toolName: string;
     type: string;
     state?: string;
   }>;
-  followupSuggestions: string[];
-};
+  usage: LanguageModelUsage | undefined;
+}
 
 async function executeAgentAndGetOutput({
   userMessage,

package/templates/chat-app/lib/ai/followup-suggestions.ts

@@ -12,7 +12,7 @@ export async function generateFollowupSuggestions(
   const minQuestionCount = 3;
   const maxCharactersPerQuestion = 80;
   return streamText({
-    model: await getLanguageModel(config.models.defaults.followupSuggestions),
+    model: await getLanguageModel(config.ai.tools.followupSuggestions.default),
     messages: [
       ...modelMessages,
       {

package/templates/chat-app/lib/ai/gateway-model-defaults.ts

@@ -1,28 +1,58 @@
 import type { GatewayType } from "./gateways/registry";
 
-type ModelDefaults = {
-  providerOrder: string[];
-  disabledModels: string[];
-  curatedDefaults: string[];
+interface ModelDefaults {
   anonymousModels: string[];
-  defaults: {
+  curatedDefaults: string[];
+  disabledModels: string[];
+  providerOrder: string[];
+  tools: {
+    webSearch: {
+      enabled: boolean;
+    };
+    urlRetrieval: {
+      enabled: boolean;
+    };
+    codeExecution: {
+      enabled: boolean;
+    };
+    mcp: {
+      enabled: boolean;
+    };
+    followupSuggestions: {
+      enabled: boolean;
+      default: string;
+    };
+    text: {
+      polish: string;
+    };
+    sheet: {
+      format: string;
+      analyze: string;
+    };
+    code: {
+      edits: string;
+    };
+    image: {
+      enabled: boolean;
+      default: string;
+    };
+    deepResearch: {
+      enabled: boolean;
+      defaultModel: string;
+      finalReportModel: string;
+      allowClarification: boolean;
+      maxResearcherIterations: number;
+      maxConcurrentResearchUnits: number;
+      maxSearchQueries: number;
+    };
+  };
+  workflows: {
     chat: string;
     title: string;
     pdf: string;
-    artifact: string;
-    artifactSuggestion: string;
-    followupSuggestions: string;
-    suggestions: string;
-    polishText: string;
-    formatSheet: string;
-    analyzeSheet: string;
-    codeEdits: string;
     chatImageCompatible: string;
-    image: string;
-    deepResearch: string;
-    deepResearchFinalReport: string;
   };
-};
+}
 
 const multiProviderDefaults = {
   providerOrder: ["openai", "google", "anthropic"],
@@ -40,22 +70,52 @@ const multiProviderDefaults = {
     "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",
+    },
+    deepResearch: {
+      enabled: false,
+      defaultModel: "google/gemini-2.5-flash-lite",
+      finalReportModel: "google/gemini-3-flash",
+      allowClarification: true,
+      maxResearcherIterations: 1,
+      maxConcurrentResearchUnits: 2,
+      maxSearchQueries: 2,
+    },
   },
 } satisfies ModelDefaults;
 
@@ -69,22 +129,52 @@ const openaiOnlyDefaults = {
     "gpt-5.2-chat-latest",
   ],
   anonymousModels: ["gpt-5-nano"],
-  defaults: {
+  workflows: {
     chat: "gpt-5-mini",
     title: "gpt-5-nano",
     pdf: "gpt-5-mini",
-    artifact: "gpt-5-nano",
-    artifactSuggestion: "gpt-5-mini",
-    followupSuggestions: "gpt-5-nano",
-    suggestions: "gpt-5-mini",
-    polishText: "gpt-5-mini",
-    formatSheet: "gpt-5-mini",
-    analyzeSheet: "gpt-5-mini",
-    codeEdits: "gpt-5-mini",
     chatImageCompatible: "gpt-4o-mini",
-    image: "gpt-image-1",
-    deepResearch: "gpt-5-nano",
-    deepResearchFinalReport: "gpt-5-mini",
+  },
+  tools: {
+    webSearch: {
+      enabled: false,
+    },
+    urlRetrieval: {
+      enabled: false,
+    },
+    codeExecution: {
+      enabled: false,
+    },
+    mcp: {
+      enabled: false,
+    },
+    followupSuggestions: {
+      enabled: false,
+      default: "gpt-5-nano",
+    },
+    text: {
+      polish: "gpt-5-mini",
+    },
+    sheet: {
+      format: "gpt-5-mini",
+      analyze: "gpt-5-mini",
+    },
+    code: {
+      edits: "gpt-5-mini",
+    },
+    image: {
+      enabled: false,
+      default: "gpt-image-1",
+    },
+    deepResearch: {
+      enabled: false,
+      defaultModel: "gpt-5-nano",
+      finalReportModel: "gpt-5-mini",
+      allowClarification: true,
+      maxResearcherIterations: 1,
+      maxConcurrentResearchUnits: 2,
+      maxSearchQueries: 2,
+    },
   },
 } satisfies ModelDefaults;
 

package/templates/chat-app/lib/ai/gateways/gateway-provider.ts

@@ -1,19 +1,23 @@
+import type { Experimental_VideoModelV3 } from "@ai-sdk/provider";
 import type { ImageModel, LanguageModel } from "ai";
 import type { AiGatewayModel } from "../ai-gateway-models-schemas";
 
-export type GatewayProvider<
+export interface GatewayProvider<
   TGateway extends string = string,
   TModelId extends string = string,
   TImageModelId extends string = string,
-> = {
-  readonly type: TGateway;
+  TVideoModelId extends string = string,
+> {
+  /** Create a dedicated image model instance, or null if unsupported */
+  createImageModel(modelId: TImageModelId): ImageModel | null;
 
   /** Create a language model instance from a model ID like "openai/gpt-5-nano" */
   createLanguageModel(modelId: TModelId): LanguageModel;
 
-  /** Create a dedicated image model instance, or null if unsupported */
-  createImageModel(modelId: TImageModelId): ImageModel | null;
+  /** Create a video model instance, or null if unsupported */
+  createVideoModel(modelId: TVideoModelId): Experimental_VideoModelV3 | null;
 
   /** Fetch the list of available models from the gateway's API */
   fetchModels(): Promise<AiGatewayModel[]>;
-};
+  readonly type: TGateway;
+}

package/templates/chat-app/lib/ai/gateways/openai-compatible-gateway.ts

@@ -1,4 +1,5 @@
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import type { Experimental_VideoModelV3 } from "@ai-sdk/provider";
 import type { ImageModel, LanguageModel } from "ai";
 import { createModuleLogger } from "@/lib/logger";
 import type { AiGatewayModel } from "../ai-gateway-models-schemas";
@@ -7,12 +8,12 @@ import type { GatewayProvider } from "./gateway-provider";
 
 const log = createModuleLogger("ai/gateways/openai-compatible");
 
-type OpenAICompatibleModelResponse = {
+interface OpenAICompatibleModelResponse {
+  created: number;
   id: string;
   object: string;
-  created: number;
   owned_by: string;
-};
+}
 
 function toAiGatewayModel(
   model: OpenAICompatibleModelResponse
@@ -32,7 +33,7 @@ function toAiGatewayModel(
 }
 
 export class OpenAICompatibleGateway
-  implements GatewayProvider<"openai-compatible", string, string>
+  implements GatewayProvider<"openai-compatible", string, string, never>
 {
   readonly type = "openai-compatible" as const;
 
@@ -59,6 +60,10 @@ export class OpenAICompatibleGateway
     return provider.imageModel(modelId);
   }
 
+  createVideoModel(_modelId: never): Experimental_VideoModelV3 | null {
+    return null;
+  }
+
   private getApiKey(): string | undefined {
     return process.env.OPENAI_COMPATIBLE_API_KEY;
   }

package/templates/chat-app/lib/ai/gateways/openai-gateway.ts

@@ -1,4 +1,5 @@
 import { createOpenAI } from "@ai-sdk/openai";
+import type { Experimental_VideoModelV3 } from "@ai-sdk/provider";
 import type { ImageModel, LanguageModel } from "ai";
 import { env } from "@/lib/env";
 import { createModuleLogger } from "@/lib/logger";
@@ -20,12 +21,12 @@ type OpenaiImageModelId = StrictLiterals<
   ExtractImageModelIdFromProvider<typeof createOpenAI>
 >;
 
-type OpenAIModelResponse = {
+interface OpenAIModelResponse {
+  created: number;
   id: string;
   object: string;
-  created: number;
   owned_by: string;
-};
+}
 
 function toAiGatewayModel(model: OpenAIModelResponse): AiGatewayModel {
   return {
@@ -45,7 +46,7 @@ function toAiGatewayModel(model: OpenAIModelResponse): AiGatewayModel {
 
 export class OpenAIGateway
   implements
-    GatewayProvider<"openai", OpenaiLanguageModelId, OpenaiImageModelId>
+    GatewayProvider<"openai", OpenaiLanguageModelId, OpenaiImageModelId, never>
 {
   readonly type = "openai" as const;
 
@@ -67,6 +68,10 @@ export class OpenAIGateway
     return provider.image(modelId);
   }
 
+  createVideoModel(_modelId: never): Experimental_VideoModelV3 | null {
+    return null;
+  }
+
   private getApiKey(): string | undefined {
     return env.OPENAI_API_KEY;
   }

package/templates/chat-app/lib/ai/gateways/openrouter-gateway.ts

@@ -1,3 +1,4 @@
+import type { Experimental_VideoModelV3 } from "@ai-sdk/provider";
 import { createOpenRouter } from "@openrouter/ai-sdk-provider";
 import type { ImageModel, LanguageModel } from "ai";
 import { createModuleLogger } from "@/lib/logger";
@@ -7,21 +8,17 @@ import type { GatewayProvider } from "./gateway-provider";
 
 const log = createModuleLogger("ai/gateways/openrouter");
 
-type OpenRouterModelResponse = {
-  id: string;
-  name: string;
-  created: number;
-  description: string;
-  context_length: number | null;
+interface OpenRouterModelResponse {
   architecture: {
     modality?: string;
     input_modalities?: string[];
     output_modalities?: string[];
   } | null;
-  top_provider: {
-    context_length?: number | null;
-    max_completion_tokens: number | null;
-  } | null;
+  context_length: number | null;
+  created: number;
+  description: string;
+  id: string;
+  name: string;
   pricing: {
     prompt?: string;
     completion?: string;
@@ -32,7 +29,11 @@ type OpenRouterModelResponse = {
     input_cache_write?: string;
   } | null;
   supported_parameters?: string[] | null;
-};
+  top_provider: {
+    context_length?: number | null;
+    max_completion_tokens: number | null;
+  } | null;
+}
 
 function deriveTags(model: OpenRouterModelResponse): string[] {
   const inputMods = model.architecture?.input_modalities ?? ["text"];
@@ -95,7 +96,7 @@ function toAiGatewayModel(model: OpenRouterModelResponse): AiGatewayModel {
 }
 
 export class OpenRouterGateway
-  implements GatewayProvider<"openrouter", string, string>
+  implements GatewayProvider<"openrouter", string, string, never>
 {
   readonly type = "openrouter" as const;
 
@@ -118,6 +119,10 @@ export class OpenRouterGateway
     return null;
   }
 
+  createVideoModel(_modelId: never): Experimental_VideoModelV3 | null {
+    return null;
+  }
+
   private getApiKey(): string | undefined {
     return process.env.OPENROUTER_API_KEY;
   }

package/templates/chat-app/lib/ai/gateways/registry.ts

@@ -60,3 +60,12 @@ export type GatewayImageModelIdMap = {
     | InferImageModelId<K>
     | (K extends typeof generatedForGateway ? MultimodalImageModel : never);
 };
+
+/** Infer video model ID type from a gateway's `createVideoModel` parameter */
+type InferVideoModelId<T extends GatewayType> = Parameters<
+  ReturnType<(typeof gatewayRegistry)[T]>["createVideoModel"]
+>[0];
+
+export type GatewayVideoModelIdMap = {
+  [K in GatewayType]: InferVideoModelId<K>;
+};

package/templates/chat-app/lib/ai/gateways/vercel-gateway.ts

@@ -1,9 +1,11 @@
 import { gateway } from "@ai-sdk/gateway";
+import type { Experimental_VideoModelV3 } from "@ai-sdk/provider";
 import type { ImageModel, LanguageModel } from "ai";
 import { createModuleLogger } from "@/lib/logger";
 import {
   type AiGatewayModel,
   aiGatewayModelsResponseSchema,
+  isAiGatewayModelType,
 } from "../ai-gateway-models-schemas";
 import { getFallbackModels } from "./fallback-models";
 import type { GatewayProvider } from "./gateway-provider";
@@ -12,13 +14,19 @@ import type { StrictLiterals } from "./provider-types";
 const log = createModuleLogger("ai/gateways/vercel");
 
 type VercelImageModelId = Parameters<(typeof gateway)["imageModel"]>[0];
+type VercelVideoModelId = Parameters<(typeof gateway)["videoModel"]>[0];
 type VercelLanguageModelId = StrictLiterals<
   Parameters<(typeof gateway)["languageModel"]>[0]
 >;
 
 export class VercelGateway
   implements
-    GatewayProvider<"vercel", VercelLanguageModelId, VercelImageModelId>
+    GatewayProvider<
+      "vercel",
+      VercelLanguageModelId,
+      VercelImageModelId,
+      VercelVideoModelId
+    >
 {
   readonly type = "vercel" as const;
 
@@ -30,6 +38,10 @@ export class VercelGateway
     return gateway.imageModel(modelId);
   }
 
+  createVideoModel(modelId: VercelVideoModelId): Experimental_VideoModelV3 {
+    return gateway.videoModel(modelId);
+  }
+
   private getApiKey(): string | undefined {
     return process.env.AI_GATEWAY_API_KEY || process.env.VERCEL_OIDC_TOKEN;
   }
@@ -68,13 +80,33 @@ export class VercelGateway
 
       const bodyRaw = await response.json();
       const body = aiGatewayModelsResponseSchema.parse(bodyRaw);
-      const modelCount = body.data?.length ?? 0;
+      const unsupportedTypes = new Set<string>();
+      const models: AiGatewayModel[] = [];
+
+      for (const model of body.data) {
+        if (!isAiGatewayModelType(model.type)) {
+          unsupportedTypes.add(model.type);
+          continue;
+        }
+        models.push({ ...model, type: model.type });
+      }
+
+      if (unsupportedTypes.size > 0) {
+        log.warn(
+          {
+            unsupportedTypes: [...unsupportedTypes],
+            skippedModelCount: body.data.length - models.length,
+            modelCount: body.data.length,
+          },
+          "Skipping models with unsupported types from Vercel AI Gateway"
+        );
+      }
 
       log.info(
-        { modelCount },
+        { modelCount: models.length },
         "Successfully fetched models from Vercel AI Gateway"
       );
-      return body.data || [];
+      return models;
     } catch (error) {
       log.error(
         { err: error, url },

package/templates/chat-app/lib/ai/mcp/cache.ts

@@ -11,25 +11,18 @@ const mcpCacheTags = {
 } as const;
 
 // Types for cached results
-export type ConnectionStatusResult = {
+export interface ConnectionStatusResult {
+  error?: string;
+  needsAuth: boolean;
   status:
     | "disconnected"
     | "connecting"
     | "connected"
     | "authorizing"
     | "incompatible";
-  needsAuth: boolean;
-  error?: string;
-};
+}
 
-export type DiscoveryResult = {
-  tools: Array<{ name: string; description: string | null }>;
-  resources: Array<{
-    name: string;
-    uri: string;
-    description: string | null;
-    mimeType: string | null;
-  }>;
+export interface DiscoveryResult {
   prompts: Array<{
     name: string;
     description: string | null;
@@ -39,7 +32,14 @@ export type DiscoveryResult = {
       required: boolean;
     }>;
   }>;
-};
+  resources: Array<{
+    name: string;
+    uri: string;
+    description: string | null;
+    mimeType: string | null;
+  }>;
+  tools: Array<{ name: string; description: string | null }>;
+}
 
 /**
  * Create a cached connection status fetcher for a specific connector.

package/templates/chat-app/lib/ai/model-data.ts

@@ -1,23 +1,7 @@
-export type ModelData = {
-  id: string;
-  object: string;
-  owned_by: string;
-  name: string;
-  description: string;
-  type: "language" | "embedding" | "image";
-  tags?: string[];
+export interface ModelData {
   context_window: number;
-  max_tokens: number;
-  pricing: {
-    input?: string;
-    output?: string;
-    input_cache_read?: string;
-    input_cache_write?: string;
-    web_search?: string;
-    image?: string;
-  };
-  reasoning: boolean;
-  toolCall: boolean;
+  description: string;
+  id: string;
   input: {
     image: boolean;
     text: boolean;
@@ -25,9 +9,26 @@ export type ModelData = {
     video: boolean;
     audio: boolean;
   };
+  max_tokens: number;
+  name: string;
+  object: string;
   output: {
     image: boolean;
     text: boolean;
     audio: boolean;
+    video: boolean;
   };
-};
+  owned_by: string;
+  pricing: {
+    input?: string;
+    output?: string;
+    input_cache_read?: string;
+    input_cache_write?: string;
+    web_search?: string;
+    image?: string;
+  };
+  reasoning: boolean;
+  tags?: string[];
+  toolCall: boolean;
+  type: "language" | "embedding" | "image" | "video";
+}