@phnx-labs/agents-cli 1.12.0 → 1.14.2

package/dist/lib/models.d.ts

@@ -1,4 +1,5 @@
 import type { AgentId } from './types.js';
+/** Model identifiers per cloud provider (used by Claude's multi-cloud routing). */
 export interface ModelPerCloud {
     firstParty: string;
     bedrock?: string;
@@ -7,10 +8,12 @@ export interface ModelPerCloud {
     anthropicAws?: string;
     mantle?: string | null;
 }
+/** A reasoning effort level exposed by an agent's model. */
 export interface ReasoningLevel {
     effort: string;
     description?: string;
 }
+/** Metadata for a single model within an agent's catalog. */
 export interface ModelInfo {
     id: string;
     displayName?: string;
@@ -26,29 +29,41 @@ export interface ModelInfo {
     /** Default reasoning level if applicable */
     defaultReasoningLevel?: string;
 }
+/** The complete model catalog for a specific (agent, version) pair. */
 export interface ModelCatalog {
     agent: AgentId;
     version: string;
-    source: 'bundle' | 'binary';
+    source: ModelSourceKind;
     sourcePath: string;
     models: ModelInfo[];
-    /** Aliases from the CLI's alias map (claude only): { opus: "claude-opus-4-7", ... } */
+    /** Aliases that the CLI resolves to a canonical id (e.g. { opus: "claude-opus-4-7" } for claude, { flash: "gemini-3-flash-preview" } for gemini) */
     aliases: Record<string, string>;
 }
+/** How the model catalog source was obtained. */
+export type ModelSourceKind = 'bundle' | 'binary' | 'js' | 'cli';
+/** Describes the location and extraction strategy for a model catalog source. */
+export interface ModelSource {
+    path: string;
+    kind: ModelSourceKind;
+}
 /**
- * Locate the bundle (cli.js) or native binary that holds the installed model
- * catalog for a given (agent, version). Returns null if not found.
+ * Locate the file that authoritatively describes the installed model catalog
+ * for a given (agent, version). The `kind` tells `getModelCatalog` how to
+ * read it:
+ *   bundle/binary -- strings(1)-style extraction (claude/codex)
+ *   js            -- read + regex-parse an exported JS module (gemini)
+ *   cli           -- spawn the agent's own `models` command (opencode/cursor/openclaw)
+ *
+ * Returns null if nothing usable is found.
  */
-export declare function locateModelSource(agent: AgentId, version: string): {
-    path: string;
-    kind: 'bundle' | 'binary';
-} | null;
+export declare function locateModelSource(agent: AgentId, version: string): ModelSource | null;
 /**
  * Build (or load from cache) the model catalog for a specific (agent, version).
- * Cache is keyed on binary mtime, so re-extracts automatically when the user
- * upgrades or reinstalls a version.
+ * Cache is keyed on source-file mtime (binary or js module), so re-extracts
+ * automatically when the user upgrades or reinstalls a version.
  */
 export declare function getModelCatalog(agent: AgentId, version: string): ModelCatalog | null;
+/** The result of resolving a user-supplied model string against the catalog. */
 export interface ResolvedModel {
     /** The model string to forward to the CLI (canonical id when we can resolve, else passed through unchanged). */
     forwarded: string;
@@ -80,4 +95,3 @@ export declare function resolveModel(agent: AgentId, version: string, requested:
  * - 'auto' passes --effort auto to claude if supported.
  */
 export declare function buildReasoningFlags(agent: AgentId, level: string): string[];
-//# sourceMappingURL=models.d.ts.map

package/dist/lib/models.js

@@ -1,23 +1,47 @@
+/**
+ * Model catalog extraction, caching, and resolution for all supported agents.
+ *
+ * Each agent ships its model list differently -- Claude and Codex embed it in
+ * compiled bundles/binaries, Gemini exports it from a JS module, and OpenCode/
+ * Cursor/OpenClaw expose it via CLI commands. This module provides a unified
+ * `getModelCatalog()` and `resolveModel()` interface over all of them, backed
+ * by a file-system cache keyed on source mtime.
+ */
 import * as fs from 'fs';
 import * as path from 'path';
-import * as os from 'os';
+import { execFileSync } from 'child_process';
 import { getVersionDir } from './versions.js';
-const CACHE_PATH = path.join(os.homedir(), '.agents', '.models-cache.json');
+import { getAgentsDir } from './state.js';
+const CACHE_PATH = path.join(getAgentsDir(), '.models-cache.json');
+/**
+ * Bump when the extractor logic changes shape in an incompatible way so cached
+ * catalogs from older agents-cli builds are re-extracted.
+ */
+const CACHE_SCHEMA_VERSION = 2;
 let memoryCache = null;
 function cacheKey(agent, version) {
     return `${agent}@${version}`;
 }
+/** Load the cache file from disk (or return the in-memory copy). */
 function loadCache() {
     if (memoryCache)
         return memoryCache;
     try {
-        memoryCache = JSON.parse(fs.readFileSync(CACHE_PATH, 'utf-8'));
+        const raw = JSON.parse(fs.readFileSync(CACHE_PATH, 'utf-8'));
+        if (raw && raw.schema === CACHE_SCHEMA_VERSION && raw.entries) {
+            memoryCache = raw;
+        }
+        else {
+            // Legacy (pre-schema) or stale-schema cache -- drop it.
+            memoryCache = { schema: CACHE_SCHEMA_VERSION, entries: {} };
+        }
     }
     catch {
-        memoryCache = {};
+        memoryCache = { schema: CACHE_SCHEMA_VERSION, entries: {} };
     }
     return memoryCache;
 }
+/** Persist the in-memory cache to disk. Best-effort; failures are silent. */
 function saveCache() {
     if (!memoryCache)
         return;
@@ -32,8 +56,14 @@ function saveCache() {
     }
 }
 /**
- * Locate the bundle (cli.js) or native binary that holds the installed model
- * catalog for a given (agent, version). Returns null if not found.
+ * Locate the file that authoritatively describes the installed model catalog
+ * for a given (agent, version). The `kind` tells `getModelCatalog` how to
+ * read it:
+ *   bundle/binary -- strings(1)-style extraction (claude/codex)
+ *   js            -- read + regex-parse an exported JS module (gemini)
+ *   cli           -- spawn the agent's own `models` command (opencode/cursor/openclaw)
+ *
+ * Returns null if nothing usable is found.
  */
 export function locateModelSource(agent, version) {
     const versionDir = getVersionDir(agent, version);
@@ -63,8 +93,64 @@ export function locateModelSource(agent, version) {
         }
         return null;
     }
+    if (agent === 'gemini') {
+        // Gemini ships a clean ES module with all constants and aliases -- no need
+        // to parse the minified CLI bundle.
+        const modelsJs = path.join(versionDir, 'node_modules', '@google', 'gemini-cli-core', 'dist', 'src', 'config', 'models.js');
+        if (fs.existsSync(modelsJs))
+            return { path: modelsJs, kind: 'js' };
+        return null;
+    }
+    if (agent === 'opencode') {
+        // The `opencode` shim under node_modules/.bin dispatches to a platform-
+        // specific native binary. We don't parse the 100MB binary; we let the CLI
+        // produce its own catalog via `opencode models --verbose`.
+        const cli = path.join(versionDir, 'node_modules', '.bin', 'opencode');
+        if (fs.existsSync(cli))
+            return { path: cli, kind: 'cli' };
+        return null;
+    }
+    if (agent === 'openclaw') {
+        const cli = path.join(versionDir, 'node_modules', '.bin', 'openclaw');
+        if (fs.existsSync(cli))
+            return { path: cli, kind: 'cli' };
+        // Fallback: installed outside agents-cli version management (e.g. global npm).
+        const pathBin = findOnPath('openclaw');
+        if (pathBin)
+            return { path: pathBin, kind: 'cli' };
+        return null;
+    }
+    if (agent === 'cursor') {
+        // cursor-agent is installed via curl script, not agents-cli. Version argument
+        // is accepted for API symmetry but ignored -- cursor lives on PATH.
+        const pathBin = findOnPath('cursor-agent');
+        if (pathBin)
+            return { path: pathBin, kind: 'cli' };
+        return null;
+    }
+    return null;
+}
+/** Search PATH for a command and return its absolute path, or null. */
+function findOnPath(command) {
+    const pathEnv = process.env.PATH || '';
+    const exts = process.platform === 'win32' ? (process.env.PATHEXT || '').split(';') : [''];
+    for (const dir of pathEnv.split(path.delimiter)) {
+        if (!dir)
+            continue;
+        for (const ext of exts) {
+            const full = path.join(dir, command + ext);
+            try {
+                if (fs.statSync(full).isFile())
+                    return full;
+            }
+            catch {
+                /* not here */
+            }
+        }
+    }
     return null;
 }
+/** Map the current Node.js platform/arch pair to a Rust-style target triple. */
 function currentTargetTriple() {
     switch (`${process.platform}-${process.arch}`) {
         case 'darwin-arm64': return 'aarch64-apple-darwin';
@@ -199,10 +285,282 @@ function extractCodexCatalog(text) {
     }
     return { models, aliases: {} };
 }
+/**
+ * Extract Gemini's model catalog from `@google/gemini-cli-core/.../config/models.js`.
+ *
+ * The module exports a set of named constants (e.g. `DEFAULT_GEMINI_MODEL`,
+ * `PREVIEW_GEMINI_FLASH_MODEL`) plus a `VALID_GEMINI_MODELS` Set and a handful
+ * of `GEMINI_MODEL_ALIAS_*` strings. We parse it with regex (a JS-module import
+ * would pollute the runtime and ES-module interop is awkward from a CJS build).
+ */
+function extractGeminiCatalog(text) {
+    const constRe = /export\s+const\s+([A-Z0-9_]+)\s*=\s*'([^']+)'/g;
+    const constants = new Map();
+    let m;
+    while ((m = constRe.exec(text)) !== null) {
+        constants.set(m[1], m[2]);
+    }
+    // The set of ids the CLI accepts as "valid model names". Names (not values)
+    // are listed inside `new Set([...])`, so we expand them via the constants map.
+    const validIds = new Set();
+    const setBlock = text.match(/VALID_GEMINI_MODELS\s*=\s*new\s+Set\(\[([\s\S]*?)\]\)/);
+    if (setBlock) {
+        const nameRe = /([A-Z0-9_]+)/g;
+        let nm;
+        while ((nm = nameRe.exec(setBlock[1])) !== null) {
+            const id = constants.get(nm[1]);
+            if (id)
+                validIds.add(id);
+        }
+    }
+    // Fall back to any gemini-shaped id we saw in the constants map -- useful
+    // when the Set shape changes across gemini versions.
+    if (validIds.size === 0) {
+        for (const [name, value] of constants) {
+            if (/^(DEFAULT_|PREVIEW_)/.test(name) && /^gemini-/.test(value)) {
+                validIds.add(value);
+            }
+        }
+    }
+    // Aliases are exported as `GEMINI_MODEL_ALIAS_FLASH = 'flash'` etc. The alias
+    // is the *value*; the target model is resolved at runtime by `resolveModel()`.
+    // We replicate that logic here so callers get a concrete id per alias.
+    const defaultId = constants.get('DEFAULT_GEMINI_MODEL');
+    const previewPro = constants.get('PREVIEW_GEMINI_MODEL');
+    const previewFlash = constants.get('PREVIEW_GEMINI_FLASH_MODEL');
+    const flashLite = constants.get('DEFAULT_GEMINI_FLASH_LITE_MODEL');
+    const aliases = {};
+    if (previewPro) {
+        aliases.auto = previewPro;
+        aliases.pro = previewPro;
+    }
+    if (previewFlash)
+        aliases.flash = previewFlash;
+    if (flashLite)
+        aliases['flash-lite'] = flashLite;
+    const aliasReverse = {};
+    for (const [alias, id] of Object.entries(aliases)) {
+        (aliasReverse[id] ||= []).push(alias);
+    }
+    const defaults = new Set();
+    if (defaultId)
+        defaults.add(defaultId);
+    if (previewPro)
+        defaults.add(previewPro); // auto/pro alias resolves here
+    const displayNameFor = (id) => {
+        // Gemini has a `getDisplayString` for some aliases but the canonical id
+        // is human-readable enough ("gemini-3-pro-preview") -- no separate map.
+        return undefined;
+    };
+    const models = Array.from(validIds)
+        .sort()
+        .map((id) => ({
+        id,
+        displayName: displayNameFor(id),
+        alias: aliasReverse[id]?.[0],
+        isDefault: defaults.has(id),
+    }));
+    return { models, aliases };
+}
+/**
+ * Extract OpenCode's catalog by invoking `opencode models --verbose`. The
+ * output is a sequence of `<provider>/<id>\n{json}` blocks -- we parse every
+ * JSON block that follows a provider/id line.
+ *
+ * OpenCode caches the models.dev snapshot internally, so this is a local,
+ * non-network call after first launch.
+ */
+function extractOpenCodeCatalog(binaryPath) {
+    let stdout;
+    try {
+        stdout = execFileSync(binaryPath, ['models', '--verbose'], {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 15_000,
+            maxBuffer: 64 * 1024 * 1024,
+        });
+    }
+    catch {
+        return { models: [], aliases: {} };
+    }
+    const models = [];
+    const seen = new Set();
+    // Blocks look like:
+    //   provider/model-id
+    //   {
+    //     "id": "...", "providerID": "...", "name": "...", ...
+    //   }
+    // Walk forward finding `{` at column 0 that terminates with a `}` at column 0.
+    const lines = stdout.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!/^[a-z0-9][a-z0-9.-]*\/[^\s]+$/i.test(line))
+            continue;
+        const fullKey = line;
+        // Find the opening `{` right after this line, collect until matching `}`.
+        let start = -1;
+        for (let j = i + 1; j < lines.length; j++) {
+            if (lines[j] === '{') {
+                start = j;
+                break;
+            }
+            if (lines[j].trim() !== '')
+                break;
+        }
+        if (start === -1)
+            continue;
+        let depth = 0;
+        let end = -1;
+        for (let j = start; j < lines.length; j++) {
+            for (const ch of lines[j]) {
+                if (ch === '{')
+                    depth++;
+                else if (ch === '}')
+                    depth--;
+            }
+            if (depth === 0) {
+                end = j;
+                break;
+            }
+        }
+        if (end === -1)
+            continue;
+        const json = lines.slice(start, end + 1).join('\n');
+        try {
+            const obj = JSON.parse(json);
+            if (seen.has(fullKey))
+                continue;
+            seen.add(fullKey);
+            // obj.status can be "active" | "deprecated" | "preview" -- surface only
+            // when it isn't the default so the consumer can flag stale models.
+            const nonDefaultStatus = obj.status && obj.status !== 'active' ? obj.status : undefined;
+            models.push({
+                id: fullKey,
+                displayName: obj.name,
+                description: nonDefaultStatus,
+            });
+        }
+        catch {
+            /* skip malformed block */
+        }
+        i = end;
+    }
+    // Second pass: if --verbose produced nothing, fall back to the plain list.
+    if (models.length === 0) {
+        try {
+            const plain = execFileSync(binaryPath, ['models'], {
+                encoding: 'utf-8',
+                stdio: ['ignore', 'pipe', 'ignore'],
+                timeout: 10_000,
+                maxBuffer: 16 * 1024 * 1024,
+            });
+            for (const raw of plain.split('\n')) {
+                const id = raw.trim();
+                if (!id || !/^[a-z0-9][a-z0-9.-]*\/[^\s]+$/i.test(id))
+                    continue;
+                if (seen.has(id))
+                    continue;
+                seen.add(id);
+                models.push({ id });
+            }
+        }
+        catch {
+            /* leave empty */
+        }
+    }
+    return { models, aliases: {} };
+}
+/**
+ * Extract Cursor's catalog via `cursor-agent --list-models`. Output lines look like:
+ *   `auto - Auto`
+ *   `composer-2-fast - Composer 2 Fast  (current, default)`
+ *   `gpt-5.3-codex - Codex 5.3`
+ */
+function extractCursorCatalog(binaryPath) {
+    let stdout;
+    try {
+        stdout = execFileSync(binaryPath, ['--list-models'], {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 15_000,
+            maxBuffer: 8 * 1024 * 1024,
+        });
+    }
+    catch {
+        return { models: [], aliases: {} };
+    }
+    // Strip ANSI escape sequences; cursor renders a loading spinner.
+    // eslint-disable-next-line no-control-regex
+    const plain = stdout.replace(/\x1b\[[0-9;]*[A-Za-z]/g, '');
+    const models = [];
+    const seen = new Set();
+    for (const raw of plain.split('\n')) {
+        const line = raw.trim();
+        if (!line)
+            continue;
+        // Expect `id - display[  (flag1, flag2, ...)]`
+        const m = line.match(/^([A-Za-z0-9][A-Za-z0-9.\-_]*)\s+-\s+(.+)$/);
+        if (!m)
+            continue;
+        const id = m[1];
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        const rest = m[2];
+        const flagMatch = rest.match(/\s+\(([^)]+)\)\s*$/);
+        const flags = flagMatch ? flagMatch[1].split(',').map((s) => s.trim().toLowerCase()) : [];
+        const displayName = (flagMatch ? rest.slice(0, flagMatch.index) : rest).trim();
+        models.push({
+            id,
+            displayName,
+            isDefault: flags.includes('default'),
+        });
+    }
+    return { models, aliases: {} };
+}
+/**
+ * Extract OpenClaw's catalog via `openclaw models list --all --json`. OpenClaw
+ * bundles its own models.dev-like snapshot and exposes a stable JSON shape.
+ */
+function extractOpenClawCatalog(binaryPath) {
+    let stdout;
+    try {
+        stdout = execFileSync(binaryPath, ['models', 'list', '--all', '--json'], {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 20_000,
+            maxBuffer: 64 * 1024 * 1024,
+        });
+    }
+    catch {
+        return { models: [], aliases: {} };
+    }
+    // OpenClaw prefaces output with a banner line on stderr; stdout should be
+    // pure JSON, but be defensive and skip preface text if any slipped through.
+    const firstBrace = stdout.indexOf('{');
+    if (firstBrace === -1)
+        return { models: [], aliases: {} };
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout.slice(firstBrace));
+    }
+    catch {
+        return { models: [], aliases: {} };
+    }
+    const rawModels = Array.isArray(parsed?.models) ? parsed.models : [];
+    const models = rawModels
+        .filter((m) => typeof m?.key === 'string')
+        .map((m) => ({
+        id: m.key,
+        displayName: typeof m.name === 'string' ? m.name : undefined,
+        isDefault: m.available === true && m.tags?.includes?.('default'),
+    }));
+    return { models, aliases: {} };
+}
 /**
  * Build (or load from cache) the model catalog for a specific (agent, version).
- * Cache is keyed on binary mtime, so re-extracts automatically when the user
- * upgrades or reinstalls a version.
+ * Cache is keyed on source-file mtime (binary or js module), so re-extracts
+ * automatically when the user upgrades or reinstalls a version.
  */
 export function getModelCatalog(agent, version) {
     const src = locateModelSource(agent, version);
@@ -217,14 +575,37 @@ export function getModelCatalog(agent, version) {
     }
     const cache = loadCache();
     const key = cacheKey(agent, version);
-    const cached = cache[key];
+    const cached = cache.entries[key];
     if (cached && cached.sourcePath === src.path && cached.mtime === mtime) {
         return cached.catalog;
     }
-    const text = extractStrings(src.path);
-    const { models, aliases } = agent === 'claude' ? extractClaudeCatalog(text)
-        : agent === 'codex' ? extractCodexCatalog(text)
-            : { models: [], aliases: {} };
+    let models = [];
+    let aliases = {};
+    if (src.kind === 'bundle' || src.kind === 'binary') {
+        const text = extractStrings(src.path);
+        ({ models, aliases } =
+            agent === 'claude' ? extractClaudeCatalog(text)
+                : agent === 'codex' ? extractCodexCatalog(text)
+                    : { models: [], aliases: {} });
+    }
+    else if (src.kind === 'js') {
+        try {
+            const text = fs.readFileSync(src.path, 'utf-8');
+            if (agent === 'gemini')
+                ({ models, aliases } = extractGeminiCatalog(text));
+        }
+        catch {
+            /* unreadable */
+        }
+    }
+    else if (src.kind === 'cli') {
+        if (agent === 'opencode')
+            ({ models, aliases } = extractOpenCodeCatalog(src.path));
+        else if (agent === 'cursor')
+            ({ models, aliases } = extractCursorCatalog(src.path));
+        else if (agent === 'openclaw')
+            ({ models, aliases } = extractOpenClawCatalog(src.path));
+    }
     const catalog = {
         agent,
         version,
@@ -233,8 +614,14 @@ export function getModelCatalog(agent, version) {
         models,
         aliases,
     };
-    cache[key] = { sourcePath: src.path, mtime, catalog };
-    saveCache();
+    // Don't cache empty CLI extractions: the CLI may have been mid-install,
+    // network-dependent, or transiently failing. Caching 0 models would mask
+    // the real catalog forever (mtime won't change). Bundle/binary/js sources
+    // are deterministic, so cache those even when empty.
+    if (src.kind !== 'cli' || models.length > 0) {
+        cache.entries[key] = { sourcePath: src.path, mtime, catalog };
+        saveCache();
+    }
     return catalog;
 }
 /**
@@ -274,6 +661,7 @@ export function resolveModel(agent, version, requested) {
         warning: `model "${requested}" not in known catalog for ${agent}@${version}; forwarding as-is${hint}`,
     };
 }
+/** Find the closest matching model ids/aliases using edit distance. */
 function pickSuggestions(requested, catalog) {
     const all = [...catalog.models.map((m) => m.id), ...Object.keys(catalog.aliases)];
     return all
@@ -283,6 +671,7 @@ function pickSuggestions(requested, catalog) {
         .slice(0, 3)
         .map((s) => s.id);
 }
+/** Normalized Levenshtein similarity (0..1, where 1 is identical). */
 function similarity(a, b) {
     const longer = a.length >= b.length ? a : b;
     const shorter = a.length >= b.length ? b : a;
@@ -291,6 +680,7 @@ function similarity(a, b) {
     const distance = levenshtein(longer, shorter);
     return (longer.length - distance) / longer.length;
 }
+/** Standard Levenshtein edit distance between two strings. */
 function levenshtein(a, b) {
     const m = a.length;
     const n = b.length;
@@ -335,4 +725,3 @@ export function buildReasoningFlags(agent, level) {
     }
     return [];
 }
-//# sourceMappingURL=models.js.map

package/dist/lib/onepassword.d.ts

@@ -0,0 +1,63 @@
+/**
+ * 1Password CLI (op) integration for importing secrets from vaults.
+ */
+export interface OpVault {
+    id: string;
+    name: string;
+}
+export interface OpItemSummary {
+    id: string;
+    title: string;
+    category: string;
+    vault: {
+        id: string;
+        name: string;
+    };
+}
+export interface OpField {
+    id: string;
+    label: string;
+    type: string;
+    value?: string;
+    purpose?: string;
+}
+export interface OpItem extends OpItemSummary {
+    fields: OpField[];
+}
+export interface ImportableSecret {
+    envKey: string;
+    itemTitle: string;
+    fieldLabel: string;
+    value: string;
+}
+export interface SkippedField {
+    itemTitle: string;
+    fieldLabel: string;
+    reason: string;
+}
+export declare function assertOpAvailable(): void;
+export declare function listVaults(): OpVault[];
+export declare function listItems(vaultName: string): OpItemSummary[];
+export declare function getItem(itemId: string, vaultName: string): OpItem;
+export declare function toEnvKey(title: string): string;
+export declare function slugify(name: string): string;
+export declare function extractSecrets(items: OpItemSummary[], vaultName: string): {
+    secrets: ImportableSecret[];
+    skipped: SkippedField[];
+};
+export interface PasswordItemTemplate {
+    title: string;
+    category: 'PASSWORD';
+    tags: string[];
+    fields: Array<{
+        id: string;
+        type: 'CONCEALED';
+        purpose: 'PASSWORD';
+        label: string;
+        value: string;
+    }>;
+}
+export declare function buildPasswordItemTemplate(title: string, value: string): PasswordItemTemplate;
+export declare function itemExistsByTitle(title: string, vaultName: string): boolean;
+export declare function deleteItemByTitle(title: string, vaultName: string): void;
+export declare function createPasswordItem(title: string, value: string, vaultName: string): void;