autohand-cli 0.9.0 → 0.9.2

package/dist/{chunk-3UT7R3XV.js → chunk-CM24K6ZT.js}

@@ -1,6 +1,13 @@
 import {
   loadLocalProjectSettings
-} from "./chunk-HJIXWGQZ.js";
+} from "./chunk-JSU46T6K.js";
+import {
+  getCustomProviderConfig,
+  isCustomProviderName
+} from "./chunk-JJGDOBFL.js";
+import {
+  isAwsBedrockProviderEnabled
+} from "./chunk-H7HXRRHK.js";
 import {
   autoInitTheme,
   configureThemeSources,
@@ -8,7 +15,7 @@ import {
 } from "./chunk-NBGOIFKP.js";
 import {
   AUTOHAND_FILES
-} from "./chunk-TWQDAUZU.js";
+} from "./chunk-PG2JIU5M.js";
 
 // src/config.ts
 import fs from "fs-extra";
@@ -25,7 +32,9 @@ var DEFAULT_OPENAI_URL = "https://api.openai.com/v1";
 var DEFAULT_MLX_URL = "http://localhost:8080";
 var DEFAULT_LLMGATEWAY_URL = "https://api.llmgateway.io/v1";
 var DEFAULT_ZAI_URL = "https://api.z.ai/api/paas/v4";
+var DEFAULT_SAKANA_URL = "https://api.sakana.ai/v1";
 var DEFAULT_DEEPSEEK_URL = "https://api.deepseek.com";
+var DEFAULT_BEDROCK_REGION = "us-east-1";
 function normalizeProviderName(provider) {
   if (provider === void 0) {
     return void 0;
@@ -33,6 +42,9 @@ function normalizeProviderName(provider) {
   if (provider === "vertex") {
     return "vertexai";
   }
+  if (isCustomProviderName(provider)) {
+    return provider;
+  }
   const validProviders = [
     "openrouter",
     "ollama",
@@ -42,11 +54,13 @@ function normalizeProviderName(provider) {
     "llmgateway",
     "azure",
     "zai",
+    "sakana",
     "vertexai",
     "xai",
     "cerebras",
     "nvidia",
-    "deepseek"
+    "deepseek",
+    "bedrock"
   ];
   if (typeof provider === "string" && validProviders.includes(provider)) {
     return provider;
@@ -306,6 +320,9 @@ async function loadConfig(customPath, workspaceRoot) {
       ui: {
         theme: "dark",
         autoConfirm: false,
+        silentToolOutput: false,
+        completionReportEnabled: true,
+        activityVerbsEnabled: true,
         promptSuggestions: true
       },
       telemetry: {
@@ -355,7 +372,18 @@ function mergeWorkspaceSettings(globalConfig, workspaceSettings) {
   }
   if (workspaceSettings.model !== void 0) {
     const provider = workspaceSettings.provider || merged.provider;
-    if (provider && merged[provider]) {
+    if (provider && isCustomProviderName(provider)) {
+      const customProvider = getCustomProviderConfig(merged, provider);
+      if (customProvider) {
+        merged.customProviders = {
+          ...merged.customProviders,
+          [customProvider.id]: {
+            ...customProvider,
+            model: workspaceSettings.model
+          }
+        };
+      }
+    } else if (provider && merged[provider]) {
       merged[provider].model = workspaceSettings.model;
     }
   }
@@ -422,6 +450,16 @@ function mergeEnvVariables(config) {
       }
     };
   }
+  const envRegion = process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION;
+  if (envRegion && config.bedrock) {
+    config = {
+      ...config,
+      bedrock: {
+        ...config.bedrock,
+        region: config.bedrock.region || envRegion
+      }
+    };
+  }
   return config;
 }
 function normalizeConfig(config) {
@@ -449,6 +487,9 @@ function normalizeConfig(config) {
       ui: {
         autoConfirm: config.dry_run ?? false,
         theme: "dark",
+        silentToolOutput: false,
+        completionReportEnabled: true,
+        activityVerbsEnabled: true,
         promptSuggestions: true
       }
     };
@@ -456,7 +497,7 @@ function normalizeConfig(config) {
   return config;
 }
 function isModernConfig(config) {
-  return typeof config.openrouter === "object" || typeof config.ollama === "object" || typeof config.llamacpp === "object" || typeof config.openai === "object" || typeof config.mlx === "object" || typeof config.azure === "object" || typeof config.zai === "object" || typeof config.vertexai === "object" || typeof config.xai === "object" || typeof config.cerebras === "object" || typeof config.nvidia === "object" || typeof config.deepseek === "object";
+  return typeof config.openrouter === "object" || typeof config.ollama === "object" || typeof config.llamacpp === "object" || typeof config.openai === "object" || typeof config.mlx === "object" || typeof config.azure === "object" || typeof config.zai === "object" || typeof config.sakana === "object" || typeof config.vertexai === "object" || typeof config.xai === "object" || typeof config.cerebras === "object" || typeof config.nvidia === "object" || typeof config.deepseek === "object" || typeof config.bedrock === "object" || typeof config.customProviders === "object";
 }
 function isLegacyConfig(config) {
   return typeof config.api_key === "string";
@@ -489,6 +530,15 @@ function validateConfig(config, configPath) {
     if (config.ui.promptSuggestions !== void 0 && typeof config.ui.promptSuggestions !== "boolean") {
       throw new Error(`ui.promptSuggestions must be boolean in ${configPath}`);
     }
+    if (config.ui.completionReportEnabled !== void 0 && typeof config.ui.completionReportEnabled !== "boolean") {
+      throw new Error(`ui.completionReportEnabled must be boolean in ${configPath}`);
+    }
+    if (config.ui.activityVerbsEnabled !== void 0 && typeof config.ui.activityVerbsEnabled !== "boolean") {
+      throw new Error(`ui.activityVerbsEnabled must be boolean in ${configPath}`);
+    }
+  }
+  if (config.auth?.apiKeyHelper !== void 0 && typeof config.auth.apiKeyHelper !== "string") {
+    throw new Error(`auth.apiKeyHelper must be a string in ${configPath}`);
   }
   if (config.agent) {
     if (config.agent.toolSelectionCache !== void 0 && typeof config.agent.toolSelectionCache !== "boolean") {
@@ -548,6 +598,37 @@ function validateConfig(config, configPath) {
       }
     }
   }
+  if (config.customProviders !== void 0) {
+    if (!isPlainObject(config.customProviders)) {
+      throw new Error(`customProviders must be an object in ${configPath}`);
+    }
+    for (const [key, provider] of Object.entries(config.customProviders)) {
+      if (!isPlainObject(provider)) {
+        throw new Error(`customProviders.${key} must be an object in ${configPath}`);
+      }
+      if (provider.id !== key) {
+        throw new Error(`customProviders.${key}.id must match its config key in ${configPath}`);
+      }
+      if (typeof provider.displayName !== "string" || provider.displayName.trim() === "") {
+        throw new Error(`customProviders.${key}.displayName must be a non-empty string in ${configPath}`);
+      }
+      if (provider.apiFormat !== "openai-compatible") {
+        throw new Error(`customProviders.${key}.apiFormat must be "openai-compatible" in ${configPath}`);
+      }
+      if (typeof provider.baseUrl !== "string" || provider.baseUrl.trim() === "") {
+        throw new Error(`customProviders.${key}.baseUrl must be a non-empty string in ${configPath}`);
+      }
+      if (typeof provider.model !== "string" || provider.model.trim() === "") {
+        throw new Error(`customProviders.${key}.model must be a non-empty string in ${configPath}`);
+      }
+      if (provider.apiKeyRequired !== void 0 && typeof provider.apiKeyRequired !== "boolean") {
+        throw new Error(`customProviders.${key}.apiKeyRequired must be boolean in ${configPath}`);
+      }
+      if (provider.contextWindow !== void 0 && (typeof provider.contextWindow !== "number" || provider.contextWindow <= 0)) {
+        throw new Error(`customProviders.${key}.contextWindow must be a positive number in ${configPath}`);
+      }
+    }
+  }
 }
 function resolveWorkspaceRoot(config, requestedPath) {
   const candidate = requestedPath ?? process.cwd() ?? config.workspace?.defaultRoot;
@@ -555,6 +636,30 @@ function resolveWorkspaceRoot(config, requestedPath) {
 }
 function getProviderConfig(config, provider) {
   const chosen = provider ?? config.provider ?? "openrouter";
+  if (isCustomProviderName(chosen)) {
+    const entry2 = getCustomProviderConfig(config, chosen);
+    if (!entry2 || entry2.apiFormat !== "openai-compatible") {
+      return null;
+    }
+    const model = entry2.model?.trim();
+    const baseUrl = entry2.baseUrl?.trim();
+    const requiresApiKey = entry2.apiKeyRequired !== false;
+    if (!model || !baseUrl) {
+      return null;
+    }
+    if (requiresApiKey && (!entry2.apiKey || entry2.apiKey === "replace-me")) {
+      return null;
+    }
+    return {
+      ...entry2,
+      model,
+      baseUrl
+    };
+  }
+  if (chosen === "bedrock" && !isAwsBedrockProviderEnabled(config)) {
+    return null;
+  }
+  const builtInProvider = chosen;
   const configByProvider = {
     openrouter: config.openrouter,
     ollama: config.ollama,
@@ -564,13 +669,15 @@ function getProviderConfig(config, provider) {
     llmgateway: config.llmgateway,
     azure: config.azure,
     zai: config.zai,
+    sakana: config.sakana,
     vertexai: config.vertexai,
     xai: config.xai,
     cerebras: config.cerebras,
     nvidia: config.nvidia,
-    deepseek: config.deepseek
+    deepseek: config.deepseek,
+    bedrock: config.bedrock
   };
-  const entry = configByProvider[chosen];
+  const entry = configByProvider[builtInProvider];
   if (!entry) {
     return null;
   }
@@ -588,22 +695,24 @@ function getProviderConfig(config, provider) {
         return null;
       }
     }
-  } else if (chosen === "openrouter" || chosen === "llmgateway" || chosen === "zai" || chosen === "nvidia" || chosen === "deepseek") {
+  } else if (builtInProvider === "openrouter" || builtInProvider === "llmgateway" || builtInProvider === "zai" || builtInProvider === "sakana" || builtInProvider === "nvidia" || builtInProvider === "deepseek") {
     const { apiKey, model } = entry;
     if (!apiKey || apiKey === "replace-me" || !model) {
       return null;
     }
-  } else if (chosen === "vertexai") {
+  } else if (builtInProvider === "vertexai") {
     const { authToken, projectId, model } = entry;
     if (!authToken || !projectId || !model) {
       return null;
     }
+  } else if (builtInProvider === "bedrock") {
+    return normalizeBedrockProviderConfig(entry);
   } else {
-    if (chosen === "llamacpp") {
+    if (builtInProvider === "llamacpp") {
       return {
         ...entry,
         model: entry.model ?? "local",
-        baseUrl: entry.baseUrl ?? defaultBaseUrlFor(chosen, entry.port)
+        baseUrl: entry.baseUrl ?? defaultBaseUrlFor(builtInProvider, entry.port)
       };
     }
     if (!entry.model) {
@@ -612,13 +721,14 @@ function getProviderConfig(config, provider) {
   }
   return {
     ...entry,
-    baseUrl: entry.baseUrl ?? defaultBaseUrlFor(chosen, entry.port)
+    baseUrl: entry.baseUrl ?? defaultBaseUrlFor(builtInProvider, entry.port)
   };
 }
 function defaultBaseUrlFor(provider, port) {
   if (provider === "openrouter") return DEFAULT_BASE_URL;
   if (provider === "llmgateway") return DEFAULT_LLMGATEWAY_URL;
   if (provider === "zai") return DEFAULT_ZAI_URL;
+  if (provider === "sakana") return DEFAULT_SAKANA_URL;
   if (provider === "deepseek") return DEFAULT_DEEPSEEK_URL;
   const p = port ? port.toString() : void 0;
   switch (provider) {
@@ -632,10 +742,33 @@ function defaultBaseUrlFor(provider, port) {
       return p ? `http://localhost:${p}` : DEFAULT_MLX_URL;
     case "nvidia":
       return "https://integrate.api.nvidia.com/v1";
+    case "bedrock":
+      return `https://bedrock-runtime.${DEFAULT_BEDROCK_REGION}.amazonaws.com`;
     default:
       return void 0;
   }
 }
+function normalizeBedrockProviderConfig(entry) {
+  const model = entry.model?.trim();
+  const region = entry.region?.trim() || process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || DEFAULT_BEDROCK_REGION;
+  const apiMode = entry.apiMode ?? "converse";
+  const authMode = entry.authMode ?? (apiMode === "converse" ? "aws-credentials" : "bedrock-api-key");
+  const endpoint = entry.endpoint?.replace(/\/+$/, "") ?? (apiMode === "converse" ? `https://bedrock-runtime.${region}.amazonaws.com` : `https://bedrock-runtime.${region}.amazonaws.com/openai/v1`);
+  if (!model || !region) {
+    return null;
+  }
+  if (authMode === "bedrock-api-key" && (!entry.apiKey || entry.apiKey === "replace-me")) {
+    return null;
+  }
+  return {
+    ...entry,
+    model,
+    region,
+    apiMode,
+    authMode,
+    endpoint
+  };
+}
 async function saveConfig(config) {
   const { configPath, ...data } = config;
   delete data.isNewConfig;

package/dist/chunk-CMEZ42F2.cjs

@@ -0,0 +1,303 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/onboarding/agentsGenerator.ts
+var AgentsGenerator = class {
+  /**
+   * Generate AGENTS.md content
+   */
+  generateContent(info, options) {
+    const sections = [];
+    sections.push("# AGENTS.md");
+    sections.push("");
+    sections.push("This file helps Autohand understand how to work with this project.");
+    sections.push("");
+    sections.push(this.generateProjectOverview(info));
+    if (info.packageManager) {
+      sections.push(this.generateCommandsSection(info));
+    }
+    if (info.testFramework) {
+      sections.push(this.generateTestingSection(info));
+    }
+    if (info.framework) {
+      const frameworkSection = this.generateFrameworkSection(info);
+      if (frameworkSection) {
+        sections.push(frameworkSection);
+      }
+    }
+    sections.push(this.generateInstructionSourcesSection());
+    sections.push(this.generateCodeStyleSection(info));
+    sections.push(this.generateConstraintsSection());
+    if (_optionalChain([options, 'optionalAccess', _ => _.customSections])) {
+      for (const section of options.customSections) {
+        sections.push(`## ${section.title}`);
+        sections.push("");
+        sections.push(section.content);
+        sections.push("");
+      }
+    }
+    return sections.join("\n");
+  }
+  /**
+   * Generate project overview section
+   */
+  generateProjectOverview(info) {
+    const lines = [];
+    lines.push("## Project Overview");
+    lines.push("");
+    if (info.language) {
+      lines.push(`- **Language**: ${info.language}`);
+    }
+    if (info.framework) {
+      lines.push(`- **Framework**: ${info.framework}`);
+    }
+    if (info.packageManager) {
+      lines.push(`- **Package Manager**: ${info.packageManager}`);
+    }
+    if (info.testFramework) {
+      lines.push(`- **Test Framework**: ${info.testFramework}`);
+    }
+    if (info.buildTool) {
+      lines.push(`- **Build Tool**: ${info.buildTool}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate commands section based on package manager
+   */
+  generateCommandsSection(info) {
+    const lines = [];
+    lines.push("## Commands");
+    lines.push("");
+    const pm = info.packageManager;
+    if (info.language === "Rust") {
+      lines.push("- **Build**: `cargo build`");
+      lines.push("- **Build (release)**: `cargo build --release`");
+      lines.push("- **Run**: `cargo run`");
+      lines.push("- **Test**: `cargo test`");
+      lines.push("- **Check**: `cargo check`");
+      lines.push("- **Format**: `cargo fmt`");
+      lines.push("- **Lint**: `cargo clippy`");
+    } else if (info.language === "Go") {
+      lines.push("- **Build**: `go build`");
+      lines.push("- **Run**: `go run .`");
+      lines.push("- **Test**: `go test ./...`");
+      lines.push("- **Format**: `go fmt ./...`");
+      lines.push("- **Vet**: `go vet ./...`");
+    } else if (info.language === "Python") {
+      if (pm === "poetry") {
+        lines.push("- **Install**: `poetry install`");
+        lines.push("- **Run**: `poetry run python main.py`");
+        lines.push("- **Add dependency**: `poetry add <package>`");
+        if (info.testFramework) {
+          lines.push(`- **Test**: \`poetry run pytest\``);
+        }
+      } else if (pm === "pipenv") {
+        lines.push("- **Install**: `pipenv install`");
+        lines.push("- **Run**: `pipenv run python main.py`");
+        if (info.testFramework) {
+          lines.push(`- **Test**: \`pipenv run pytest\``);
+        }
+      } else {
+        lines.push("- **Install**: `pip install -r requirements.txt`");
+        lines.push("- **Run**: `python main.py`");
+        if (info.testFramework) {
+          lines.push(`- **Test**: \`pytest\``);
+        }
+      }
+    } else {
+      const run = pm === "npm" ? "npm run" : pm;
+      const install = pm === "npm" ? "npm install" : `${pm} install`;
+      lines.push(`- **Install**: \`${install}\``);
+      lines.push(`- **Dev**: \`${run} dev\``);
+      lines.push(`- **Build**: \`${run} build\``);
+      if (info.testFramework) {
+        lines.push(`- **Test**: \`${run} test\``);
+      }
+      if (info.linter) {
+        lines.push(`- **Lint**: \`${run} lint\``);
+      }
+      if (info.formatter) {
+        lines.push(`- **Format**: \`${run} format\``);
+      }
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate testing section
+   */
+  generateTestingSection(info) {
+    const lines = [];
+    lines.push("## Testing");
+    lines.push("");
+    lines.push(`This project uses **${info.testFramework}** for testing.`);
+    lines.push("");
+    lines.push("- Write tests for new features before implementation");
+    lines.push("- Run tests before committing changes");
+    lines.push("- Aim for good test coverage on critical paths");
+    if (info.testFramework === "Vitest" || info.testFramework === "Jest") {
+      lines.push("- Use `describe` and `it` blocks to organize tests");
+      lines.push("- Mock external dependencies when appropriate");
+    } else if (info.testFramework === "pytest") {
+      lines.push("- Use fixtures for shared test setup");
+      lines.push("- Use `pytest.mark` for test categorization");
+    } else if (info.testFramework === "Playwright" || info.testFramework === "Cypress") {
+      lines.push("- Write E2E tests for critical user flows");
+      lines.push("- Keep selectors stable and meaningful");
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate framework-specific section
+   */
+  generateFrameworkSection(info) {
+    const lines = [];
+    switch (info.framework) {
+      case "Next.js":
+        lines.push("## Next.js Guidelines");
+        lines.push("");
+        lines.push("- Use the App Router for new pages (`app/` directory)");
+        lines.push("- Prefer Server Components by default");
+        lines.push('- Use `"use client"` only when needed for interactivity');
+        lines.push("- Keep API routes in `app/api/`");
+        lines.push("- Use `next/image` for optimized images");
+        lines.push("- Use `next/link` for client-side navigation");
+        break;
+      case "React":
+        lines.push("## React Guidelines");
+        lines.push("");
+        lines.push("- Use functional components with hooks");
+        lines.push("- Keep components small and focused");
+        lines.push("- Use custom hooks to share logic");
+        lines.push("- Prefer composition over inheritance");
+        lines.push("- Use TypeScript interfaces for props");
+        break;
+      case "Vue":
+        lines.push("## Vue Guidelines");
+        lines.push("");
+        lines.push("- Use Composition API for new components");
+        lines.push("- Keep components in single-file format (.vue)");
+        lines.push("- Use composables to share logic");
+        break;
+      case "Express":
+        lines.push("## Express Guidelines");
+        lines.push("");
+        lines.push("- Use middleware for cross-cutting concerns");
+        lines.push("- Keep route handlers thin, delegate to services");
+        lines.push("- Use async/await with proper error handling");
+        lines.push("- Validate request input before processing");
+        break;
+      case "FastAPI":
+        lines.push("## FastAPI Guidelines");
+        lines.push("");
+        lines.push("- Use Pydantic models for request/response validation");
+        lines.push("- Use dependency injection for shared resources");
+        lines.push("- Keep endpoints in organized routers");
+        lines.push("- Use async functions for I/O operations");
+        break;
+      case "Django":
+        lines.push("## Django Guidelines");
+        lines.push("");
+        lines.push("- Follow Django project structure conventions");
+        lines.push("- Use class-based views where appropriate");
+        lines.push("- Keep business logic in models or services");
+        lines.push("- Use Django ORM for database operations");
+        break;
+      case "Flask":
+        lines.push("## Flask Guidelines");
+        lines.push("");
+        lines.push("- Use blueprints to organize routes");
+        lines.push("- Keep route handlers focused");
+        lines.push("- Use Flask extensions for common functionality");
+        break;
+      case "NestJS":
+        lines.push("## NestJS Guidelines");
+        lines.push("");
+        lines.push("- Follow module-based architecture");
+        lines.push("- Use dependency injection");
+        lines.push("- Use decorators for metadata");
+        lines.push("- Keep controllers thin, services fat");
+        break;
+      default:
+        return null;
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate instruction sources section
+   */
+  generateInstructionSourcesSection() {
+    const lines = [];
+    lines.push("## Instruction Sources");
+    lines.push("");
+    lines.push("- Check saved memories and preferences before implementation work.");
+    lines.push("- Follow this AGENTS.md file for repository-specific guidance.");
+    lines.push("- AGENTS.md takes precedence over CLAUDE.md when both files provide instructions.");
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate code style section
+   */
+  generateCodeStyleSection(info) {
+    const lines = [];
+    lines.push("## Code Style");
+    lines.push("");
+    if (info.language === "TypeScript") {
+      lines.push("- Use strict TypeScript settings");
+      lines.push("- Define types/interfaces for data structures");
+      lines.push("- Avoid `any` type - use `unknown` if type is truly unknown");
+      lines.push("- Use type inference where obvious");
+    } else if (info.language === "Python") {
+      lines.push("- Follow PEP 8 style guidelines");
+      lines.push("- Use type hints for function signatures");
+      lines.push("- Use docstrings for public functions");
+    } else if (info.language === "Rust") {
+      lines.push("- Follow Rust naming conventions (snake_case for functions)");
+      lines.push("- Use descriptive error types");
+      lines.push("- Prefer `Result` over panicking");
+    } else if (info.language === "Go") {
+      lines.push("- Follow Go idioms and conventions");
+      lines.push("- Use short variable names in small scopes");
+      lines.push("- Handle errors explicitly");
+    }
+    lines.push("- Follow existing patterns in the codebase");
+    lines.push("- Use meaningful variable and function names");
+    lines.push("- Add comments for complex logic");
+    lines.push("- Keep functions focused and small");
+    if (info.linter) {
+      lines.push(`- Run **${info.linter}** before committing`);
+    }
+    if (info.formatter) {
+      lines.push(`- Format code with **${info.formatter}**`);
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate constraints section
+   */
+  generateConstraintsSection() {
+    const lines = [];
+    lines.push("## Constraints");
+    lines.push("");
+    lines.push("- Do not modify files outside the project directory");
+    lines.push("- Ask before making breaking changes");
+    lines.push("- Prefer editing existing files over creating new ones");
+    lines.push("- Do not delete files without confirmation");
+    lines.push("- Keep dependencies minimal - avoid adding new ones without good reason");
+    lines.push("- Do not commit sensitive data (API keys, secrets, credentials)");
+    lines.push("");
+    return lines.join("\n");
+  }
+};
+
+
+
+exports.AgentsGenerator = AgentsGenerator;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */