@standardagents/cli 0.14.0 → 0.15.0

package/dist/index.js

@@ -141,14 +141,19 @@ interface ThreadState {
   loadAgent(name): Promise<AgentConfig>;           // Load agent definition
   env(propertyName): Promise<string>;              // Resolve env value for this thread
   setEnv(propertyName, value): Promise<void>;      // Set thread env + propagate to active descendants
+  getValue<T = unknown>(key: string): Promise<T | null>; // Read durable per-thread JSON value
+  setValue(key: string, value: unknown): Promise<void>;  // Write durable value; null/undefined deletes
   notifyParent(content): Promise<void>;            // Explicitly queue a silent message to the parent
   setStatus(status): Promise<void>;                // Update this child in the parent registry
   getChildThread(referenceId): Promise<ThreadState | null>; // Resolve child thread
   getParentThread(): Promise<ThreadState | null>;            // Resolve parent thread
   terminate(): Promise<void>;                      // Soft-terminate thread
+  runCode(source, options?): CodeExecution;        // Run JS/TS in a fresh Dynamic Worker sandbox
 }
 \`\`\`
 
+\`runCode\` has no implicit access to thread state, filesystem, network, timers, or host globals. Bridge only the exact capabilities needed through \`imports\` or \`globals\`; use \`modules\` for local relative ES modules; use \`execute\` to select the export and args to run. \`modules\` keys are graph-root relative paths; entry-source imports resolve from \`filename\` when supplied, including \`../\` parent paths that stay inside the supplied graph. TypeScript input is accepted by default and erased before evaluation. In thread endpoints, \`runCode\` is forwarded into the thread Durable Object; pass plain transferable options there and keep function-backed bridges in tools or in-thread execution contexts.
+
 ## Subagents
 
 \`dual_ai\` agents can be used as subagents from prompt tool configs:
@@ -165,6 +170,8 @@ Access in tools:
 export default defineTool('...', schema, async (state, args) => {
   const threadId = state.threadId;
   const { messages } = await state.getMessages();
+  const count = (await state.getValue<number>('invocation_count')) ?? 0;
+  await state.setValue('invocation_count', count + 1);
   // ...
 });
 \`\`\`
@@ -236,6 +243,7 @@ Models define which LLM provider and model to use for prompts.
 | \`outputPrice\` | \`number\` | No | Cost per 1M output tokens (USD) |
 | \`cachedPrice\` | \`number\` | No | Cost per 1M cached input tokens |
 | \`includedProviders\` | \`string[]\` | No | Provider prefixes for OpenRouter routing |
+| \`providerTools\` | \`string[]\` | No | Provider-built-in tool names to make available for prompts using this model |
 
 ## Example
 
@@ -250,6 +258,19 @@ export default defineModel({
 });
 \`\`\`
 
+## Provider Tools
+
+Providers can expose built-in tools such as search, file search, code execution,
+or provider-specific tools through their \`getTools()\` implementation. Enable the
+provider tool names on the model with \`providerTools\`; prompts can then include
+those tools like normal tool names. Provider tools execute on the upstream
+provider, not in AgentBuilder, and successful calls are logged as provider tool
+entries.
+
+OpenRouter exposes \`web_search\`, \`web_fetch\`, \`datetime\`, and \`image_generation\`
+as provider-executed server tools. Configure optional OpenRouter parameters with
+\`providerOptions.serverTools\` on the model.
+
 ## Recommended Models (OpenRouter)
 
 | Use Case | Model ID | Description |
@@ -372,6 +393,12 @@ export default definePrompt({
 
 \`type: 'env'\` inserts a resolved thread variable value. Use this only for non-secret values that are safe to expose to the LLM.
 
+The sandboxed coding prompt declares \`HTTP_HOST\` as a text variable. Its URL helper uses that value as the origin for files exposed from the thread \`public/\` directory and endpoints exposed from the thread \`api/\` directory. Public URLs should usually omit extensions; extensionless public paths resolve \`.html\`, then \`.js\`, then \`.ts\`, then matching \`index\` files in the same order. Browser pages should reference only public files, \`api/\` endpoints, or absolute external URLs, using relative asset URLs like \`./app\` and \`./api/todos\`; private \`src/\` files are not served directly. Public \`.ts\` files are transformed to browser JavaScript and are not server endpoints. Server-side endpoints live under the thread filesystem \`api/\` directory, and the \`api/\` directory name stays in the public URL: \`api/todo.ts\` is \`/api/threads/{threadId}/api/todo\`, while \`api/todo.ts\` is not \`/api/threads/{threadId}/todo\` or \`/api/threads/{threadId}/todos\`. Endpoint files default-export a function that accepts \`Request\` and returns \`Response\` or \`Promise<Response>\`. Endpoint code can import \`fetch\`, \`fs\`, and \`storage\`, and can import private helpers with relative paths such as \`../src/todo.ts\`. When the coding agent creates a site, page, or endpoint, it should call \`get_public_url\` with the created file path and use the returned URL.
+
+Sandboxed code and \`api/\` endpoints can persist small JSON-serializable runtime data through \`import { storage } from "storage"\`. Use \`storage.get\`, \`storage.set\`, \`storage.delete\`, and \`storage.has\` with stable logical keys. Do not expose, mention, or depend on internal storage key prefixes.
+
+The sandboxed coding prompt includes \`delete_file\` for removing files or empty directories from the thread filesystem. Use it to clean up obsolete implementation files, stale public assets, and abandoned endpoint routes after the replacement is working.
+
 ## Tool Configuration
 
 Tools can be simple names or detailed configs:
@@ -389,6 +416,12 @@ tools: [
 ],
 \`\`\`
 
+Provider-built-in tools use the same \`tools\` list once the selected model enables
+them with \`providerTools\`. AgentBuilder passes them to the provider and records
+provider-reported calls in request logs; it does not execute those tools locally.
+Generated prompt files may store these selections as \`provider:<toolName>\` to
+distinguish provider tools from local tools with the same name.
+
 ### Subagent Tool Configuration
 
 Use \`SubagentToolConfig\` when the tool is a \`dual_ai\` agent:
@@ -422,14 +455,14 @@ When prompt-configured resumable dual_ai subagents exist, the runtime auto-injec
 - \`subagent_create\` for spawning new child instances
 - \`subagent_message\` for messaging active resumable instances
 
-\`subagent_create\` supports optional \`name\` for human-friendly child thread labels.
-Pair it with \`initAgentNameProperty\` to map that argument into a \`name:<value>\` thread tag.
+\`subagent_create\` requires a non-empty \`name\` for human-friendly child thread labels.
+AgentBuilder stores that argument as a \`name:<value>\` thread tag.
 
 Set \`immediate: true\` to run a tool automatically when the prompt activates.
 Use \`immediate: { nameEnv, descriptionEnv, scopedEnv }\` when you want safe per-instance bootstrap hints while keeping copied scoped env runtime-only.
 Set \`optional: 'ENV_NAME'\` to enable a subagent branch only when env resolves to \`true\`, \`1\`, or \`yes\`.
 Set \`resumable.parentCommunication: 'explicit'\` when the child should stay quiet until its own tools or hooks call \`state.notifyParent()\` or \`state.setStatus()\`.
-If required scoped vars are missing, the runtime returns \`error_code: "subagent_env_required"\` with a temporary \`GET/POST /api/threads/:id/variables/:requestId\` endpoint in \`error_data.endpoint\`.
+If required scoped vars are missing, the runtime returns \`error_code: "subagent_env_required"\` with a temporary \`GET/POST /api/threads/:threadId/variables/:requestId\` endpoint in \`error_data.endpoint\`.
 
 ## Input Validation
 
@@ -710,6 +743,10 @@ export default defineTool({
 });
 \`\`\`
 
+## Argument Schemas
+
+Tool args must be a top-level \`z.object(...)\`. Prefer explicit, bounded schemas made from strings, numbers, booleans, nulls, literals, enums, arrays, objects, optionals, nullables, and defaults. Avoid provider-visible recursive or open-ended schemas such as \`z.unknown()\`, \`z.any()\`, and \`z.object({}).catchall(...)\`; strict tool providers can reject the generated JSON Schema. If a tool needs arbitrary JSON input, accept it as a JSON string and parse it inside \`execute\`.
+
 ## ToolResult Interface
 
 | Property | Type | Description |
@@ -742,11 +779,29 @@ execute: async (state, args) => {
   const apiKey = await state.env('GOOGLE_API_KEY');
   await state.setEnv('LAST_TOOL_RUN_AT', new Date().toISOString());
 
+  // Durable per-thread JSON values
+  const runCount = (await state.getValue<number>('run_count')) ?? 0;
+  await state.setValue('run_count', runCount + 1);
+
+  // Sandboxed JS/TS execution with explicit bridge capabilities
+  const run = state.runCode('export async function main(path) { return await read(path) }', {
+    execute: { fn: 'main', args: ['/notes.txt'] },
+    globals: {
+      read: async (path: string) => {
+        const data = await state.readFile(path);
+        return data ? new TextDecoder().decode(data) : null;
+      },
+    },
+  });
+  const codeResult = await run;
+
   // Parent state (for sub-prompts)
   const root = state.rootState;
 }
 \`\`\`
 
+Use \`state.runCode()\` instead of \`eval\` or \`new Function\` for model- or user-authored JavaScript/TypeScript. The sandbox starts with no ambient host capabilities; provide imports/globals explicitly, use \`modules\` for local relative ES modules, use \`execute\` to select an export and pass args, use \`report\` for streamed observations, and call \`run.terminate(reason)\` from your own timeout budget when needed. \`modules\` keys are graph-root relative paths; entry-source imports resolve from \`options.filename\` when supplied. Relative module imports may use \`./\` and \`../\` as long as they resolve within the supplied module graph. In thread endpoints, \`runCode\` is forwarded into the thread Durable Object; pass plain transferable option values there, and do function-backed bridges from tools or in-thread execution contexts.
+
 ## Tool Without Arguments
 
 \`\`\`typescript
@@ -912,6 +967,9 @@ Hooks intercept and modify agent execution at specific lifecycle points.
 
 | Hook | Signature | Purpose |
 |------|-----------|---------|
+| \`after_thread_created\` | \`(state: ThreadState) => void\` | Initialize a newly created thread before execution |
+| \`after_subagent_created\` | \`(state: ThreadState, childState: ThreadState) => void\` | Run parent-side logic after a child thread is created |
+| \`after_system_message\` | \`(state: ThreadState, systemMessage: string) => string \\| null \\| undefined\` | Modify the rendered system message for a request |
 | \`filter_messages\` | \`(state: ThreadState, messages: Message[]) => Message[]\` | Filter raw messages before LLM context |
 | \`prefilter_llm_history\` | \`(state: ThreadState, messages: LLMMessage[]) => LLMMessage[]\` | Modify chat completion messages before LLM |
 | \`before_create_message\` | \`(state: ThreadState, message: Message) => Message\` | Modify message before database insert |
@@ -922,7 +980,7 @@ Hooks intercept and modify agent execution at specific lifecycle points.
 | \`after_tool_call_success\` | \`(state: ThreadState, toolCall: HookToolCall, result: HookToolResult) => HookToolResult \\| null\` | Process successful tool execution |
 | \`after_tool_call_failure\` | \`(state: ThreadState, toolCall: HookToolCall, result: HookToolResult) => HookToolResult \\| null\` | Process failed tool execution |
 
-All hooks receive \`ThreadState\` as their first parameter, providing access to thread identity, message history, and resource loading.
+All hooks receive \`ThreadState\` as their first parameter, providing access to thread identity, message history, resource loading, durable per-thread values via \`getValue\` / \`setValue\`, and sandboxed JS/TS execution via \`runCode\`.
 
 ## Creating a Hook
 
@@ -1086,6 +1144,7 @@ export default defineHook({
 ## Hook Categories
 
 **Transformation hooks** (return modified data):
+- \`after_system_message\` (return replacement string, or null/undefined for no change)
 - \`filter_messages\`
 - \`prefilter_llm_history\`
 - \`before_create_message\`
@@ -1095,6 +1154,8 @@ export default defineHook({
 - \`after_tool_call_failure\` (return modified result or null)
 
 **Event hooks** (side effects only):
+- \`after_thread_created\`
+- \`after_subagent_created\`
 - \`after_create_message\`
 - \`after_update_message\`
 
@@ -1121,25 +1182,33 @@ Define custom API endpoints that operate on specific threads with access to the
 
 | File Pattern | HTTP Method | Route |
 |--------------|-------------|-------|
-| \`name.ts\` | GET | \`/api/threads/:id/name\` |
-| \`name.get.ts\` | GET | \`/api/threads/:id/name\` |
-| \`name.post.ts\` | POST | \`/api/threads/:id/name\` |
-| \`name.put.ts\` | PUT | \`/api/threads/:id/name\` |
-| \`name.delete.ts\` | DELETE | \`/api/threads/:id/name\` |
-| \`nested/route.ts\` | GET | \`/api/threads/:id/nested/route\` |
+| \`name.ts\` | GET | \`/api/threads/:threadId/name\` |
+| \`name.get.ts\` | GET | \`/api/threads/:threadId/name\` |
+| \`name.post.ts\` | POST | \`/api/threads/:threadId/name\` |
+| \`name.put.ts\` | PUT | \`/api/threads/:threadId/name\` |
+| \`name.delete.ts\` | DELETE | \`/api/threads/:threadId/name\` |
+| \`index.ts\` | GET | \`/api/threads/:threadId\` |
+| \`nested/route.ts\` | GET | \`/api/threads/:threadId/nested/route\` |
+| \`items/[id].ts\` | GET | \`/api/threads/:threadId/items/:id\` |
+| \`files/[*].ts\` | GET | \`/api/threads/:threadId/files/*\` |
+
+Files without a method suffix default to GET. Method suffixes are case-insensitive and support \`.get.ts\`, \`.post.ts\`, \`.put.ts\`, \`.patch.ts\`, and \`.delete.ts\`.
+
+Dynamic segments use \`[name]\` and are passed to the handler as \`params.name\`. Catch-all segments use \`[*]\` and are passed as \`params['*']\`; the catch-all value may contain \`/\` for nested paths. Static routes match before dynamic routes, and dynamic routes match before catch-all routes.
 
 ## Basic Example
 
 \`\`\`typescript
-// agents/api/status.get.ts -> GET /api/threads/:id/status
+// agents/api/status.get.ts -> GET /api/threads/:threadId/status
 import { defineThreadEndpoint } from '@standardagents/spec';
 
-export default defineThreadEndpoint(async (req, state) => {
+export default defineThreadEndpoint(async (req, state, params) => {
   const { messages, total } = await state.getMessages();
   return Response.json({
     threadId: state.threadId,
     messageCount: total,
     status: 'active',
+    params,
   });
 });
 \`\`\`
@@ -1149,9 +1218,10 @@ export default defineThreadEndpoint(async (req, state) => {
 | Parameter | Type | Description |
 |-----------|------|-------------|
 | \`req\` | \`Request\` | The incoming HTTP request |
-| \`state\` | \`ThreadState\` | Thread state with messages, identity, file system, etc. |
+| \`state\` | \`ThreadState\` | Thread state with messages, identity, file system, \`runCode\`, etc. |
+| \`params\` | \`Record<string, string>\` | Route parameters captured from \`[name]\` and \`[*]\` path segments |
 
-Note: \`state.execution\` is always \`null\` in endpoints since the thread is at rest.
+Note: \`state.execution\` is always \`null\` in endpoints since the thread is at rest. \`state.runCode()\` is available from endpoints and is forwarded into the thread runtime; pass plain transferable option values there, and do function-backed sandbox bridges from tools or in-thread execution contexts.
 
 ## ThreadState Methods
 
@@ -1177,6 +1247,10 @@ export default defineThreadEndpoint(async (req, state) => {
   const approvalGate = await state.env('TOPDOWN_APPROVAL_GATE');
   await state.setEnv('TOPDOWN_APPROVAL_GATE', approvalGate || 'open');
 
+  // Durable per-thread JSON values
+  const exports = (await state.getValue<number>('export_count')) ?? 0;
+  await state.setValue('export_count', exports + 1);
+
   // File system operations
   const files = await state.findFiles('**/*.json');
   const data = await state.readFile('/data/config.json');
@@ -1192,7 +1266,7 @@ export default defineThreadEndpoint(async (req, state) => {
 ## POST with Request Body
 
 \`\`\`typescript
-// agents/api/export.post.ts -> POST /api/threads/:id/export
+// agents/api/export.post.ts -> POST /api/threads/:threadId/export
 import { defineThreadEndpoint } from '@standardagents/spec';
 
 export default defineThreadEndpoint(async (req, state) => {
@@ -1218,11 +1292,12 @@ Create directories for nested routes:
 
 \`\`\`
 agents/api/
-\u251C\u2500\u2500 status.get.ts           -> GET /api/threads/:id/status
-\u251C\u2500\u2500 export.post.ts          -> POST /api/threads/:id/export
+\u251C\u2500\u2500 status.get.ts           -> GET /api/threads/:threadId/status
+\u251C\u2500\u2500 export.post.ts          -> POST /api/threads/:threadId/export
 \u2514\u2500\u2500 messages/
-    \u251C\u2500\u2500 count.ts            -> GET /api/threads/:id/messages/count
-    \u2514\u2500\u2500 search.post.ts      -> POST /api/threads/:id/messages/search
+    \u251C\u2500\u2500 count.ts            -> GET /api/threads/:threadId/messages/count
+    \u251C\u2500\u2500 [id].ts             -> GET /api/threads/:threadId/messages/:id
+    \u2514\u2500\u2500 [*].ts              -> GET /api/threads/:threadId/messages/*
 \`\`\`
 
 ## Error Handling
@@ -1287,10 +1362,18 @@ var WRANGLER_TEMPLATE = (name) => {
   "name": "${name}",
   "main": "worker/index.ts",
   "compatibility_date": "${getScaffoldCompatibilityDate()}",
-  "compatibility_flags": ["nodejs_compat"],
+  "compatibility_flags": ["nodejs_compat", "enable_ctx_exports"],
   "observability": {
     "enabled": true
   },
+  "worker_loaders": [
+    {
+      "binding": "AGENT_BUILDER_CODE_LOADER"
+    }
+  ],
+  "vars": {
+    "AGENT_BUILDER_CODE_COMPATIBILITY_DATE": "${getScaffoldCompatibilityDate()}"
+  },
   "assets": {
     "directory": "dist/client",
     "not_found_handling": "single-page-application",
@@ -1330,7 +1413,7 @@ var AGENT_BUILDER_TS = `import { DurableAgentBuilder } from 'virtual:@standardag
 
 export default class AgentBuilder extends DurableAgentBuilder {}
 `;
-var WORKER_INDEX = `import { router } from "virtual:@standardagents/builder"
+var WORKER_INDEX = `import { router, CodeExecutionBridge } from "virtual:@standardagents/builder"
 import DurableThread from '../agents/Thread';
 import DurableAgentBuilder from '../agents/AgentBuilder';
 
@@ -1341,7 +1424,7 @@ export default {
   },
 } satisfies ExportedHandler<Env>
 
-export { DurableThread, DurableAgentBuilder }
+export { DurableThread, DurableAgentBuilder, CodeExecutionBridge }
 `;
 function getProjectName(cwd) {
   const packageJsonPath = path3.join(cwd, "package.json");
@@ -1427,11 +1510,34 @@ function createOrUpdateWranglerConfig(cwd, projectName, force) {
       const hasBindings = config.durable_objects?.bindings?.some(
         (b) => b.name === "AGENT_BUILDER_THREAD" || b.name === "AGENT_BUILDER"
       );
-      if (hasBindings) {
+      const hasCodeLoader = config.worker_loaders?.some(
+        (loader) => loader.binding === "AGENT_BUILDER_CODE_LOADER"
+      );
+      const hasCodeCompatibilityDate = config.vars?.AGENT_BUILDER_CODE_COMPATIBILITY_DATE === getScaffoldCompatibilityDate();
+      const hasCtxExportsFlag = Array.isArray(config.compatibility_flags) ? config.compatibility_flags.includes("enable_ctx_exports") : false;
+      if (hasBindings && hasCodeLoader && hasCodeCompatibilityDate && hasCtxExportsFlag) {
         logger.info("wrangler.jsonc already configured for Standard Agents");
         return true;
       }
       let result = text;
+      if (!hasCodeLoader) {
+        const loaders = [...config.worker_loaders || [], { binding: "AGENT_BUILDER_CODE_LOADER" }];
+        const edits = modify(result, ["worker_loaders"], loaders, {});
+        result = applyEdits(result, edits);
+      }
+      if (!hasCodeCompatibilityDate) {
+        const vars = {
+          ...config.vars || {},
+          AGENT_BUILDER_CODE_COMPATIBILITY_DATE: getScaffoldCompatibilityDate()
+        };
+        const edits = modify(result, ["vars"], vars, {});
+        result = applyEdits(result, edits);
+      }
+      if (!hasCtxExportsFlag) {
+        const flags = Array.isArray(config.compatibility_flags) ? [...config.compatibility_flags, "enable_ctx_exports"] : ["nodejs_compat", "enable_ctx_exports"];
+        const edits = modify(result, ["compatibility_flags"], flags, {});
+        result = applyEdits(result, edits);
+      }
       if (!config.durable_objects) {
         const edits = modify(result, ["durable_objects"], {
           bindings: [
@@ -1442,10 +1548,12 @@ function createOrUpdateWranglerConfig(cwd, projectName, force) {
         result = applyEdits(result, edits);
       } else {
         const bindings = config.durable_objects.bindings || [];
-        bindings.push(
-          { name: "AGENT_BUILDER_THREAD", class_name: "DurableThread" },
-          { name: "AGENT_BUILDER", class_name: "DurableAgentBuilder" }
-        );
+        if (!bindings.some((b) => b.name === "AGENT_BUILDER_THREAD")) {
+          bindings.push({ name: "AGENT_BUILDER_THREAD", class_name: "DurableThread" });
+        }
+        if (!bindings.some((b) => b.name === "AGENT_BUILDER")) {
+          bindings.push({ name: "AGENT_BUILDER", class_name: "DurableAgentBuilder" });
+        }
         const edits = modify(result, ["durable_objects", "bindings"], bindings, {});
         result = applyEdits(result, edits);
       }
@@ -1512,10 +1620,23 @@ async function createOrUpdateWorkerEntry(cwd, force) {
   const content = fs3.readFileSync(entryPath, "utf-8");
   const hasRouter = content.includes("virtual:@standardagents/builder") && content.includes("router");
   const hasDurableExports = content.includes("DurableThread") && content.includes("DurableAgentBuilder");
-  if (hasRouter && hasDurableExports && !force) {
+  const hasCodeBridge = content.includes("CodeExecutionBridge");
+  if (hasRouter && hasDurableExports && hasCodeBridge && !force) {
     logger.info(`${path3.relative(cwd, entryPath)} already configured`);
     return true;
   }
+  if (hasRouter && hasDurableExports && !hasCodeBridge && !force) {
+    fs3.writeFileSync(
+      entryPath,
+      `${content.trimEnd()}
+
+export { CodeExecutionBridge } from "virtual:@standardagents/builder"
+`,
+      "utf-8"
+    );
+    logger.success(`Updated ${path3.relative(cwd, entryPath)} with CodeExecutionBridge export`);
+    return true;
+  }
   try {
     const mod = await loadFile(entryPath);
     if (!content.includes("virtual:@standardagents/builder") || force) {
@@ -1565,6 +1686,7 @@ async function createOrUpdateWorkerEntry(cwd, force) {
     logger.log("");
     logger.log("  // Export Durable Objects:");
     logger.log("  export { DurableThread, DurableAgentBuilder }");
+    logger.log('  export { CodeExecutionBridge } from "virtual:@standardagents/builder"');
     logger.log("");
     return false;
   }
@@ -1880,7 +2002,7 @@ function getWorkspacePackageVersion() {
   if (process.env.STANDARDAGENTS_WORKSPACE === "1") {
     return "workspace:*";
   }
-  return "0.14.0";
+  return "0.15.0";
 }
 function getSipPackageVersion() {
   return "1.0.1";
@@ -4111,7 +4233,7 @@ async function availableModels(options = {}) {
 
 // src/index.ts
 var program = new Command();
-program.name("agents").description("CLI tool for Standard Agents / AgentBuilder").version("0.14.0");
+program.name("agents").description("CLI tool for Standard Agents / AgentBuilder").version("0.15.0");
 program.command("init [project-name]").description("Create a new Standard Agents project (runs create vite, then scaffold)").option("-y, --yes", "Skip prompts and use defaults").option("--template <template>", "Vite template to use", "vanilla-ts").action(init);
 program.command("scaffold").description("Add Standard Agents to an existing Vite project").option("--force", "Overwrite existing configuration").action(scaffold);
 program.command("init-chat [project-name]").description("Scaffold a frontend chat application").option("-y, --yes", "Skip prompts and use defaults").option("--framework <framework>", "Framework to use (vite or nextjs)").action(initChat);