@standardagents/cli 0.11.0-next.ab7e1ea → 0.11.0-next.c3b4490

package/chat/src/App.tsx

@@ -110,7 +110,7 @@ function AuthenticatedApp() {
         </button>
 
         {currentThreadId ? (
-          <ThreadProvider key={currentThreadId} threadId={currentThreadId} live>
+          <ThreadProvider key={currentThreadId} threadId={currentThreadId} live useWorkblocks>
             <Chat
               thread={threads.find(t => t.id === currentThreadId)}
               onUpdateTitle={(title) => updateThreadTitle(currentThreadId, title)}

package/chat/src/components/MessageList.tsx

@@ -228,62 +228,114 @@ function WorkItemStatus({ status }: { status: 'pending' | 'success' | 'error' |
   return <SpinnerIcon className="w-3.5 h-3.5 text-[var(--text-secondary)]" />
 }
 
+// Chevron icon for collapse/expand
+function ChevronIcon({ className, expanded }: { className?: string; expanded: boolean }) {
+  return (
+    <svg
+      className={`${className} transition-transform duration-200 ${expanded ? 'rotate-90' : ''}`}
+      viewBox="0 0 24 24"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth={2}
+      strokeLinecap="round"
+      strokeLinejoin="round"
+    >
+      <path d="M9 18l6-6-6-6" />
+    </svg>
+  )
+}
+
 // Workblock component
-function Workblock({ workblock }: { workblock: WorkMessage }) {
+function Workblock({ workblock, isLast, threadLoading }: { workblock: WorkMessage; isLast?: boolean; threadLoading?: boolean }) {
+  const [isExpanded, setIsExpanded] = useState(false)
   const { text } = parseMessageContent(workblock.content)
   const isPending = workblock.status === 'pending'
 
   // Group work items by tool_call_id to pair calls with results
   const toolCalls = workblock.workItems.filter(item => item.type === 'tool_call')
+  const toolResults = workblock.workItems.filter(item => item.type === 'tool_result')
 
-  // Count completed vs total
+  // Count completed vs total and check for errors
   const completedCount = toolCalls.filter(item => item.status === 'success' || item.status === 'error').length
+  const errorCount = toolCalls.filter(item => item.status === 'error').length
   const totalCount = toolCalls.length
+  const hasErrors = errorCount > 0
+
+  // Get most recent info for the badge (last tool result or last tool call name)
+  const lastResult = toolResults[toolResults.length - 1]
+  const lastToolCall = toolCalls[toolCalls.length - 1]
+  const badgeText = lastResult?.content
+    ? (lastResult.content.length > 40 ? lastResult.content.slice(0, 40) + '...' : lastResult.content)
+    : lastToolCall?.name
+      ? formatToolName(lastToolCall.name)
+      : null
+
+  // Determine status label and color
+  const statusLabel = isPending ? 'Working' : hasErrors ? 'Completed with errors' : 'Completed'
+  const statusColor = isPending ? 'text-violet-500' : hasErrors ? 'text-amber-500' : 'text-emerald-500'
+
+  // Show loader if this is the last workblock and thread is still loading
+  const showLoader = isLast && threadLoading && !isPending
 
   return (
-    <div className="animate-fade-in space-y-3">
-      {/* Tool calls summary */}
+    <div className="animate-fade-in">
+      {/* Workblock panel */}
       <div className={`bg-[var(--bg-tertiary)] border border-[var(--border-primary)] rounded-xl overflow-hidden max-w-[85%] ${isPending ? 'workblock-shimmer' : ''}`}>
-        <div className="px-3 py-2 bg-[var(--bg-hover)] border-b border-[var(--border-primary)] flex items-center justify-between">
-          <div className="flex items-center gap-2">
-            <span className={`text-xs font-medium uppercase tracking-wide ${isPending ? 'text-violet-500' : 'text-emerald-500'}`}>
-              {isPending ? 'Working' : 'Completed'}
+        {/* Header - clickable to toggle */}
+        <button
+          onClick={() => setIsExpanded(!isExpanded)}
+          className="w-full px-3 py-2 bg-[var(--bg-hover)] flex items-center gap-2 hover:bg-[var(--bg-tertiary)] transition-colors text-left"
+        >
+          <ChevronIcon className="w-3.5 h-3.5 text-[var(--text-tertiary)]" expanded={isExpanded} />
+          <span className={`text-xs font-medium uppercase tracking-wide ${statusColor}`}>
+            {statusLabel}
+          </span>
+          {(isPending || showLoader) && (
+            <SpinnerIcon className="w-3 h-3 text-violet-500" />
+          )}
+          {/* Badge with most recent info when collapsed */}
+          {!isExpanded && badgeText && (
+            <span className="ml-auto text-xs text-[var(--text-tertiary)] bg-[var(--bg-secondary)] px-2 py-0.5 rounded truncate max-w-[200px]">
+              {badgeText}
             </span>
-            {isPending && (
-              <SpinnerIcon className="w-3 h-3 text-violet-500" />
-            )}
-          </div>
-          {totalCount > 1 && (
-            <span className="text-xs text-[var(--text-tertiary)]">
+          )}
+          {isExpanded && totalCount > 1 && (
+            <span className="ml-auto text-xs text-[var(--text-tertiary)]">
               {completedCount}/{totalCount}
             </span>
           )}
-        </div>
+        </button>
+
+        {/* Collapsible content */}
+        {isExpanded && (
+          <>
+            {/* Text content (thinking/reasoning) inside the workblock */}
+            {text && text.trim() && (
+              <div className="px-3 py-2.5 border-t border-[var(--border-primary)] bg-[var(--bg-secondary)]">
+                <p className="text-sm text-[var(--text-secondary)] italic whitespace-pre-wrap break-words">
+                  {text.trim()}
+                </p>
+              </div>
+            )}
 
-        <div className="divide-y divide-[var(--border-primary)]">
-          {toolCalls.map((item, index) => (
-            <div
-              key={item.id}
-              className="px-3 py-2.5 flex items-center gap-3 animate-slide-in"
-              style={{ animationDelay: `${index * 50}ms` }}
-            >
-              <WorkItemStatus status={item.status} />
-              <span className="text-sm text-[var(--text-primary)]">
-                {formatToolName(item.name)}
-              </span>
+            {/* Tool calls list */}
+            <div className="divide-y divide-[var(--border-primary)] border-t border-[var(--border-primary)]">
+              {toolCalls.map((item, index) => (
+                <div
+                  key={item.id}
+                  className="px-3 py-2.5 flex items-center gap-3 animate-slide-in"
+                  style={{ animationDelay: `${index * 50}ms` }}
+                >
+                  <WorkItemStatus status={item.status} />
+                  <span className="text-sm text-[var(--text-primary)]">
+                    {formatToolName(item.name)}
+                  </span>
+                </div>
+              ))}
             </div>
-          ))}
-        </div>
+          </>
+        )}
       </div>
-
-      {/* Text content if present */}
-      {text && (
-        <div className="max-w-[85%]">
-          <div className="whitespace-pre-wrap break-words text-[15px] leading-relaxed text-[var(--text-primary)]">
-            {text}
-          </div>
-        </div>
-      )}
     </div>
   )
 }
@@ -717,7 +769,7 @@ function ThinkingIndicator() {
 }
 
 export function MessageList() {
-  const { messages, loading, threadId } = useThread()
+  const { workblocks: messages, loading, threadId } = useThread()
   const bottomRef = useRef<HTMLDivElement>(null)
 
   const scrollToBottom = useCallback(() => {
@@ -771,10 +823,12 @@ export function MessageList() {
 
   return (
     <div className="py-6 px-4 space-y-6">
-      {messages.map((msg) => {
+      {messages.map((msg, index) => {
+          const isLast = index === messages.length - 1
+
           // Handle workblocks
           if (isWorkMessage(msg)) {
-            return <Workblock key={msg.id} workblock={msg} />
+            return <Workblock key={msg.id} workblock={msg} isLast={isLast} threadLoading={loading} />
           }
 
           // Skip system and tool messages (tool messages are shown in workblocks)

package/dist/index.js

@@ -116,30 +116,32 @@ agents/
 
 Files are **auto-discovered** at runtime. No manual registration needed.
 
-## FlowState
+## ThreadState
 
-\`FlowState\` is the central state object available in tools and hooks:
+\`ThreadState\` is the state object available in tools and hooks:
 
 \`\`\`typescript
-interface FlowState {
-  thread: {
-    id: string;           // Thread identifier
-    instance: DurableThread;  // Durable Object instance
-  };
-  agent: AgentConfig;     // Current agent configuration
-  prompt: PromptConfig;   // Current prompt configuration
-  model: ModelConfig;     // Current model configuration
-  messages: Message[];    // Conversation history
-  env: Env;               // Cloudflare Worker environment
-  rootState: FlowState;   // Parent state (for sub-prompts)
+interface ThreadState {
+  // Identity (readonly)
+  threadId: string;           // Thread identifier
+  agentId: string;            // Agent identifier
+  userId: string | null;      // User identifier (if set)
+  createdAt: number;          // Creation timestamp
+
+  // Methods
+  getMessages(options?): Promise<MessagesResult>;  // Get conversation history
+  injectMessage(input): Promise<Message>;          // Add message to thread
+  loadModel(name): Promise<ModelConfig>;           // Load model definition
+  loadPrompt(name): Promise<PromptConfig>;         // Load prompt definition
+  loadAgent(name): Promise<AgentConfig>;           // Load agent definition
 }
 \`\`\`
 
 Access in tools:
 \`\`\`typescript
 export default defineTool('...', schema, async (flow, args) => {
-  const threadId = flow.thread.id;
-  const messages = flow.messages;
+  const threadId = flow.threadId;
+  const { messages } = await flow.getMessages();
   // ...
 });
 \`\`\`
@@ -283,15 +285,12 @@ Prompts define system instructions, model selection, and available tools for LLM
 | \`toolDescription\` | \`string\` | Yes | Description shown when used as a tool |
 | \`prompt\` | \`string \\| StructuredPrompt\` | Yes | System instructions |
 | \`model\` | \`string\` | Yes | Model name to use (references \`agents/models/\`) |
-| \`tools\` | \`(string \\| ToolConfig)[]\` | No | Available tools for LLM |
-| \`handoffAgents\` | \`string[]\` | No | Agents this prompt can hand off to |
+| \`tools\` | \`(string \\| ToolConfig)[]\` | No | Available tools (include ai_human agent names for handoffs) |
 | \`includeChat\` | \`boolean\` | No | Include full conversation history |
 | \`includePastTools\` | \`boolean\` | No | Include previous tool results |
 | \`parallelToolCalls\` | \`boolean\` | No | Allow multiple concurrent tool calls |
 | \`toolChoice\` | \`'auto' \\| 'none' \\| 'required'\` | No | Tool calling strategy |
 | \`requiredSchema\` | \`z.ZodObject\` | No | Input validation when called as tool |
-| \`beforeTool\` | \`string\` | No | Tool to run before LLM request |
-| \`afterTool\` | \`string\` | No | Tool to run after LLM response |
 | \`reasoning\` | \`ReasoningConfig\` | No | Extended thinking configuration |
 
 ## Basic Example
@@ -491,7 +490,7 @@ export default defineAgent({
 });
 \`\`\`
 
-Other prompts can then include it in their \`handoffAgents\` array.
+Other prompts can then include the agent name in their \`tools\` array to enable handoffs.
 
 ## Stop Conditions (Priority Order)
 
@@ -528,12 +527,12 @@ Tools extend agent capabilities beyond text generation. They allow LLMs to fetch
 ## Function Signature
 
 \`\`\`typescript
-defineTool(
+defineTool({
   description: string,           // What the tool does (shown to LLM)
-  args: z.ZodObject,             // Input validation schema
-  handler: (flow, args) => ToolResult,  // Implementation
-  returnSchema?: z.ZodObject     // Optional output schema
-)
+  args?: z.ZodObject,            // Input validation schema (optional)
+  execute: (state, args) => ToolResult,  // Implementation
+  tenvs?: z.ZodObject,           // Thread environment variables (optional)
+})
 \`\`\`
 
 ## Basic Example
@@ -542,20 +541,20 @@ defineTool(
 import { defineTool } from '@standardagents/builder';
 import { z } from 'zod';
 
-export default defineTool(
-  'Search the knowledge base for articles matching a query',
-  z.object({
+export default defineTool({
+  description: 'Search the knowledge base for articles matching a query',
+  args: z.object({
     query: z.string().describe('Search query'),
     limit: z.number().optional().default(10).describe('Max results'),
   }),
-  async (flow, args) => {
+  execute: async (state, args) => {
     const results = await searchKB(args.query, args.limit);
     return {
       status: 'success',
       result: JSON.stringify(results),
     };
-  }
-);
+  },
+});
 \`\`\`
 
 ## ToolResult Interface
@@ -565,44 +564,45 @@ export default defineTool(
 | \`status\` | \`'success' \\| 'error'\` | Whether the tool succeeded |
 | \`result\` | \`string\` | Tool output (required for success) |
 | \`error\` | \`string\` | Error message (for error status) |
+| \`attachments\` | \`ToolAttachment[]\` | Files to attach (images, etc.) |
 
-## FlowState Access
+## ThreadState Access
 
-The \`flow\` parameter provides access to:
+The \`state\` parameter provides access to:
 
 \`\`\`typescript
-async (flow, args) => {
+execute: async (state, args) => {
   // Thread information
-  const threadId = flow.thread.id;
-  const thread = flow.thread.instance;
+  const threadId = state.thread.id;
+  const thread = state.thread.instance;
 
   // Configuration
-  const agentName = flow.agent.name;
-  const modelName = flow.model.name;
+  const agentName = state.agent.name;
+  const modelName = state.model.name;
 
   // Message history
-  const messages = flow.messages;
+  const messages = state.messages;
 
   // Environment bindings
-  const env = flow.env;
+  const env = state.env;
 
   // Parent state (for sub-prompts)
-  const root = flow.rootState;
+  const root = state.rootState;
 }
 \`\`\`
 
 ## Tool Without Arguments
 
 \`\`\`typescript
-export default defineTool(
-  'Get current server time',
-  async (flow) => {
+export default defineTool({
+  description: 'Get current server time',
+  execute: async (state) => {
     return {
       status: 'success',
       result: new Date().toISOString(),
     };
-  }
-);
+  },
+});
 \`\`\`
 
 ## Error Handling
@@ -610,10 +610,10 @@ export default defineTool(
 Return errors gracefully instead of throwing:
 
 \`\`\`typescript
-export default defineTool(
-  'Fetch user data',
-  z.object({ userId: z.string() }),
-  async (flow, args) => {
+export default defineTool({
+  description: 'Fetch user data',
+  args: z.object({ userId: z.string() }),
+  execute: async (state, args) => {
     try {
       const user = await fetchUser(args.userId);
       return { status: 'success', result: JSON.stringify(user) };
@@ -623,8 +623,8 @@ export default defineTool(
         error: \`Failed to fetch user: \${error.message}\`,
       };
     }
-  }
-);
+  },
+});
 \`\`\`
 
 ## Queueing Additional Tools
@@ -634,21 +634,21 @@ Queue another tool to run after the current one:
 \`\`\`typescript
 import { queueTool } from '@standardagents/builder';
 
-export default defineTool(
-  'Create order and send confirmation',
-  z.object({ items: z.array(z.string()) }),
-  async (flow, args) => {
+export default defineTool({
+  description: 'Create order and send confirmation',
+  args: z.object({ items: z.array(z.string()) }),
+  execute: async (state, args) => {
     const order = await createOrder(args.items);
 
     // Queue email tool to run next
-    queueTool(flow, 'send_confirmation_email', {
+    queueTool(state, 'send_confirmation_email', {
       orderId: order.id,
-      email: flow.thread.metadata.userEmail,
+      email: state.thread.metadata.userEmail,
     });
 
     return { status: 'success', result: JSON.stringify(order) };
-  }
-);
+  },
+});
 \`\`\`
 
 ## Injecting Messages
@@ -658,17 +658,61 @@ Add messages without triggering re-execution:
 \`\`\`typescript
 import { injectMessage } from '@standardagents/builder';
 
-export default defineTool(
-  'Log audit event',
-  z.object({ event: z.string() }),
-  async (flow, args) => {
-    await injectMessage(flow, {
+export default defineTool({
+  description: 'Log audit event',
+  args: z.object({ event: z.string() }),
+  execute: async (state, args) => {
+    await injectMessage(state, {
       role: 'system',
       content: \`[AUDIT] \${args.event}\`,
     });
     return { status: 'success', result: 'Logged' };
-  }
-);
+  },
+});
+\`\`\`
+
+## Thread Environment Variables (tenvs)
+
+Tools can declare required thread environment variables:
+
+\`\`\`typescript
+export default defineTool({
+  description: 'Search uploaded documents',
+  args: z.object({ query: z.string() }),
+  execute: async (state, args) => {
+    const vectorStoreId = state.tenvs.vectorStoreId;
+    const results = await searchVectorStore(vectorStoreId, args.query);
+    return { status: 'success', result: JSON.stringify(results) };
+  },
+  tenvs: z.object({
+    vectorStoreId: z.string().describe('OpenAI Vector Store ID'),
+  }),
+});
+\`\`\`
+
+## Returning Attachments
+
+Tools can return file attachments (e.g., generated images):
+
+\`\`\`typescript
+export default defineTool({
+  description: 'Generate a chart from data',
+  args: z.object({ data: z.array(z.number()) }),
+  execute: async (state, args) => {
+    const chartImage = await generateChart(args.data);
+    return {
+      status: 'success',
+      result: 'Chart generated successfully',
+      attachments: [{
+        name: 'chart.png',
+        mimeType: 'image/png',
+        data: chartImage.base64,
+        width: 800,
+        height: 600,
+      }],
+    };
+  },
+});
 \`\`\`
 
 ## Best Practices
@@ -678,7 +722,7 @@ export default defineTool(
 - **Handle errors gracefully** - return error status, don't throw
 - **Use snake_case** for file names (\`search_knowledge_base.ts\`)
 - **Keep tools focused** - one task per tool
-- **Use \`flow.rootState\`** when queueing from sub-prompts
+- **Use \`state.rootState\`** when queueing from sub-prompts
 
 ## Supported Zod Types
 
@@ -982,17 +1026,19 @@ Full reference: https://docs.standardagentbuilder.com/core-concepts/api
 `;
 
 // src/commands/scaffold.ts
-var WRANGLER_TEMPLATE = (name) => `{
+var WRANGLER_TEMPLATE = (name) => {
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return `{
   "$schema": "node_modules/wrangler/config-schema.json",
   "name": "${name}",
   "main": "worker/index.ts",
-  "compatibility_date": "2025-01-01",
+  "compatibility_date": "${today}",
   "compatibility_flags": ["nodejs_compat"],
   "observability": {
     "enabled": true
   },
   "assets": {
-    "directory": "dist",
+    "directory": "dist/client",
     "not_found_handling": "single-page-application",
     "binding": "ASSETS",
     "run_worker_first": ["/**"]
@@ -1021,6 +1067,7 @@ var WRANGLER_TEMPLATE = (name) => `{
   ]
 }
 `;
+};
 var THREAD_TS = `import { DurableThread } from 'virtual:@standardagents/builder'
 
 export default class Thread extends DurableThread {}
@@ -1085,14 +1132,6 @@ async function modifyViteConfig(configPath, force) {
       logger.info("Vite config already includes Standard Agents plugins");
       return true;
     }
-    if (!hasCloudflare || force) {
-      addVitePlugin(mod, {
-        from: "@cloudflare/vite-plugin",
-        imported: "cloudflare",
-        constructor: "cloudflare"
-      });
-      logger.success("Added cloudflare plugin to vite.config");
-    }
     if (!hasAgentBuilder || force) {
       addVitePlugin(mod, {
         from: "@standardagents/builder",
@@ -1102,6 +1141,14 @@ async function modifyViteConfig(configPath, force) {
       });
       logger.success("Added agentbuilder plugin to vite.config");
     }
+    if (!hasCloudflare || force) {
+      addVitePlugin(mod, {
+        from: "@cloudflare/vite-plugin",
+        imported: "cloudflare",
+        constructor: "cloudflare"
+      });
+      logger.success("Added cloudflare plugin to vite.config");
+    }
     await writeFile(mod, configPath);
     return true;
   } catch (error) {
@@ -1109,10 +1156,10 @@ async function modifyViteConfig(configPath, force) {
     logger.log("");
     logger.log("Please manually add the following to your vite.config.ts:");
     logger.log("");
-    logger.log(`  import { cloudflare } from '@cloudflare/vite-plugin'`);
     logger.log(`  import { agentbuilder } from '@standardagents/builder'`);
+    logger.log(`  import { cloudflare } from '@cloudflare/vite-plugin'`);
     logger.log("");
-    logger.log(`  plugins: [cloudflare(), agentbuilder({ mountPoint: '/' })]`);
+    logger.log(`  plugins: [agentbuilder({ mountPoint: '/' }), cloudflare()]`);
     logger.log("");
     return false;
   }
@@ -1161,7 +1208,7 @@ function createOrUpdateWranglerConfig(cwd, projectName, force) {
       }
       if (!config.assets) {
         const edits = modify(result, ["assets"], {
-          directory: "dist",
+          directory: "dist/client",
           not_found_handling: "single-page-application",
           binding: "ASSETS",
           run_worker_first: ["/**"]
@@ -1520,19 +1567,14 @@ function detectPackageManager() {
   if (fs3.existsSync("package-lock.json")) return "npm";
   return "npm";
 }
-function getBuilderPackageVersion() {
+function getCliVersion() {
   try {
     const __dirname2 = path3.dirname(fileURLToPath(import.meta.url));
     const pkgPath = path3.resolve(__dirname2, "../../package.json");
     const pkg2 = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
-    const version = pkg2.version;
-    const prereleaseMatch = version.match(/-([a-z]+)\./i);
-    if (prereleaseMatch) {
-      return `@${prereleaseMatch[1]}`;
-    }
-    return `@^${version}`;
+    return pkg2.version;
   } catch {
-    return "";
+    return "latest";
   }
 }
 async function selectPackageManager(detected) {
@@ -1670,31 +1712,7 @@ export default defineConfig({
     }
   }
   logger.log("");
-  logger.info("Step 2: Installing Standard Agents dependencies...");
-  logger.log("");
-  try {
-    const installCmd = pm === "npm" ? "install" : "add";
-    const devFlag = pm === "npm" ? "--save-dev" : "-D";
-    const builderVersion = getBuilderPackageVersion();
-    await runCommand(pm, [
-      installCmd,
-      devFlag,
-      "@cloudflare/vite-plugin",
-      `@standardagents/builder${builderVersion}`,
-      "wrangler",
-      "zod"
-    ], projectPath);
-  } catch (error) {
-    logger.error("Failed to install dependencies");
-    process.exit(1);
-  }
-  logger.log("");
-  logger.info("Step 3: Configuring Standard Agents...");
-  logger.log("");
-  process.chdir(projectPath);
-  await scaffold({ force: true });
-  logger.log("");
-  logger.info("Step 4: Configuring environment variables...");
+  logger.info("Step 2: Configuring environment variables...");
   logger.log("");
   const encryptionKey = crypto.randomBytes(32).toString("hex");
   let openrouterKey = "";
@@ -1729,6 +1747,44 @@ export default defineConfig({
   if (!adminPassword) {
     adminPassword = "admin";
   }
+  logger.log("");
+  logger.info("Step 3: Installing Standard Agents dependencies...");
+  logger.log("");
+  try {
+    const installCmd = pm === "npm" ? "install" : "add";
+    const devFlag = pm === "npm" ? "--save-dev" : "-D";
+    const cliVersion = getCliVersion();
+    await runCommand(pm, [
+      installCmd,
+      devFlag,
+      "@cloudflare/vite-plugin",
+      "wrangler"
+    ], projectPath);
+    const deps = [
+      `@standardagents/builder@${cliVersion}`,
+      `@standardagents/spec@${cliVersion}`,
+      `@standardagents/sip@${cliVersion}`,
+      "zod"
+    ];
+    if (openaiKey) {
+      deps.push(`@standardagents/openai@${cliVersion}`);
+    }
+    if (openrouterKey) {
+      deps.push(`@standardagents/openrouter@${cliVersion}`);
+    }
+    await runCommand(pm, [installCmd, ...deps], projectPath);
+  } catch (error) {
+    logger.error("Failed to install dependencies");
+    process.exit(1);
+  }
+  logger.log("");
+  logger.info("Step 4: Configuring Standard Agents...");
+  logger.log("");
+  process.chdir(projectPath);
+  await scaffold({ force: true });
+  logger.log("");
+  logger.info("Writing environment configuration...");
+  logger.log("");
   const devVarsLines = [
     "# Standard Agents Environment Variables",
     "# This file contains secrets for local development only",