@vicoa/opencode 0.1.0 → 0.1.2

package/dist/format-utils.js

@@ -1,335 +0,0 @@
-const LANGUAGE_MAP = {
-    py: 'python',
-    js: 'javascript',
-    ts: 'typescript',
-    jsx: 'jsx',
-    tsx: 'tsx',
-    java: 'java',
-    cpp: 'cpp',
-    c: 'c',
-    cs: 'csharp',
-    rb: 'ruby',
-    go: 'go',
-    rs: 'rust',
-    php: 'php',
-    swift: 'swift',
-    kt: 'kotlin',
-    yaml: 'yaml',
-    yml: 'yaml',
-    json: 'json',
-    xml: 'xml',
-    html: 'html',
-    css: 'css',
-    scss: 'scss',
-    sql: 'sql',
-    sh: 'bash',
-    bash: 'bash',
-    md: 'markdown',
-    txt: 'text',
-};
-function truncateText(text, maxLength = 100) {
-    if (text.length <= maxLength) {
-        return text;
-    }
-    return `${text.slice(0, maxLength)}...`;
-}
-function detectLanguage(filePath) {
-    const extension = filePath.includes('.') ? filePath.split('.').pop() ?? '' : '';
-    return LANGUAGE_MAP[extension] ?? '';
-}
-function getString(input, keys, fallback = '') {
-    for (const key of keys) {
-        const value = input[key];
-        if (typeof value === 'string') {
-            return value;
-        }
-    }
-    return fallback;
-}
-function getBoolean(input, keys, fallback = false) {
-    for (const key of keys) {
-        const value = input[key];
-        if (typeof value === 'boolean') {
-            return value;
-        }
-    }
-    return fallback;
-}
-function getArray(input, keys) {
-    for (const key of keys) {
-        const value = input[key];
-        if (Array.isArray(value)) {
-            return value;
-        }
-    }
-    return [];
-}
-function formatDiffBlock(oldText, newText) {
-    const diffLines = ['```diff'];
-    if (!oldText && newText) {
-        for (const line of newText.split('\n')) {
-            diffLines.push(`+ ${line}`);
-        }
-    }
-    else if (oldText && !newText) {
-        for (const line of oldText.split('\n')) {
-            diffLines.push(`- ${line}`);
-        }
-    }
-    else {
-        const oldLines = oldText.split('\n');
-        const newLines = newText.split('\n');
-        const commonPrefix = [];
-        const commonSuffix = [];
-        for (let i = 0; i < Math.min(oldLines.length, newLines.length); i += 1) {
-            if (oldLines[i] === newLines[i]) {
-                commonPrefix.push(oldLines[i]);
-            }
-            else {
-                break;
-            }
-        }
-        const oldRemaining = oldLines.slice(commonPrefix.length);
-        const newRemaining = newLines.slice(commonPrefix.length);
-        if (oldRemaining.length && newRemaining.length) {
-            for (let i = 1; i <= Math.min(oldRemaining.length, newRemaining.length); i += 1) {
-                if (oldRemaining[oldRemaining.length - i] === newRemaining[newRemaining.length - i]) {
-                    commonSuffix.unshift(oldRemaining[oldRemaining.length - i]);
-                }
-                else {
-                    break;
-                }
-            }
-        }
-        const changedOld = commonSuffix.length
-            ? oldRemaining.slice(0, oldRemaining.length - commonSuffix.length)
-            : oldRemaining;
-        const changedNew = commonSuffix.length
-            ? newRemaining.slice(0, newRemaining.length - commonSuffix.length)
-            : newRemaining;
-        if ((commonPrefix.length || commonSuffix.length) && (changedOld.length || changedNew.length)) {
-            const contextBefore = commonPrefix.slice(-2);
-            const contextAfter = commonSuffix.slice(0, 2);
-            for (const line of contextBefore) {
-                diffLines.push(`  ${line}`);
-            }
-            for (const line of changedOld) {
-                diffLines.push(`- ${line}`);
-            }
-            for (const line of changedNew) {
-                diffLines.push(`+ ${line}`);
-            }
-            for (const line of contextAfter) {
-                diffLines.push(`  ${line}`);
-            }
-        }
-        else {
-            for (const line of oldLines) {
-                diffLines.push(`- ${line}`);
-            }
-            for (const line of newLines) {
-                diffLines.push(`+ ${line}`);
-            }
-        }
-    }
-    diffLines.push('```');
-    return diffLines;
-}
-export function formatToolUsage(toolName, inputData) {
-    if (toolName.startsWith('mcp__vicoa__')) {
-        return `Using tool: ${toolName}`;
-    }
-    const normalizedTool = toolName.toLowerCase();
-    if (normalizedTool === 'write') {
-        const filePath = getString(inputData, ['file_path', 'filePath', 'path', 'filename'], 'unknown');
-        const content = getString(inputData, ['content', 'text', 'value']);
-        const lang = detectLanguage(filePath);
-        return [`Using tool: Write - \`${filePath}\``, `\`\`\`${lang}`, content, '```']
-            .filter((line) => line.length > 0)
-            .join('\n');
-    }
-    if (normalizedTool === 'read' || normalizedTool === 'notebookread' || normalizedTool === 'notebookedit') {
-        const filePath = getString(inputData, ['file_path', 'filePath', 'path', 'notebook_path'], 'unknown');
-        return `Using tool: ${toolName} - \`${filePath}\``;
-    }
-    if (normalizedTool === 'edit') {
-        const filePath = getString(inputData, ['file_path', 'filePath', 'path'], 'unknown');
-        const oldString = getString(inputData, ['old_string', 'oldString']);
-        const newString = getString(inputData, ['new_string', 'newString']);
-        const replaceAll = getBoolean(inputData, ['replace_all', 'replaceAll']);
-        const diffLines = [`Using tool: **Edit** - \`${filePath}\``];
-        if (replaceAll) {
-            diffLines.push('*Replacing all occurrences*');
-        }
-        diffLines.push('');
-        diffLines.push(...formatDiffBlock(oldString, newString));
-        return diffLines.join('\n');
-    }
-    if (normalizedTool === 'multiedit') {
-        const filePath = getString(inputData, ['file_path', 'filePath', 'path'], 'unknown');
-        const edits = getArray(inputData, ['edits']);
-        const lines = [
-            `Using tool: **MultiEdit** - \`${filePath}\``,
-            `*Making ${edits.length} edit${edits.length === 1 ? '' : 's'}:*`,
-            '',
-        ];
-        edits.forEach((edit, index) => {
-            const editIndex = index + 1;
-            const oldString = typeof edit.old_string === 'string' ? edit.old_string : edit.oldString ?? '';
-            const newString = typeof edit.new_string === 'string' ? edit.new_string : edit.newString ?? '';
-            const replaceAll = Boolean(edit.replace_all ?? edit.replaceAll ?? false);
-            lines.push(replaceAll ? `### Edit ${editIndex} *(replacing all occurrences)*` : `### Edit ${editIndex}`);
-            lines.push('');
-            lines.push(...formatDiffBlock(oldString, newString));
-            lines.push('');
-        });
-        return lines.join('\n');
-    }
-    if (normalizedTool === 'bash') {
-        const command = getString(inputData, ['command', 'cmd']);
-        return `Using tool: Bash - \`${command}\``;
-    }
-    if (normalizedTool === 'grep' || normalizedTool === 'glob') {
-        const pattern = getString(inputData, ['pattern', 'query'], 'unknown');
-        const path = getString(inputData, ['path', 'directory'], 'current directory');
-        return `Using tool: ${toolName} - \`${truncateText(pattern, 50)}\` in ${path}`;
-    }
-    if (normalizedTool === 'list' || normalizedTool === 'ls') {
-        const path = getString(inputData, ['path'], 'unknown');
-        return `Using tool: list - \`${path}\``;
-    }
-    if (normalizedTool === 'patch') {
-        const file = getString(inputData, ['file', 'path'], 'unknown');
-        return `Using tool: patch - \`${file}\``;
-    }
-    if (normalizedTool === 'skill') {
-        const name = getString(inputData, ['name', 'skill'], 'unknown');
-        return `Using tool: skill - \`${name}\``;
-    }
-    if (normalizedTool === 'question') {
-        const text = getString(inputData, ['text', 'question', 'message'], '');
-        return text ? `Asking: ${truncateText(text, 100)}` : 'Using tool: question';
-    }
-    if (normalizedTool === 'lsp') {
-        const command = getString(inputData, ['command', 'method'], 'unknown');
-        const file = getString(inputData, ['file', 'path'], '');
-        return file ? `Using tool: lsp - ${command} on \`${file}\`` : `Using tool: lsp - ${command}`;
-    }
-    if (normalizedTool === 'todowrite') {
-        const todos = getArray(inputData, ['todos']);
-        if (!todos.length) {
-            return 'Using tool: TodoWrite - clearing todo list';
-        }
-        const statusSymbol = {
-            pending: '○',
-            in_progress: '◐',
-            completed: '●',
-        };
-        const lines = ['Using tool: TodoWrite - Todo List', ''];
-        for (const todo of todos) {
-            const status = typeof todo.status === 'string' ? todo.status : 'pending';
-            const content = typeof todo.content === 'string' ? todo.content : '';
-            const symbol = statusSymbol[status] ?? '•';
-            lines.push(`${symbol} ${truncateText(content, 100)}`);
-        }
-        return lines.join('\n');
-    }
-    if (normalizedTool === 'todoread') {
-        return 'Using tool: todoread';
-    }
-    if (normalizedTool === 'task') {
-        const description = getString(inputData, ['description'], 'unknown task');
-        const subagentType = getString(inputData, ['subagent_type', 'subagentType', 'agent'], 'unknown');
-        return `Using tool: Task - ${truncateText(description, 50)} (agent: ${subagentType})`;
-    }
-    if (normalizedTool === 'webfetch') {
-        const url = getString(inputData, ['url'], 'unknown');
-        return `Using tool: WebFetch - \`${truncateText(url, 80)}\``;
-    }
-    if (normalizedTool === 'websearch') {
-        const query = getString(inputData, ['query'], 'unknown');
-        return `Using tool: WebSearch - ${truncateText(query, 80)}`;
-    }
-    if (toolName === 'ListMcpResourcesTool') {
-        return 'Using tool: List MCP Resources';
-    }
-    const defaultKeys = ['file', 'path', 'query', 'content', 'message', 'description', 'name'];
-    for (const key of defaultKeys) {
-        if (typeof inputData[key] === 'string') {
-            return `Using tool: ${toolName} - ${truncateText(String(inputData[key]), 50)}`;
-        }
-    }
-    return `Using tool: ${toolName}`;
-}
-// Most tool outputs don't need truncation - show them in full.
-// Only truncate for tools that tend to produce very large/noisy output.
-const TRUNCATE_OUTPUT_TOOLS = new Set(['']); // set to empty for not to filter message now.
-const TRUNCATE_LIMIT = 500;
-export function formatToolResult(output, toolName) {
-    try {
-        const parsed = JSON.parse(output);
-        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-            const keys = Object.keys(parsed).slice(0, 3);
-            const summary = `JSON object with keys: ${keys.join(', ')}`;
-            return keys.length < Object.keys(parsed).length ? `${summary} and ${Object.keys(parsed).length - keys.length} more` : summary;
-        }
-    }
-    catch {
-        // not JSON
-    }
-    // Default: don't truncate tool output unless it's in the truncate list
-    if (toolName && TRUNCATE_OUTPUT_TOOLS.has(toolName.toLowerCase())) {
-        return truncateText(output, TRUNCATE_LIMIT);
-    }
-    return output;
-}
-// Tools whose Result line is noise: either raw file/list content (read-side)
-// or a boilerplate success confirmation like "Edit applied successfully."
-// (write-side).  Only the usage line is shown for these.
-const SUPPRESS_OUTPUT_TOOLS = new Set([
-    'read', 'notebookread', 'list', 'ls', 'glob', 'grep', 'todoread', 'lsp',
-    'write', 'edit', 'multiedit', 'patch', 'notebookedit', 'todowrite',
-]);
-export function shouldSuppressToolOutput(toolName) {
-    return SUPPRESS_OUTPUT_TOOLS.has(toolName.toLowerCase());
-}
-export function formatToolPart(toolPart) {
-    const base = formatToolUsage(toolPart.tool, toolPart.state.input ?? {});
-    if (toolPart.state.status === 'completed') {
-        if (shouldSuppressToolOutput(toolPart.tool)) {
-            return base;
-        }
-        const result = toolPart.state.output ? formatToolResult(toolPart.state.output, toolPart.tool) : '[empty]';
-        return `${base}\nResult: ${result}`;
-    }
-    if (toolPart.state.status === 'error') {
-        const error = toolPart.state.error ? truncateText(toolPart.state.error, 200) : 'Unknown error';
-        return `${base}\nResult: Error - ${error}`;
-    }
-    return base;
-}
-export function formatReasoningPart(part) {
-    if (!part.text) {
-        return '';
-    }
-    return `[Thinking: ${truncateText(part.text, 200)}]`;
-}
-export function formatFilePart(part) {
-    if (part.mime?.startsWith('image/') && part.url) {
-        const altText = part.filename ?? 'image';
-        return `![${altText}](${part.url})`;
-    }
-    const source = part.source?.text?.value ?? '';
-    const path = part.source?.path ?? part.filename ?? part.url ?? 'file';
-    if (source) {
-        const lang = detectLanguage(path);
-        return [`File: \`${path}\``, `\`\`\`${lang}`, source, '```'].join('\n');
-    }
-    return `File: \`${path}\``;
-}
-export function formatPatchPart(part) {
-    if (part.files?.length) {
-        return `Patch updated: ${part.files.join(', ')}`;
-    }
-    return 'Patch updated';
-}

package/dist/message-poller.d.ts

@@ -1,16 +0,0 @@
-/**
- * Polls Vicoa backend for user messages and sends them to OpenCode
- *
- * This mimics the Claude wrapper's message queue and polling functionality.
- */
-import type { VicoaClient } from './vicoa-client.js';
-export declare class MessagePoller {
-    private client;
-    private interval;
-    private pollIntervalMs;
-    private onMessage;
-    private log;
-    constructor(client: VicoaClient, onMessage: (content: string) => Promise<void>, logFunc?: (level: string, msg: string) => void, pollIntervalMs?: number);
-    start(): void;
-    stop(): void;
-}

package/dist/message-poller.js

@@ -1,45 +0,0 @@
-/**
- * Polls Vicoa backend for user messages and sends them to OpenCode
- *
- * This mimics the Claude wrapper's message queue and polling functionality.
- */
-export class MessagePoller {
-    client;
-    interval = null;
-    pollIntervalMs;
-    onMessage;
-    log;
-    constructor(client, onMessage, logFunc, pollIntervalMs = 1000) {
-        this.client = client;
-        this.onMessage = onMessage;
-        this.pollIntervalMs = pollIntervalMs;
-        this.log = logFunc || ((level, msg) => console.log(`[${level}] ${msg}`));
-    }
-    start() {
-        if (this.interval) {
-            return;
-        }
-        this.log('info', 'Starting message poller');
-        this.interval = setInterval(async () => {
-            try {
-                const messages = await this.client.getPendingMessages();
-                for (const msg of messages) {
-                    if (msg.sender_type === 'USER' && msg.content) {
-                        this.log('debug', `Received user message: ${msg.content.substring(0, 100)}...`);
-                        await this.onMessage(msg.content);
-                    }
-                }
-            }
-            catch (error) {
-                this.log('warn', `Error polling messages: ${error}`);
-            }
-        }, this.pollIntervalMs);
-    }
-    stop() {
-        if (this.interval) {
-            clearInterval(this.interval);
-            this.interval = null;
-            this.log('info', 'Stopped message poller');
-        }
-    }
-}

package/dist/plugin/file-sync.d.ts

@@ -1,5 +0,0 @@
-import type { VicoaClient } from './vicoa-client.js';
-export declare function syncProjectFiles(vicoaClient: VicoaClient, projectPath: string): Promise<void>;
-/**
- * Sync project files to Vicoa backend for @ mentions
- */

package/dist/plugin/file-sync.js

@@ -1,187 +0,0 @@
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { formatProjectPath } from './path-utils.js';
-// Common patterns to always exclude (matching Python version)
-const DEFAULT_EXCLUDE_PATTERNS = [
-    '.git/',
-    '.pytest_cache/',
-    '.dart_tool/',
-    '.ruff_cache/',
-    '.mypy_cache/',
-    '__pycache__/',
-    'node_modules/',
-    '.venv/',
-    'venv/',
-    '.tox/',
-    '.eggs/',
-    '*.egg-info/',
-    'dist/',
-    'build/',
-    'target/', // Rust build output
-    '.next/', // Next.js
-    '.nuxt/', // Nuxt
-    'coverage/',
-    '.coverage',
-    '.nyc_output/',
-    '*.pyc',
-    '*.pyo',
-    '*.pyd',
-];
-// Extract directory names from exclude patterns
-function getExcludedDirNames() {
-    const excluded = new Set();
-    for (const pattern of DEFAULT_EXCLUDE_PATTERNS) {
-        // Skip file patterns (contain wildcards)
-        if (pattern.includes('*')) {
-            continue;
-        }
-        // Strip trailing slashes and add to set
-        const dirName = pattern.replace(/\/$/, '');
-        if (dirName) {
-            excluded.add(dirName);
-        }
-    }
-    return excluded;
-}
-// Load .gitignore patterns
-async function loadGitignorePatterns(projectPath) {
-    const gitignorePath = path.join(projectPath, '.gitignore');
-    try {
-        const content = await fs.readFile(gitignorePath, 'utf-8');
-        return content
-            .split('\n')
-            .map(line => line.trim())
-            .filter(line => line && !line.startsWith('#'));
-    }
-    catch {
-        return [];
-    }
-}
-// Simple gitignore pattern matcher (basic implementation)
-function matchesGitignorePattern(filePath, patterns) {
-    for (const pattern of patterns) {
-        const normalizedPattern = pattern.trim();
-        if (!normalizedPattern)
-            continue;
-        // Convert to regex for simple matching
-        const regexPattern = normalizedPattern
-            .replace(/\./g, '\\.')
-            .replace(/\*/g, '.*')
-            .replace(/\?/g, '.');
-        const regex = new RegExp(`^${regexPattern}`);
-        // Check both relative path and basename
-        if (regex.test(filePath) || regex.test(path.basename(filePath))) {
-            return true;
-        }
-    }
-    return false;
-}
-// Scan project files recursively
-async function scanProjectFiles(projectPath, vicoaClient, maxFiles = 100000) {
-    const base = path.resolve(projectPath);
-    try {
-        const stats = await fs.stat(base);
-        if (!stats.isDirectory()) {
-            return [];
-        }
-    }
-    catch {
-        return [];
-    }
-    const excludePatterns = [...DEFAULT_EXCLUDE_PATTERNS];
-    const gitignorePatterns = await loadGitignorePatterns(base);
-    excludePatterns.push(...gitignorePatterns);
-    const skipDirs = getExcludedDirNames();
-    const files = [];
-    const folders = new Set();
-    async function walkDirectory(dirPath, relativePath = '') {
-        try {
-            const entries = await fs.readdir(dirPath, { withFileTypes: true });
-            for (const entry of entries) {
-                // Skip excluded directories early
-                if (entry.isDirectory() && skipDirs.has(entry.name)) {
-                    continue;
-                }
-                const entryRelativePath = relativePath ? path.join(relativePath, entry.name) : entry.name;
-                const entryFullPath = path.join(dirPath, entry.name);
-                if (entry.isDirectory()) {
-                    await walkDirectory(entryFullPath, entryRelativePath);
-                    // Add folder to results (with trailing slash)
-                    const folderPath = entryRelativePath.replace(/\\/g, '/') + '/';
-                    folders.add(folderPath);
-                }
-                else if (entry.isFile()) {
-                    // Check if file should be excluded
-                    if (matchesGitignorePattern(entryRelativePath, excludePatterns)) {
-                        continue;
-                    }
-                    files.push(entryRelativePath.replace(/\\/g, '/'));
-                    // Extract parent folders
-                    const parts = entryRelativePath.split(path.sep);
-                    for (let i = 0; i < parts.length - 1; i++) {
-                        const folderPath = parts.slice(0, i + 1).join('/') + '/';
-                        folders.add(folderPath);
-                    }
-                }
-                // Stop at max_files limit
-                if (files.length >= maxFiles) {
-                    vicoaClient.log('warn', `Large project detected: ${maxFiles}+ files found`);
-                    vicoaClient.log('warn', `Only syncing first ${maxFiles} files for performance`);
-                    vicoaClient.log('warn', 'File mentions may be incomplete');
-                    return;
-                }
-            }
-        }
-        catch (error) {
-            vicoaClient.log('warn', `Error scanning directory ${dirPath}: ${error}`);
-        }
-    }
-    await walkDirectory(base);
-    // Combine folders and files
-    return Array.from(folders).concat(files);
-}
-// Sync project files to Vicoa backend
-export async function syncProjectFiles(vicoaClient, projectPath) {
-    try {
-        // Use absolute path for file scanning (needed for fs operations)
-        const absolutePath = path.resolve(projectPath);
-        vicoaClient.log('info', 'Preparing fuzzy file search with @ ...');
-        const files = await scanProjectFiles(absolutePath, vicoaClient);
-        if (files.length === 0) {
-            return; // No files to sync
-        }
-        // Send tilde path to backend (consistent with Claude wrapper)
-        const formattedPath = formatProjectPath(absolutePath);
-        await vicoaClient.syncFiles(formattedPath, files);
-        vicoaClient.log('info', `Synced ${files.length} files for fuzzy search`);
-    }
-    catch (error) {
-        vicoaClient.log('warn', `Failed to sync project files: ${error}`);
-        // Silently fail - don't block plugin startup
-    }
-}
-// Backup vicoa client api call here
-/**
- * Sync project files to Vicoa backend for @ mentions
- */
-// async syncFiles(projectPath: string, files: string[]): Promise<void> {
-//   try {
-//     const response = await fetch(`${this.config.baseUrl}/api/v1/files/sync`, {
-//       method: 'POST',
-//       headers: {
-//         'Authorization': `Bearer ${this.config.apiKey}`,
-//         'Content-Type': 'application/json',
-//       },
-//       body: JSON.stringify({
-//         project_path: projectPath,
-//         files,
-//       }),
-//     });
-//     if (!response.ok) {
-//       const error = await response.text();
-//       this.log('warn', `Failed to sync project files: ${response.statusText} - ${error}`);
-//     }
-//   } catch (error) {
-//     this.log('warn', `Error syncing project files: ${error}`);
-//   }
-// }

package/dist/vicoa-client.d.ts

@@ -1,67 +0,0 @@
-/**
- * Vicoa API client for OpenCode plugin
- *
- * This client uses Vicoa's existing REST APIs to communicate with the dashboard.
- * It mimics the Python VicoaClient functionality but runs in TypeScript/Node.js.
- */
-export interface VicoaClientConfig {
-    apiKey: string;
-    baseUrl: string;
-    agentType: string;
-    agentInstanceId: string;
-    logFunc?: (level: string, msg: string) => void;
-}
-export interface VicoaMessage {
-    id: string;
-    content: string;
-    sender_type: 'USER' | 'AGENT';
-    requires_user_input: boolean;
-    created_at: string;
-}
-export declare class VicoaClient {
-    private config;
-    lastMessageId: string | null;
-    log: (level: string, msg: string) => void;
-    constructor(config: VicoaClientConfig);
-    /**
-     * Register agent instance with Vicoa backend
-     */
-    registerAgentInstance(project: string, homeDir: string): Promise<{
-        agent_instance_id: string;
-    }>;
-    /**
-     * Sync custom slash commands to Vicoa backend
-     */
-    syncCommands(agentType: string, commands: Record<string, {
-        description: string;
-    }>): Promise<void>;
-    /**
-     * Send agent message to Vicoa dashboard
-     */
-    sendMessage(content: string, requiresUserInput?: boolean): Promise<string | null>;
-    /**
-     * Send user message from terminal to Vicoa dashboard
-     * This is used when the user types a message directly in the OpenCode terminal
-     */
-    sendUserMessage(content: string): Promise<string | null>;
-    /**
-     * Poll for pending user messages from Vicoa dashboard
-     */
-    getPendingMessages(): Promise<VicoaMessage[]>;
-    /**
-     * Request user input (equivalent to Claude wrapper's request_user_input)
-     */
-    requestUserInput(messageId: string): Promise<void>;
-    /**
-     * Update agent instance status
-     */
-    updateStatus(status: 'ACTIVE' | 'AWAITING_INPUT' | 'PAUSED' | 'STALE' | 'COMPLETED' | 'FAILED' | 'KILLED' | 'DISCONNECTED' | 'DELETED'): Promise<void>;
-    /**
-     * Update agent instance title/name
-     */
-    updateAgentInstanceName(name: string): Promise<void>;
-    /**
-     * End session
-     */
-    endSession(): Promise<void>;
-}