byterover-cli 1.5.0 → 1.7.0

package/dist/server/infra/http/authenticated-http-client.d.ts

@@ -0,0 +1,74 @@
+import type { HttpRequestConfig, IHttpClient } from '../../core/interfaces/services/i-http-client.js';
+/**
+ * HTTP client implementation that automatically adds authentication headers to all requests.
+ *
+ * This client wraps axios and automatically includes:
+ * - x-byterover-session-id: {sessionKey}
+ *
+ * Usage:
+ * ```typescript
+ * const client = new AuthenticatedHttpClient(accessToken, sessionKey)
+ * const data = await client.get<ResponseType>('https://api.example.com/endpoint')
+ * ```
+ */
+export declare class AuthenticatedHttpClient implements IHttpClient {
+    private readonly sessionKey;
+    constructor(sessionKey: string);
+    /**
+     * Performs an HTTP GET request with authentication headers.
+     * @param url The URL to request
+     * @param config Optional request configuration (headers, timeout)
+     * @returns A promise that resolves to the response data
+     * @throws Error if the request fails
+     */
+    get<T>(url: string, config?: HttpRequestConfig): Promise<T>;
+    /**
+     * Performs an HTTP POST request with authentication headers.
+     * @param url The URL to request
+     * @param data The data to send in the request body
+     * @param config Optional request configuration (headers, timeout)
+     * @returns A promise that resolves to the response data
+     * @throws Error if the request fails
+     */
+    post<TResponse, TData = unknown>(url: string, data?: TData, config?: HttpRequestConfig): Promise<TResponse>;
+    /**
+     * Performs an HTTP PUT request with authentication headers.
+     * @param url The URL to request
+     * @param data The data to send in the request body
+     * @param config Optional request configuration (headers, timeout)
+     * @returns A promise that resolves to the response data
+     * @throws Error if the request fails
+     */
+    put<TResponse, TData = unknown>(url: string, data?: TData, config?: HttpRequestConfig): Promise<TResponse>;
+    /**
+     * Builds request headers by merging authentication headers with custom headers.
+     * Custom headers take precedence over default headers.
+     */
+    private buildHeaders;
+    /**
+     * Transforms axios errors into generic Error instances.
+     * Preserves error information while abstracting axios-specific details.
+     */
+    private handleError;
+    /**
+     * Type guard to check if error is an axios error with response.
+     */
+    private isLLMServerError;
+    /**
+     * Parse HTTP error to extract user-friendly error message.
+     *
+     * Handles standardized API error responses from the server:
+     * ```json
+     * {
+     *   "statusCode": 401,
+     *   "code": "AUTH_INVALID_TOKEN",
+     *   "message": "Your authentication token is invalid. Please login again.",
+     *   "timestamp": "2024-01-01T00:00:00.000Z"
+     * }
+     * ```
+     *
+     * @param error - HTTP error object (may contain response data)
+     * @returns User-friendly error message
+     */
+    private parseHttpError;
+}

package/dist/server/infra/http/authenticated-http-client.js

@@ -0,0 +1,159 @@
+import axios, { isAxiosError } from 'axios';
+/**
+ * HTTP client implementation that automatically adds authentication headers to all requests.
+ *
+ * This client wraps axios and automatically includes:
+ * - x-byterover-session-id: {sessionKey}
+ *
+ * Usage:
+ * ```typescript
+ * const client = new AuthenticatedHttpClient(accessToken, sessionKey)
+ * const data = await client.get<ResponseType>('https://api.example.com/endpoint')
+ * ```
+ */
+export class AuthenticatedHttpClient {
+    sessionKey;
+    constructor(sessionKey) {
+        this.sessionKey = sessionKey;
+    }
+    /**
+     * Performs an HTTP GET request with authentication headers.
+     * @param url The URL to request
+     * @param config Optional request configuration (headers, timeout)
+     * @returns A promise that resolves to the response data
+     * @throws Error if the request fails
+     */
+    async get(url, config) {
+        try {
+            const axiosConfig = {
+                headers: this.buildHeaders(config?.headers),
+                timeout: config?.timeout,
+            };
+            const response = await axios.get(url, axiosConfig);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error);
+        }
+    }
+    /**
+     * Performs an HTTP POST request with authentication headers.
+     * @param url The URL to request
+     * @param data The data to send in the request body
+     * @param config Optional request configuration (headers, timeout)
+     * @returns A promise that resolves to the response data
+     * @throws Error if the request fails
+     */
+    async post(url, data, config) {
+        try {
+            const axiosConfig = {
+                headers: this.buildHeaders(config?.headers),
+                timeout: config?.timeout,
+            };
+            const response = await axios.post(url, data, axiosConfig);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error);
+        }
+    }
+    /**
+     * Performs an HTTP PUT request with authentication headers.
+     * @param url The URL to request
+     * @param data The data to send in the request body
+     * @param config Optional request configuration (headers, timeout)
+     * @returns A promise that resolves to the response data
+     * @throws Error if the request fails
+     */
+    async put(url, data, config) {
+        try {
+            const axiosConfig = {
+                headers: this.buildHeaders(config?.headers),
+                timeout: config?.timeout,
+            };
+            const response = await axios.put(url, data, axiosConfig);
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error);
+        }
+    }
+    /**
+     * Builds request headers by merging authentication headers with custom headers.
+     * Custom headers take precedence over default headers.
+     */
+    buildHeaders(customHeaders) {
+        return {
+            'x-byterover-session-id': this.sessionKey,
+            ...customHeaders,
+        };
+    }
+    /**
+     * Transforms axios errors into generic Error instances.
+     * Preserves error information while abstracting axios-specific details.
+     */
+    handleError(error) {
+        if (isAxiosError(error) && error.response?.status === 401) {
+            // IMPORTANT: Do not handle 401 errors here - let callers handle errors (e.g., distinguish 401 from network errors)
+            return error;
+        }
+        // WARNING: isLLMServerError() matches any response with the standard ApiErrorResponse structure (IAM, Cogit, LLM services all use it)
+        if (this.isLLMServerError(error)) {
+            // Extract standardized API error message
+            return new Error(this.parseHttpError(error));
+        }
+        if (isAxiosError(error)) {
+            if (error.response) {
+                // Server responded with error status
+                return new Error(`HTTP ${error.response.status}: ${error.response.statusText}`);
+            }
+            if (error.code === 'ECONNABORTED' || error.message.includes('timeout')) {
+                // Request timeout
+                return new Error(`Request timeout: ${error.message}`);
+            }
+            if (error.request) {
+                // Request was made but no response received
+                return new Error('Network error: No response received from server');
+            }
+        }
+        // Generic error
+        if (error instanceof Error) {
+            return error;
+        }
+        return new Error('Unknown error occurred');
+    }
+    /**
+     * Type guard to check if error is an axios error with response.
+     */
+    isLLMServerError(error) {
+        return (typeof error === 'object' &&
+            error !== null &&
+            'response' in error &&
+            typeof error.response === 'object');
+    }
+    /**
+     * Parse HTTP error to extract user-friendly error message.
+     *
+     * Handles standardized API error responses from the server:
+     * ```json
+     * {
+     *   "statusCode": 401,
+     *   "code": "AUTH_INVALID_TOKEN",
+     *   "message": "Your authentication token is invalid. Please login again.",
+     *   "timestamp": "2024-01-01T00:00:00.000Z"
+     * }
+     * ```
+     *
+     * @param error - HTTP error object (may contain response data)
+     * @returns User-friendly error message
+     */
+    parseHttpError(error) {
+        const responseData = error.response.data;
+        // If server returned standardized API error format, use the message
+        if ('message' in responseData && typeof responseData.message === 'string') {
+            return responseData.message;
+        }
+        // Fallback to HTTP status error
+        return `HTTP ${error.response.status}: ${error.response.statusText}`;
+    }
+}

package/dist/server/infra/http/callback-handler.d.ts

@@ -0,0 +1,13 @@
+import type { CallbackResult, ICallbackHandler } from '../../core/interfaces/auth/i-callback-handler.js';
+/**
+ * Adapter implementation of ICallbackHandler that wraps CallbackServer.
+ * Provides OAuth callback handling functionality through a local HTTP server.
+ */
+export declare class CallbackHandler implements ICallbackHandler {
+    private readonly server;
+    constructor();
+    getPort(): number | undefined;
+    start(): Promise<number>;
+    stop(): Promise<void>;
+    waitForCallback(expectedState: string, timeoutMs: number): Promise<CallbackResult>;
+}

package/dist/server/infra/mcp/mcp-server.js

@@ -0,0 +1,179 @@
+import { connectToTransport } from '@campfirein/brv-transport-client';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { registerBrvCurateTool, registerBrvQueryTool } from './tools/index.js';
+/** Reconnection configuration */
+const RECONNECT_DELAY_MS = 1000;
+const RECONNECT_MAX_DELAY_MS = 30_000;
+const RECONNECT_BACKOFF_MULTIPLIER = 1.5;
+/**
+ * ByteRover MCP Server.
+ *
+ * Exposes brv-query and brv-curate as MCP tools for coding agents.
+ * Connects to a running brv instance via Socket.IO transport.
+ *
+ * Architecture:
+ * - Coding agent spawns `brv mcp` process
+ * - MCP server connects to running brv instance via Socket.IO
+ * - MCP tools create tasks via transport
+ * - Tasks are executed by the existing agent process
+ */
+export class ByteRoverMcpServer {
+    client;
+    config;
+    currentReconnectDelay = RECONNECT_DELAY_MS;
+    isReconnecting = false;
+    reconnectTimer;
+    server;
+    transport;
+    constructor(config) {
+        this.config = config;
+        this.server = new McpServer({
+            name: 'byterover',
+            version: config.version,
+        });
+        // Register tools with lazy client getter
+        // Client will be set when start() is called
+        registerBrvQueryTool(this.server, () => this.client, () => this.config.workingDirectory);
+        registerBrvCurateTool(this.server, () => this.client, () => this.config.workingDirectory);
+    }
+    /**
+     * Starts the MCP server.
+     *
+     * 1. Connects to running brv instance via Socket.IO
+     * 2. Starts MCP server with stdio transport
+     *
+     * @throws NoInstanceRunningError - No brv instance is running
+     * @throws ConnectionFailedError - Failed to connect to brv instance
+     */
+    async start() {
+        this.log('Starting MCP server...');
+        this.log(`Working directory: ${this.config.workingDirectory}`);
+        // Connect to running brv instance using modern API
+        this.log('Connecting to brv instance...');
+        let client;
+        let projectRoot;
+        try {
+            const result = await connectToTransport(this.config.workingDirectory);
+            client = result.client;
+            projectRoot = result.projectRoot;
+        }
+        catch (error) {
+            this.log(`Connection failed: ${error instanceof Error ? error.message : String(error)}`);
+            throw error;
+        }
+        this.client = client;
+        this.log(`Connected to brv instance at ${projectRoot}`);
+        this.log(`Client ID: ${client.getClientId()}`);
+        this.log(`Initial connection state: ${client.getState()}`);
+        // Monitor connection state changes and handle reconnection
+        this.setupStateChangeHandler(client);
+        // Start MCP server with stdio transport
+        this.transport = new StdioServerTransport();
+        await this.server.connect(this.transport);
+        this.log('MCP server started and ready for tool calls');
+        // Log client state periodically to debug connection issues
+        setInterval(() => {
+            if (this.client) {
+                this.log(`[heartbeat] Client state: ${this.client.getState()}, ID: ${this.client.getClientId()}`);
+            }
+            else {
+                this.log('[heartbeat] Client is undefined!');
+            }
+        }, 10_000);
+    }
+    /**
+     * Stops the MCP server.
+     *
+     * Disconnects from the brv instance.
+     */
+    async stop() {
+        // Clear any pending reconnection timer
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = undefined;
+        }
+        this.isReconnecting = false;
+        if (this.client) {
+            await this.client.disconnect();
+            this.client = undefined;
+        }
+    }
+    /**
+     * Attempts to reconnect to the brv instance.
+     * Uses exponential backoff for retry delays.
+     */
+    async attemptReconnect() {
+        if (this.isReconnecting) {
+            this.log('Reconnection already in progress, skipping...');
+            return;
+        }
+        this.isReconnecting = true;
+        this.log(`Attempting to reconnect in ${this.currentReconnectDelay}ms...`);
+        this.reconnectTimer = setTimeout(async () => {
+            try {
+                // Use modern connectToTransport API for reconnection
+                const result = await connectToTransport(this.config.workingDirectory);
+                // Disconnect old client if it exists
+                if (this.client) {
+                    try {
+                        await this.client.disconnect();
+                    }
+                    catch {
+                        // Ignore disconnect errors on old client
+                    }
+                }
+                this.client = result.client;
+                this.log(`Reconnected successfully! Client ID: ${result.client.getClientId()}`);
+                // Reset backoff delay on successful connection
+                this.currentReconnectDelay = RECONNECT_DELAY_MS;
+                this.isReconnecting = false;
+                // Set up state change handler for the new client
+                this.setupStateChangeHandler(result.client);
+            }
+            catch (error) {
+                this.log(`Reconnection failed: ${error instanceof Error ? error.message : String(error)}`);
+                // Increase delay with exponential backoff (capped at max)
+                this.currentReconnectDelay = Math.min(this.currentReconnectDelay * RECONNECT_BACKOFF_MULTIPLIER, RECONNECT_MAX_DELAY_MS);
+                this.isReconnecting = false;
+                // Schedule next reconnection attempt
+                this.attemptReconnect();
+            }
+        }, this.currentReconnectDelay);
+    }
+    /**
+     * Log to stderr (stdout is reserved for MCP protocol).
+     */
+    log(msg) {
+        process.stderr.write(`[brv-mcp] ${msg}\n`);
+    }
+    /**
+     * Sets up the state change handler for a client.
+     * Handles disconnection by triggering auto-reconnect.
+     */
+    setupStateChangeHandler(client) {
+        client.onStateChange((state) => {
+            const timestamp = new Date().toISOString();
+            this.log(`[${timestamp}] Connection state changed: ${state}`);
+            switch (state) {
+                case 'connected': {
+                    this.log(`[${timestamp}] Connected to brv instance.`);
+                    // Reset backoff delay on successful connection
+                    this.currentReconnectDelay = RECONNECT_DELAY_MS;
+                    this.isReconnecting = false;
+                    break;
+                }
+                case 'disconnected': {
+                    this.log(`[${timestamp}] Socket disconnected from brv instance. Initiating reconnection...`);
+                    // Trigger auto-reconnect
+                    this.attemptReconnect();
+                    break;
+                }
+                case 'reconnecting': {
+                    this.log(`[${timestamp}] Socket.IO attempting to reconnect...`);
+                    break;
+                }
+            }
+        });
+    }
+}

package/dist/server/infra/mcp/tools/brv-curate-tool.d.ts

@@ -0,0 +1,34 @@
+import type { ITransportClient } from '@campfirein/brv-transport-client';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+export declare const BrvCurateInputSchema: z.ZodEffects<z.ZodObject<{
+    context: z.ZodOptional<z.ZodString>;
+    files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    folder: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    context?: string | undefined;
+    files?: string[] | undefined;
+    folder?: string | undefined;
+}, {
+    context?: string | undefined;
+    files?: string[] | undefined;
+    folder?: string | undefined;
+}>, {
+    context?: string | undefined;
+    files?: string[] | undefined;
+    folder?: string | undefined;
+}, {
+    context?: string | undefined;
+    files?: string[] | undefined;
+    folder?: string | undefined;
+}>;
+/**
+ * Registers the brv-curate tool with the MCP server.
+ *
+ * This tool allows coding agents to store context to the ByteRover context tree.
+ * Use it to save patterns, architectural decisions, error solutions, or insights.
+ *
+ * Uses fire-and-forget pattern: returns immediately after queueing the task.
+ * The curation is processed asynchronously by the ByteRover agent.
+ */
+export declare function registerBrvCurateTool(server: McpServer, getClient: () => ITransportClient | undefined, getWorkingDirectory: () => string): void;

package/dist/server/infra/mcp/tools/brv-curate-tool.js

@@ -0,0 +1,93 @@
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
+export const BrvCurateInputSchema = z
+    .object({
+    context: z
+        .string()
+        .optional()
+        .describe('Knowledge to store: patterns, decisions, errors, or insights about the codebase. Required unless files or folder are provided.'),
+    files: z
+        .array(z.string())
+        .max(5)
+        .optional()
+        .describe('Optional file paths with critical context to include (max 5 files). Required if context and folder not provided.'),
+    folder: z
+        .string()
+        .optional()
+        .describe('Folder path to pack and analyze (triggers folder pack flow). When provided, the entire folder will be analyzed and curated. Takes precedence over files.'),
+})
+    .refine((data) => Boolean(data.context?.trim()) || Boolean(data.files?.length) || Boolean(data.folder?.trim()), {
+    message: 'Either context, files, or folder must be provided',
+});
+/**
+ * Registers the brv-curate tool with the MCP server.
+ *
+ * This tool allows coding agents to store context to the ByteRover context tree.
+ * Use it to save patterns, architectural decisions, error solutions, or insights.
+ *
+ * Uses fire-and-forget pattern: returns immediately after queueing the task.
+ * The curation is processed asynchronously by the ByteRover agent.
+ */
+export function registerBrvCurateTool(server, getClient, getWorkingDirectory) {
+    server.registerTool('brv-curate', {
+        description: 'Store context to the ByteRover context tree. Save patterns, decisions, or insights.',
+        inputSchema: BrvCurateInputSchema,
+        title: 'ByteRover Curate',
+    }, async ({ context, files, folder }) => {
+        const client = getClient();
+        if (!client) {
+            return {
+                content: [{ text: 'Error: Not connected to ByteRover instance. Run "brv" first.', type: 'text' }],
+                isError: true,
+            };
+        }
+        // Check connection state before making request
+        const state = client.getState();
+        if (state !== 'connected') {
+            return {
+                content: [
+                    {
+                        text: `Error: Socket not connected. Current state: ${state}. Ensure "brv" is running.`,
+                        type: 'text',
+                    },
+                ],
+                isError: true,
+            };
+        }
+        try {
+            const taskId = randomUUID();
+            // Create task via transport (same pattern as brv curate command)
+            // Use provided context, or empty string for file-only/folder-only mode
+            const resolvedContent = context?.trim() ? context : '';
+            // Determine task type: folder pack takes precedence over file-based curate
+            const hasFolder = Boolean(folder?.trim());
+            const taskType = hasFolder ? 'curate-folder' : 'curate';
+            await client.requestWithAck('task:create', {
+                clientCwd: getWorkingDirectory(),
+                content: resolvedContent,
+                taskId,
+                type: taskType,
+                ...(hasFolder && folder ? { folderPath: folder } : {}),
+                ...(!hasFolder && files?.length ? { files } : {}),
+            });
+            // Fire-and-forget: return immediately after task is queued
+            // Curation is processed asynchronously by the ByteRover agent
+            const modeDescription = hasFolder ? 'folder pack' : 'curation';
+            return {
+                content: [
+                    {
+                        text: `✓ Context queued for ${modeDescription} (taskId: ${taskId}). The curation will be processed asynchronously.`,
+                        type: 'text',
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [{ text: `Error: ${message}`, type: 'text' }],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/server/infra/mcp/tools/brv-query-tool.d.ts

@@ -0,0 +1,17 @@
+import type { ITransportClient } from '@campfirein/brv-transport-client';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+export declare const BrvQueryInputSchema: z.ZodObject<{
+    query: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+}, {
+    query: string;
+}>;
+/**
+ * Registers the brv-query tool with the MCP server.
+ *
+ * This tool allows coding agents to query the ByteRover context tree
+ * for patterns, decisions, implementation details, or any stored knowledge.
+ */
+export declare function registerBrvQueryTool(server: McpServer, getClient: () => ITransportClient | undefined, getWorkingDirectory: () => string): void;

package/dist/server/infra/mcp/tools/brv-query-tool.js

@@ -0,0 +1,62 @@
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
+import { waitForTaskResult } from './task-result-waiter.js';
+export const BrvQueryInputSchema = z.object({
+    query: z.string().describe('Natural language question about the codebase or project'),
+});
+/**
+ * Registers the brv-query tool with the MCP server.
+ *
+ * This tool allows coding agents to query the ByteRover context tree
+ * for patterns, decisions, implementation details, or any stored knowledge.
+ */
+export function registerBrvQueryTool(server, getClient, getWorkingDirectory) {
+    server.registerTool('brv-query', {
+        description: 'Query the ByteRover context tree for patterns, decisions, or implementation details.',
+        inputSchema: BrvQueryInputSchema,
+        title: 'ByteRover Query',
+    }, async ({ query }) => {
+        const client = getClient();
+        if (!client) {
+            return {
+                content: [{ text: 'Error: Not connected to ByteRover instance. Run "brv" first.', type: 'text' }],
+                isError: true,
+            };
+        }
+        // Check connection state before making request
+        const state = client.getState();
+        if (state !== 'connected') {
+            return {
+                content: [
+                    {
+                        text: `Error: Socket not connected. Current state: ${state}. Ensure "brv" is running.`,
+                        type: 'text',
+                    },
+                ],
+                isError: true,
+            };
+        }
+        try {
+            const taskId = randomUUID();
+            // Create task via transport (same pattern as brv query command)
+            await client.requestWithAck('task:create', {
+                clientCwd: getWorkingDirectory(),
+                content: query,
+                taskId,
+                type: 'query',
+            });
+            // Wait for task completion and return result
+            const result = await waitForTaskResult(client, taskId);
+            return {
+                content: [{ text: result, type: 'text' }],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [{ text: `Error: ${message}`, type: 'text' }],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/server/infra/mcp/tools/task-result-waiter.d.ts

@@ -0,0 +1,30 @@
+import type { ITransportClient } from '@campfirein/brv-transport-client';
+export interface TaskCompletedPayload {
+    result: string;
+    taskId: string;
+}
+export interface TaskErrorPayload {
+    error: {
+        code?: string;
+        details?: Record<string, unknown>;
+        message: string;
+        name: string;
+    };
+    taskId: string;
+}
+export interface LlmResponsePayload {
+    content: string;
+    taskId: string;
+}
+/**
+ * Waits for a task to complete and returns the result.
+ *
+ * Unlike the fire-and-forget pattern used by `brv curate`, MCP tools need
+ * to wait for the task to finish and return the result to the coding agent.
+ *
+ * This function listens for:
+ * - llmservice:response: Captures the LLM's text response
+ * - task:completed: Task finished successfully
+ * - task:error: Task failed with an error
+ */
+export declare function waitForTaskResult(client: ITransportClient, taskId: string, timeoutMs?: number): Promise<string>;

package/dist/server/infra/memory/http-memory-retrieval-service.d.ts

@@ -0,0 +1,18 @@
+import type { IMemoryRetrievalService, RetrieveParams } from '../../core/interfaces/services/i-memory-retrieval-service.js';
+import { RetrieveResult } from '../../core/domain/entities/retrieve-result.js';
+export type MemoryRetrievalServiceConfig = {
+    apiBaseUrl: string;
+    timeout?: number;
+};
+/**
+ * HTTP implementation of IMemoryRetrievalService for ByteRover Memora service.
+ * Handles retrieval of memories based on search queries.
+ */
+export declare class HttpMemoryRetrievalService implements IMemoryRetrievalService {
+    private readonly config;
+    constructor(config: MemoryRetrievalServiceConfig);
+    retrieve(params: RetrieveParams): Promise<RetrieveResult>;
+    private buildQueryParams;
+    private mapToMemory;
+    private mapToRetrieveResult;
+}