@chat-js/cli 0.6.1 → 0.6.3

package/templates/chat-app/lib/ai/tool-renderer-registry.ts

@@ -0,0 +1,31 @@
+import type { ToolUIPart } from "ai";
+import type { ComponentType } from "react";
+import { ui } from "@/tools/chatjs/ui";
+import type { InstalledTools, installedTools } from "./installed-tools";
+
+export type InstalledToolName = keyof typeof installedTools;
+export type InstalledToolType = `tool-${InstalledToolName & string}`;
+export type InstalledToolUIPart = ToolUIPart<InstalledTools>;
+
+export type InstalledToolPart<T extends InstalledToolType> = Extract<
+  InstalledToolUIPart,
+  { type: T }
+>;
+
+export type ToolRendererProps<T extends InstalledToolType> = {
+  tool: InstalledToolPart<T>;
+  messageId: string;
+  isReadonly: boolean;
+};
+
+export type ToolRendererRegistry = {
+  [K in InstalledToolType]: ComponentType<ToolRendererProps<K>>;
+};
+
+export const toolRendererRegistry = ui satisfies ToolRendererRegistry;
+
+export function isInstalledToolType(
+  type: string
+): type is keyof typeof toolRendererRegistry {
+  return Object.hasOwn(toolRendererRegistry, type);
+}

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

@@ -5,22 +5,21 @@ import type {
   UIMessageStreamWriter,
 } from "ai";
 import { z } from "zod";
-import type { codeExecution } from "@/lib/ai/tools/code-execution";
-import type { deepResearch } from "@/lib/ai/tools/deep-research/deep-research";
-import type { generateImageTool as generateImageToolFactory } from "@/lib/ai/tools/generate-image";
-import type { generateVideoTool as generateVideoToolFactory } from "@/lib/ai/tools/generate-video";
-import type { getWeather } from "@/lib/ai/tools/get-weather";
-import type { readDocument } from "@/lib/ai/tools/read-document";
-import type { retrieveUrl } from "@/lib/ai/tools/retrieve-url";
-import type { tavilyWebSearch } from "@/lib/ai/tools/web-search";
+import type { codeExecution } from "@/tools/platform/code-execution";
+import type { deepResearch } from "@/tools/platform/deep-research/deep-research";
+import type { createCodeDocumentTool } from "@/tools/platform/documents/create-code-document";
+import type { createSheetDocumentTool } from "@/tools/platform/documents/create-sheet-document";
+import type { createTextDocumentTool } from "@/tools/platform/documents/create-text-document";
+import type { editCodeDocumentTool } from "@/tools/platform/documents/edit-code-document";
+import type { editSheetDocumentTool } from "@/tools/platform/documents/edit-sheet-document";
+import type { editTextDocumentTool } from "@/tools/platform/documents/edit-text-document";
+import type { generateImageTool as generateImageToolFactory } from "@/tools/platform/generate-image";
+import type { generateVideoTool as generateVideoToolFactory } from "@/tools/platform/generate-video";
+import type { readDocument } from "@/tools/platform/read-document";
+import type { ResearchUpdate } from "@/tools/platform/research-updates-schema";
+import type { tavilyWebSearch } from "@/tools/platform/web-search";
 import type { AppModelId } from "./app-models";
-import type { createCodeDocumentTool } from "./tools/documents/create-code-document";
-import type { createSheetDocumentTool } from "./tools/documents/create-sheet-document";
-import type { createTextDocumentTool } from "./tools/documents/create-text-document";
-import type { editCodeDocumentTool } from "./tools/documents/edit-code-document";
-import type { editSheetDocumentTool } from "./tools/documents/edit-sheet-document";
-import type { editTextDocumentTool } from "./tools/documents/edit-text-document";
-import type { ResearchUpdate } from "./tools/research-updates-schema";
+import type { InstalledTools } from "./installed-tools";
 
 export const toolNameSchema = z.enum([
   "getWeather",
@@ -143,7 +142,6 @@ const messageMetadataSchema = z.object({
 
 export type MessageMetadata = z.infer<typeof messageMetadataSchema>;
 
-type weatherTool = InferUITool<typeof getWeather>;
 type createTextDocumentToolType = InferUITool<
   ReturnType<typeof createTextDocumentTool>
 >;
@@ -172,7 +170,6 @@ type generateVideoTool = InferUITool<
 >;
 type webSearchTool = InferUITool<ReturnType<typeof tavilyWebSearch>>;
 type codeExecutionTool = InferUITool<ReturnType<typeof codeExecution>>;
-type retrieveUrlTool = InferUITool<typeof retrieveUrl>;
 
 export type ChatTools = {
   codeExecution: codeExecutionTool;
@@ -185,11 +182,9 @@ export type ChatTools = {
   editTextDocument: editTextDocumentToolType;
   generateImage: generateImageTool;
   generateVideo: generateVideoTool;
-  getWeather: weatherTool;
   readDocument: readDocumentTool;
-  retrieveUrl: retrieveUrlTool;
   webSearch: webSearchTool;
-};
+} & InstalledTools;
 
 interface FollowupSuggestions {
   suggestions: string[];

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

@@ -8,10 +8,19 @@ import type {
 type EnvVarName = keyof NodeJS.ProcessEnv;
 
 export interface EnvRequirement {
-  description: string;
+  description?: string;
   options: EnvVarName[][];
 }
 
+export function formatRequirementDescription(
+  requirement: EnvRequirement
+): string {
+  return (
+    requirement.description ??
+    requirement.options.map((option) => option.join(" + ")).join(" or ")
+  );
+}
+
 export const gatewayEnvRequirements: Record<GatewayType, EnvRequirement> = {
   openrouter: {
     options: [["OPENROUTER_API_KEY"]],
@@ -51,10 +60,6 @@ export const aiToolEnvRequirements: Partial<
     options: [["TAVILY_API_KEY"], ["FIRECRAWL_API_KEY"]],
     description: "TAVILY_API_KEY or FIRECRAWL_API_KEY",
   },
-  urlRetrieval: {
-    options: [["FIRECRAWL_API_KEY"]],
-    description: "FIRECRAWL_API_KEY",
-  },
   mcp: {
     options: [["MCP_ENCRYPTION_KEY"]],
     description: "MCP_ENCRYPTION_KEY",
@@ -106,5 +111,5 @@ export function getMissingRequirement(
 ): string | null {
   return isRequirementSatisfied(requirement, env)
     ? null
-    : requirement.description;
+    : formatRequirementDescription(requirement);
 }

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

@@ -92,6 +92,14 @@ function createAiSchema<G extends GatewayType>(g: G) {
         mcp: z.object({
           enabled: z.boolean(),
         }),
+        documents: z.object({
+          enabled: z.boolean(),
+          types: z.object({
+            text: z.boolean(),
+            code: z.boolean(),
+            sheet: z.boolean(),
+          }),
+        }),
         followupSuggestions: z.object({
           enabled: z.boolean(),
           default: gatewayModelId<G>(),
@@ -253,6 +261,16 @@ export const authenticationConfigSchema = z
     github: true,
     vercel: false,
   });
+export const pathsConfigSchema = z
+  .object({
+    tools: z
+      .string()
+      .describe(
+        "Import alias for the installable tools registry index and tool files"
+      )
+      .default("@/tools/chatjs"),
+  })
+  .default({ tools: "@/tools/chatjs" });
 
 export const desktopAppConfigSchema = z
   .object({
@@ -343,6 +361,8 @@ export const configSchema = z.object({
   anonymous: anonymousConfigSchema,
 
   attachments: attachmentsConfigSchema,
+
+  paths: pathsConfigSchema,
 });
 
 // Output types (after defaults applied)
@@ -352,6 +372,7 @@ export type AiConfig = z.infer<typeof aiConfigSchema>;
 export type AnonymousConfig = z.infer<typeof anonymousConfigSchema>;
 export type AttachmentsConfig = z.infer<typeof attachmentsConfigSchema>;
 export type FeaturesConfig = z.infer<typeof featuresConfigSchema>;
+export type PathsConfig = z.infer<typeof pathsConfigSchema>;
 export type AuthenticationConfig = z.infer<typeof authenticationConfigSchema>;
 export type DesktopAppConfig = z.infer<typeof desktopAppConfigSchema>;
 
@@ -391,6 +412,9 @@ interface AiToolsInputFor<G extends GatewayType> {
   code?: Partial<{ [P in keyof AiToolsShape["code"]]: GatewayModelIdMap[G] }>;
   codeExecution?: Partial<AiToolsShape["codeExecution"]>;
   deepResearch?: DeepResearchToolInputFor<G>;
+  documents?: Partial<Omit<AiToolsShape["documents"], "types">> & {
+    types?: AiToolsShape["documents"]["types"];
+  };
   followupSuggestions?: FollowupSuggestionsToolInputFor<G>;
   image?: ImageToolInputFor<G>;
   mcp?: Partial<AiToolsShape["mcp"]>;

package/templates/chat-app/lib/stores/hooks-message-parts.ts

@@ -3,7 +3,7 @@
 import equal from "fast-deep-equal";
 import { shallow } from "zustand/shallow";
 import { useStoreWithEqualityFn } from "zustand/traditional";
-import { documentToolTypes } from "../ai/tools/documents/types";
+import { documentToolTypes } from "@/tools/platform/documents/types";
 import type { ChatMessage } from "../ai/types";
 import {
   type CustomChatStoreState,

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

@@ -8,212 +8,212 @@ import { ChatSDKError, type ErrorCode } from "./ai/errors";
 import type { Attachment, ChatMessage } from "./ai/types";
 
 export function cn(...inputs: ClassValue[]) {
-  return twMerge(clsx(inputs));
+	return twMerge(clsx(inputs));
 }
 
 interface ApplicationError extends Error {
-  info: string;
-  status: number;
+	info: string;
+	status: number;
 }
 
 export async function fetchWithErrorHandlers(
-  input: RequestInfo | URL,
-  init?: RequestInit
+	input: RequestInfo | URL,
+	init?: RequestInit,
 ) {
-  try {
-    const response = await fetch(input, init);
-
-    if (!response.ok) {
-      const { code, cause } = await response.json();
-      throw new ChatSDKError(code as ErrorCode, cause);
-    }
-
-    return response;
-  } catch (error: unknown) {
-    if (typeof navigator !== "undefined" && !navigator.onLine) {
-      throw new ChatSDKError("offline:chat");
-    }
-
-    throw error;
-  }
+	try {
+		const response = await fetch(input, init);
+
+		if (!response.ok) {
+			const { code, cause } = await response.json();
+			throw new ChatSDKError(code as ErrorCode, cause);
+		}
+
+		return response;
+	} catch (error: unknown) {
+		if (typeof navigator !== "undefined" && !navigator.onLine) {
+			throw new ChatSDKError("offline:chat");
+		}
+
+		throw error;
+	}
 }
 
 function findLastArtifact(
-  messages: Array<ChatMessage>
+	messages: Array<ChatMessage>,
 ): { messageIndex: number; toolCallId: string } | null {
-  const allArtifacts: Array<{ messageIndex: number; toolCallId: string }> = [];
-
-  messages.forEach((msg, messageIndex) => {
-    msg.parts?.forEach((part) => {
-      if (
-        (part.type === "tool-createTextDocument" ||
-          part.type === "tool-createCodeDocument" ||
-          part.type === "tool-createSheetDocument" ||
-          part.type === "tool-editTextDocument" ||
-          part.type === "tool-editCodeDocument" ||
-          part.type === "tool-editSheetDocument" ||
-          part.type === "tool-deepResearch") &&
-        part.state === "output-available"
-      ) {
-        allArtifacts.push({
-          messageIndex,
-          toolCallId: part.toolCallId,
-        });
-      }
-    });
-  });
-
-  return allArtifacts[allArtifacts.length - 1] || null;
+	const allArtifacts: Array<{ messageIndex: number; toolCallId: string }> = [];
+
+	messages.forEach((msg, messageIndex) => {
+		msg.parts?.forEach((part) => {
+			if (
+				(part.type === "tool-createTextDocument" ||
+					part.type === "tool-createCodeDocument" ||
+					part.type === "tool-createSheetDocument" ||
+					part.type === "tool-editTextDocument" ||
+					part.type === "tool-editCodeDocument" ||
+					part.type === "tool-editSheetDocument" ||
+					part.type === "tool-deepResearch") &&
+				part.state === "output-available"
+			) {
+				allArtifacts.push({
+					messageIndex,
+					toolCallId: part.toolCallId,
+				});
+			}
+		});
+	});
+
+	return allArtifacts[allArtifacts.length - 1] || null;
 }
 
 const fetcher = async (url: string) => {
-  const res = await fetch(url);
+	const res = await fetch(url);
 
-  if (!res.ok) {
-    const error = new Error(
-      "An error occurred while fetching the data."
-    ) as ApplicationError;
+	if (!res.ok) {
+		const error = new Error(
+			"An error occurred while fetching the data.",
+		) as ApplicationError;
 
-    error.info = await res.json();
-    error.status = res.status;
+		error.info = await res.json();
+		error.status = res.status;
 
-    throw error;
-  }
+		throw error;
+	}
 
-  return res.json();
+	return res.json();
 };
 
 function getLocalStorage(key: string) {
-  if (typeof window !== "undefined") {
-    return JSON.parse(localStorage.getItem(key) || "[]");
-  }
-  return [];
+	if (typeof window !== "undefined") {
+		return JSON.parse(localStorage.getItem(key) || "[]");
+	}
+	return [];
 }
 
 export function generateUUID(): string {
-  return uuidv7();
+	return uuidv7();
 }
 
 function getMostRecentUserMessage(messages: Array<ChatMessage>) {
-  const userMessages = messages.filter((message) => message.role === "user");
-  return userMessages.at(-1);
+	const userMessages = messages.filter((message) => message.role === "user");
+	return userMessages.at(-1);
 }
 
 function getDocumentTimestampByIndex(
-  documents: Array<Document>,
-  index: number
+	documents: Array<Document>,
+	index: number,
 ) {
-  if (!documents) return new Date();
-  if (index > documents.length) return new Date();
+	if (!documents) return new Date();
+	if (index > documents.length) return new Date();
 
-  return documents[index].createdAt;
+	return documents[index].createdAt;
 }
 
 function getTrailingMessageId({
-  messages,
+	messages,
 }: {
-  messages: Array<ChatMessage>;
+	messages: Array<ChatMessage>;
 }): string | null {
-  const trailingMessage = messages.at(-1);
+	const trailingMessage = messages.at(-1);
 
-  if (!trailingMessage) return null;
+	if (!trailingMessage) return null;
 
-  return trailingMessage.id;
+	return trailingMessage.id;
 }
 
 export function getLanguageFromFileName(fileName: string): string {
-  const extension = fileName.split(".").pop()?.toLowerCase() || "";
-
-  const extensionToLanguage: Record<string, string> = {
-    // JavaScript/TypeScript
-    js: "javascript",
-    jsx: "jsx",
-    ts: "typescript",
-    tsx: "tsx",
-    mjs: "javascript",
-    cjs: "javascript",
-
-    // Python
-    py: "python",
-    pyw: "python",
-    pyi: "python",
-
-    // Web
-    html: "html",
-    htm: "html",
-    css: "css",
-    scss: "css",
-    sass: "css",
-    less: "css",
-
-    // Data formats
-    json: "json",
-    xml: "xml",
-    yaml: "yaml",
-    yml: "yaml",
-    toml: "toml",
-
-    // Shell
-    sh: "shell",
-    bash: "shell",
-    zsh: "shell",
-    fish: "shell",
-
-    // Other languages
-    sql: "sql",
-    md: "markdown",
-    mdx: "markdown",
-    java: "java",
-    c: "c",
-    cpp: "cpp",
-    cc: "cpp",
-    cxx: "cpp",
-    h: "c",
-    hpp: "cpp",
-    cs: "csharp",
-    php: "php",
-    rb: "ruby",
-    go: "go",
-    rs: "rust",
-    swift: "swift",
-    kt: "kotlin",
-    r: "r",
-    R: "r",
-  };
-
-  return extensionToLanguage[extension] || "python"; // Default to python
+	const extension = fileName.split(".").pop()?.toLowerCase() || "";
+
+	const extensionToLanguage: Record<string, string> = {
+		// JavaScript/TypeScript
+		js: "javascript",
+		jsx: "jsx",
+		ts: "typescript",
+		tsx: "tsx",
+		mjs: "javascript",
+		cjs: "javascript",
+
+		// Python
+		py: "python",
+		pyw: "python",
+		pyi: "python",
+
+		// Web
+		html: "html",
+		htm: "html",
+		css: "css",
+		scss: "css",
+		sass: "css",
+		less: "css",
+
+		// Data formats
+		json: "json",
+		xml: "xml",
+		yaml: "yaml",
+		yml: "yaml",
+		toml: "toml",
+
+		// Shell
+		sh: "shell",
+		bash: "shell",
+		zsh: "shell",
+		fish: "shell",
+
+		// Other languages
+		sql: "sql",
+		md: "markdown",
+		mdx: "markdown",
+		java: "java",
+		c: "c",
+		cpp: "cpp",
+		cc: "cpp",
+		cxx: "cpp",
+		h: "c",
+		hpp: "cpp",
+		cs: "csharp",
+		php: "php",
+		rb: "ruby",
+		go: "go",
+		rs: "rust",
+		swift: "swift",
+		kt: "kotlin",
+		r: "r",
+		R: "r",
+	};
+
+	return extensionToLanguage[extension] || "python"; // Default to python
 }
 
 export function getAttachmentsFromMessage(message: ChatMessage): Attachment[] {
-  return message.parts
-    .filter<FileUIPart>((part) => part.type === "file")
-    .map((part) => ({
-      name: part.filename || "",
-      url: part.url,
-      contentType: part.mediaType,
-    }));
+	return message.parts
+		.filter<FileUIPart>((part) => part.type === "file")
+		.map((part) => ({
+			name: part.filename || "",
+			url: part.url,
+			contentType: part.mediaType,
+		}));
 }
 
 export function getTextContentFromMessage(message: ChatMessage): string {
-  return message.parts
-    .filter<TextPart>((part) => part.type === "text")
-    .map((part) => part.text)
-    .join("");
+	return message.parts
+		.filter<TextPart>((part) => part.type === "text")
+		.map((part) => part.text)
+		.join("");
 }
 
 export function getTextContentFromModelMessage(message: ModelMessage): string {
-  const content = message.content;
-
-  if (typeof content === "string") {
-    return content;
-  }
-
-  return content
-    .map((part) => {
-      if (part.type === "text") {
-        return part.text;
-      }
-      return "";
-    })
-    .join("\n");
+	const content = message.content;
+
+	if (typeof content === "string") {
+		return content;
+	}
+
+	return content
+		.map((part) => {
+			if (part.type === "text") {
+				return part.text;
+			}
+			return "";
+		})
+		.join("\n");
 }

package/templates/chat-app/package.json

@@ -153,7 +153,7 @@
     "usehooks-ts": "^3.1.0",
     "uuid": "^11.1.0",
     "vaul": "^1.1.2",
-    "zod": "^4.1.4",
+    "zod": "^4.3.6",
     "zustand": "^5.0.6"
   },
   "overrides": {