hyacinth-ai 0.9.6

package/dist/provider/resilient.js

@@ -0,0 +1,181 @@
+/**
+ * ResilientProvider — wraps any Provider with retry + circuit breaker.
+ *
+ * Retry: exponential backoff (1s → 2s → 4s → 8s, max 4 retries)
+ *   - Retryable: network errors, 5xx, 429 (rate limit)
+ *   - Non-retryable: 4xx auth/validation errors
+ *
+ * Circuit breaker: after N consecutive failures, open for cooldown period.
+ *   - Closed → Open (after failureThreshold consecutive failures)
+ *   - Open → Half-open (after cooldownMs)
+ *   - Half-open → Closed (on success) / Open (on failure)
+ */
+import { createLogger } from '../logging/logger.js';
+import { DEFAULT_RETRY_CONFIG } from './retry.js';
+export const DEFAULT_CB = {
+    failureThreshold: 5,
+    cooldownMs: 30_000,
+};
+// ─── Helpers ───────────────────────────────────────────────────────
+const RETRYABLE_STATUS_CODES = new Set([429, 500, 502, 503, 504]);
+const RETRYABLE_ERROR_PATTERNS = [
+    /ECONNREFUSED/i,
+    /ECONNRESET/i,
+    /ETIMEDOUT/i,
+    /ENOTFOUND/i,
+    /EAI_AGAIN/i,
+    /socket hang up/i,
+    /timeout/i,
+    /rate.?limit/i,
+    /too many requests/i,
+    /service.?unavailable/i,
+    /internal.?server.?error/i,
+    /bad gateway/i,
+    /gateway.?timeout/i,
+];
+function isRetryableError(error) {
+    const message = error.message ?? '';
+    // Check status code in message — match " 429 ", "HTTP 429", "status 429", etc.
+    // Use word-boundary-like matching to avoid false positives (e.g. "tried 429 times")
+    for (const code of RETRYABLE_STATUS_CODES) {
+        if (new RegExp(`\\b${code}\\b`).test(message))
+            return true;
+    }
+    // Check known error patterns
+    for (const pattern of RETRYABLE_ERROR_PATTERNS) {
+        if (pattern.test(message))
+            return true;
+    }
+    return false;
+}
+function isAbortError(err) {
+    return err.name === 'AbortError' || err.name === 'APIUserAbortError';
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export class ResilientProvider {
+    inner;
+    retryConfig;
+    cbConfig;
+    logger;
+    // Circuit breaker state
+    cbState = 'closed';
+    failureCount = 0;
+    lastFailureTime = 0;
+    name;
+    constructor(provider, retryConfig, cbConfig) {
+        this.inner = provider;
+        this.retryConfig = { ...DEFAULT_RETRY_CONFIG, ...retryConfig };
+        this.cbConfig = { ...DEFAULT_CB, ...cbConfig };
+        this.name = `${provider.getProviderType()}/${provider.getModel()}`;
+        this.logger = createLogger(`provider:resilient:${this.name}`);
+    }
+    getProviderType() {
+        return this.inner.getProviderType();
+    }
+    getModel() {
+        return this.inner.getModel();
+    }
+    getCapabilities() {
+        return this.inner.getCapabilities?.() ?? {
+            toolCalling: false, streaming: true, adapterSupport: false,
+            maxContextTokens: 4096, isLocal: false, vision: false,
+        };
+    }
+    getInner() {
+        return this.inner;
+    }
+    setThinking(enabled, effort) {
+        this.inner.setThinking?.(enabled, effort);
+    }
+    setUserId(userId) {
+        this.inner.setUserId?.(userId);
+    }
+    getCircuitState() {
+        return this.cbState;
+    }
+    async *createStream(messages, tools, signal) {
+        const maxAttempts = this.retryConfig.maxRetries + 1; // initial + retries
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            // ── Circuit breaker check ─────────────────────────────────
+            if (this.cbState === 'open') {
+                const elapsed = Date.now() - this.lastFailureTime;
+                if (elapsed < this.cbConfig.cooldownMs) {
+                    throw new Error(`[ResilientProvider:${this.name}] Circuit breaker OPEN. ` +
+                        `Cooldown in ${Math.ceil((this.cbConfig.cooldownMs - elapsed) / 1000)}s.`);
+                }
+                // Transition to half-open
+                this.cbState = 'half-open';
+                this.logger.info('circuit breaker: half-open (trial)', { failures: this.failureCount });
+            }
+            // ── Backoff delay (skip first attempt) ──────────────────
+            if (attempt > 0) {
+                const delay = Math.min(this.retryConfig.baseDelayMs * Math.pow(2, attempt - 1), this.retryConfig.maxDelayMs);
+                this.logger.warn('retrying', { attempt, delayMs: delay });
+                await sleep(delay);
+            }
+            // ── Track whether we've yielded any event ────────────────
+            // 一旦 yield 过任何事件，重试必然导致 text/thinking 重复（已送出的无法撤回），
+            // 此时再遇到错误直接抛出，不再重试。
+            let hasYielded = false;
+            try {
+                // ── Execute (manual for-await to detect first yield) ──
+                const innerStream = this.inner.createStream(messages, tools, signal);
+                for await (const event of innerStream) {
+                    hasYielded = true;
+                    yield event;
+                }
+                // Success → reset
+                this.onSuccess(attempt);
+                return;
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                // ── Abort → rethrow immediately (never retry) ─────
+                if (isAbortError(err)) {
+                    throw err;
+                }
+                // ── Already yielded → cannot retry without duplication ──
+                if (hasYielded) {
+                    this.onFailure(err);
+                    throw err;
+                }
+                // ── Last attempt → fail ─────────────────────────────
+                if (attempt === maxAttempts - 1) {
+                    this.onFailure(err);
+                    throw err;
+                }
+                // ── Non-retryable → fail immediately ────────────────
+                if (!isRetryableError(err)) {
+                    this.onFailure(err);
+                    throw err;
+                }
+                // ── Retryable → record failure and loop ─────────────
+                this.onFailure(err);
+            }
+        }
+    }
+    // ── Circuit breaker state transitions ──────────────────────────
+    onSuccess(attempts) {
+        if (this.failureCount > 0) {
+            this.logger.info('recovered', { attempts: attempts + 1, previousFailures: this.failureCount });
+        }
+        this.failureCount = 0;
+        this.cbState = 'closed';
+    }
+    onFailure(err) {
+        this.failureCount++;
+        this.lastFailureTime = Date.now();
+        this.logger.warn('provider error', { error: err.message, failureCount: this.failureCount });
+        if (this.cbState !== 'open' &&
+            this.failureCount >= this.cbConfig.failureThreshold) {
+            this.cbState = 'open';
+            this.logger.error('circuit breaker: opened', err, {
+                cooldownMs: this.cbConfig.cooldownMs,
+                failures: this.failureCount,
+            });
+        }
+    }
+}
+//# sourceMappingURL=resilient.js.map

package/dist/provider/retry.d.ts

@@ -0,0 +1,16 @@
+export interface RetryConfig {
+    maxRetries: number;
+    baseDelayMs: number;
+    maxDelayMs: number;
+}
+export declare const DEFAULT_RETRY_CONFIG: RetryConfig;
+/** Check if an error is retryable */
+export declare function isRetryableError(error: unknown): boolean;
+/** Check if an error is non-retryable (auth, bad request, etc) */
+export declare function isNonRetryableError(error: unknown): boolean;
+/**
+ * Wrap an async function with retry logic.
+ * Exponential backoff: 1s, 2s, 4s, 8s (capped at maxDelayMs)
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, config?: Partial<RetryConfig>, operationName?: string): Promise<T>;
+//# sourceMappingURL=retry.d.ts.map

package/dist/provider/retry.js

@@ -0,0 +1,78 @@
+import { createLogger } from '../logging/logger.js';
+const logger = createLogger('retry');
+export const DEFAULT_RETRY_CONFIG = {
+    maxRetries: 4,
+    baseDelayMs: 1000,
+    maxDelayMs: 30000,
+};
+/** Check if an error is retryable */
+export function isRetryableError(error) {
+    if (error instanceof Error) {
+        const msg = error.message.toLowerCase();
+        // Network errors
+        if (msg.includes('econnreset') || msg.includes('etimedout') || msg.includes('enotfound'))
+            return true;
+        if (msg.includes('timeout') || msg.includes('network'))
+            return true;
+        // HTTP status codes in message
+        if (msg.includes('status: 5') || msg.includes('status: 429'))
+            return true;
+        if (msg.includes('status: 502') || msg.includes('status: 503') || msg.includes('status: 504'))
+            return true;
+        // Anthropic SDK specific
+        if (msg.includes('overloaded') || msg.includes('rate limit'))
+            return true;
+    }
+    return false;
+}
+/** Check if an error is non-retryable (auth, bad request, etc) */
+export function isNonRetryableError(error) {
+    if (error instanceof Error) {
+        const msg = error.message.toLowerCase();
+        if (msg.includes('status: 401') || msg.includes('status: 403'))
+            return true;
+        if (msg.includes('status: 404'))
+            return true;
+        if (msg.includes('invalid api key') || msg.includes('authentication'))
+            return true;
+    }
+    return false;
+}
+/** Sleep helper */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Wrap an async function with retry logic.
+ * Exponential backoff: 1s, 2s, 4s, 8s (capped at maxDelayMs)
+ */
+export async function withRetry(fn, config = {}, operationName = 'operation') {
+    const cfg = { ...DEFAULT_RETRY_CONFIG, ...config };
+    let lastError;
+    for (let attempt = 0; attempt <= cfg.maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            // Non-retryable errors fail immediately
+            if (isNonRetryableError(error)) {
+                throw error;
+            }
+            // Non-retryable errors (not in our retryable list) fail on first attempt
+            if (attempt === 0 && !isRetryableError(error)) {
+                throw error;
+            }
+            // Last attempt, give up
+            if (attempt >= cfg.maxRetries) {
+                break;
+            }
+            // Calculate delay with exponential backoff
+            const delay = Math.min(cfg.baseDelayMs * Math.pow(2, attempt), cfg.maxDelayMs);
+            logger.warn('retry attempt failed', { operation: operationName, attempt: attempt + 1, delay });
+            await sleep(delay);
+        }
+    }
+    throw lastError;
+}
+//# sourceMappingURL=retry.js.map

package/dist/provider/router.d.ts

@@ -0,0 +1,68 @@
+import type { Provider } from './interface.js';
+/** 路由评估输入 */
+export interface AssessmentInput {
+    complexity: 'low' | 'medium' | 'high';
+}
+/** 当前路由模式信息 */
+export interface RoutingInfo {
+    /** 当前使用的 Provider 名称 */
+    providerName: string;
+    /** 路由模式：'auto' | 'manual' */
+    mode: 'auto' | 'manual';
+    /** Provider 是否本地 */
+    isLocal: boolean;
+}
+/**
+ * ProviderRouter — 在已注册的 Provider 之间进行动态路由。
+ *
+ * 支持：
+ * - 按名称注册/注销/查询 Provider
+ * - 手动覆盖默认 Provider（setDefault / clearDefault）
+ * - 基于复杂度评估自动路由：
+ *   - high → 优先在线 Provider
+ *   - low / medium → 优先本地 Provider
+ */
+export declare class ProviderRouter {
+    /** 注册表：名称 → Provider */
+    private registry;
+    /** 手动覆盖的默认 Provider 名称（为 null 时走自动路由） */
+    private defaultName;
+    /** 按名称注册 Provider */
+    register(name: string, provider: Provider): void;
+    /** 移除注册的 Provider */
+    unregister(name: string): void;
+    /** 获取已注册的 Provider */
+    get(name: string): Provider | undefined;
+    /** 列出所有已注册的 Provider 名称 */
+    list(): string[];
+    /** 设置默认 Provider（手动覆盖） */
+    setDefault(name: string): void;
+    /** 清除手动覆盖，恢复自动路由 */
+    clearDefault(): void;
+    /**
+     * 根据复杂度评估选择 Provider。
+     *
+     * 路由逻辑：
+     * 1. 存在手动覆盖 → 返回指定 Provider
+     * 2. complexity === 'high' → 优先第一个在线 Provider
+     * 3. 其他情况 → 优先第一个本地 Provider
+     * 4. 找不到匹配 → 返回第一个已注册 Provider
+     * 5. 注册表为空 → 抛出错误
+     */
+    route(assessment: AssessmentInput): Provider;
+    /**
+     * 获取当前路由模式信息。
+     *
+     * 注意：该方法在 route() 之前调用时，返回的是当前配置状态；
+     * 在 route() 之后调用则反映上一次路由的实际结果。
+     */
+    getRoutingInfo(): RoutingInfo;
+    /**
+     * 判断 Provider 是否为本地部署。
+     *
+     * 优先通过 getCapabilities()?.isLocal 判断；
+     * fallback: 通过 getProviderType() 返回值判断。
+     */
+    private isLocalProvider;
+}
+//# sourceMappingURL=router.d.ts.map

package/dist/provider/router.js

@@ -0,0 +1,145 @@
+// ---------------------------------------------------------------------------
+// ProviderRouter
+// ---------------------------------------------------------------------------
+/**
+ * ProviderRouter — 在已注册的 Provider 之间进行动态路由。
+ *
+ * 支持：
+ * - 按名称注册/注销/查询 Provider
+ * - 手动覆盖默认 Provider（setDefault / clearDefault）
+ * - 基于复杂度评估自动路由：
+ *   - high → 优先在线 Provider
+ *   - low / medium → 优先本地 Provider
+ */
+export class ProviderRouter {
+    /** 注册表：名称 → Provider */
+    registry = new Map();
+    /** 手动覆盖的默认 Provider 名称（为 null 时走自动路由） */
+    defaultName = null;
+    // ---- 注册管理 -----------------------------------------------------------
+    /** 按名称注册 Provider */
+    register(name, provider) {
+        this.registry.set(name, provider);
+    }
+    /** 移除注册的 Provider */
+    unregister(name) {
+        this.registry.delete(name);
+    }
+    /** 获取已注册的 Provider */
+    get(name) {
+        return this.registry.get(name);
+    }
+    /** 列出所有已注册的 Provider 名称 */
+    list() {
+        return Array.from(this.registry.keys());
+    }
+    // ---- 手动覆盖 -----------------------------------------------------------
+    /** 设置默认 Provider（手动覆盖） */
+    setDefault(name) {
+        if (!this.registry.has(name)) {
+            throw new Error(`ProviderRouter.setDefault: Provider "${name}" is not registered. ` +
+                `Call register() first.`);
+        }
+        this.defaultName = name;
+    }
+    /** 清除手动覆盖，恢复自动路由 */
+    clearDefault() {
+        this.defaultName = null;
+    }
+    // ---- 核心路由 -----------------------------------------------------------
+    /**
+     * 根据复杂度评估选择 Provider。
+     *
+     * 路由逻辑：
+     * 1. 存在手动覆盖 → 返回指定 Provider
+     * 2. complexity === 'high' → 优先第一个在线 Provider
+     * 3. 其他情况 → 优先第一个本地 Provider
+     * 4. 找不到匹配 → 返回第一个已注册 Provider
+     * 5. 注册表为空 → 抛出错误
+     */
+    route(assessment) {
+        // 手动覆盖
+        if (this.defaultName !== null) {
+            const provider = this.registry.get(this.defaultName);
+            if (!provider) {
+                // 理论上不会进入这里（setDefault 已校验），但作为防御性代码保留
+                throw new Error(`ProviderRouter.route: Default Provider "${this.defaultName}" ` +
+                    `is no longer registered.`);
+            }
+            return provider;
+        }
+        // 自动路由
+        if (this.registry.size === 0) {
+            throw new Error('ProviderRouter.route: No providers registered. ' +
+                'Call register() before routing.');
+        }
+        const preferOnline = assessment.complexity === 'high';
+        const entries = Array.from(this.registry.entries());
+        // 按偏好查找第一个匹配的 Provider
+        for (const [, provider] of entries) {
+            const isLocal = this.isLocalProvider(provider);
+            if (preferOnline ? !isLocal : isLocal) {
+                return provider;
+            }
+        }
+        // 没有匹配类型的 Provider，fallback 到第一个已注册的
+        return entries[0][1];
+    }
+    // ---- 路由信息 -----------------------------------------------------------
+    /**
+     * 获取当前路由模式信息。
+     *
+     * 注意：该方法在 route() 之前调用时，返回的是当前配置状态；
+     * 在 route() 之后调用则反映上一次路由的实际结果。
+     */
+    getRoutingInfo() {
+        let providerName;
+        let mode;
+        let isLocal;
+        if (this.defaultName !== null) {
+            mode = 'manual';
+            providerName = this.defaultName;
+            const provider = this.registry.get(this.defaultName);
+            isLocal = provider ? this.isLocalProvider(provider) : false;
+        }
+        else {
+            mode = 'auto';
+            // 自动模式下，优先报告在线 Provider（high 复杂度路径）
+            const entries = Array.from(this.registry.entries());
+            if (entries.length === 0) {
+                return {
+                    providerName: '(none)',
+                    mode: 'auto',
+                    isLocal: false,
+                };
+            }
+            // 找到第一个在线 Provider 作为感知名称
+            const online = entries.find(([, p]) => !this.isLocalProvider(p));
+            if (online) {
+                providerName = online[0];
+                isLocal = false;
+            }
+            else {
+                providerName = entries[0][0];
+                isLocal = true;
+            }
+        }
+        return { providerName, mode, isLocal };
+    }
+    // ---- 内部工具 -----------------------------------------------------------
+    /**
+     * 判断 Provider 是否为本地部署。
+     *
+     * 优先通过 getCapabilities()?.isLocal 判断；
+     * fallback: 通过 getProviderType() 返回值判断。
+     */
+    isLocalProvider(provider) {
+        if (provider.getCapabilities) {
+            return provider.getCapabilities().isLocal;
+        }
+        // fallback: 通过 type 判断
+        const type = provider.getProviderType();
+        return type === 'llamacpp' || type === 'local' || type === 'ollama';
+    }
+}
+//# sourceMappingURL=router.js.map

package/dist/provider/tool-args-recovery.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Tool Arguments Recovery — best-effort extraction of tool parameters
+ * from malformed JSON strings.
+ *
+ * When a model generates a tool call with large content (e.g., Write tool
+ * with source code), the streaming JSON may be truncated or contain
+ * unescaped characters. Rather than falling back to empty `{}`, we attempt
+ * to salvage known fields via regex extraction.
+ */
+/**
+ * Result of best-effort JSON recovery.
+ * - recovered: Record of successfully extracted fields
+ * - complete: true if the original JSON was valid (no recovery needed)
+ * - error: parse error message if JSON was invalid
+ */
+export interface RecoveryResult {
+    recovered: Record<string, unknown>;
+    complete: boolean;
+    error?: string;
+}
+/**
+ * Try to parse JSON, with fallback regex-based recovery for known tool patterns.
+ *
+ * Known patterns (in priority order):
+ * - "file_path": extracted via regex for write/edit/read tools
+ * - "content": extracted as everything after "content":" up to the end
+ * - "path": generic path extraction
+ * - "pattern": for glob/grep tools
+ * - "command": for bash tool
+ */
+export declare function recoverToolArguments(raw: string, toolName: string): RecoveryResult;
+/**
+ * Log a warning about tool call arguments that are empty or failed to parse.
+ */
+export declare function logToolArgsWarning(providerLabel: string, toolName: string, raw: string, error?: string): void;
+//# sourceMappingURL=tool-args-recovery.d.ts.map

package/dist/provider/tool-args-recovery.js

@@ -0,0 +1,91 @@
+/**
+ * Tool Arguments Recovery — best-effort extraction of tool parameters
+ * from malformed JSON strings.
+ *
+ * When a model generates a tool call with large content (e.g., Write tool
+ * with source code), the streaming JSON may be truncated or contain
+ * unescaped characters. Rather than falling back to empty `{}`, we attempt
+ * to salvage known fields via regex extraction.
+ */
+/**
+ * Try to parse JSON, with fallback regex-based recovery for known tool patterns.
+ *
+ * Known patterns (in priority order):
+ * - "file_path": extracted via regex for write/edit/read tools
+ * - "content": extracted as everything after "content":" up to the end
+ * - "path": generic path extraction
+ * - "pattern": for glob/grep tools
+ * - "command": for bash tool
+ */
+export function recoverToolArguments(raw, toolName) {
+    // First: try normal JSON parse
+    try {
+        const parsed = JSON.parse(raw || '{}');
+        return { recovered: parsed, complete: true };
+    }
+    catch (e) {
+        const error = e.message;
+        const recovered = {};
+        // ── file_path (write / edit / read) ──────────────────────
+        const filePathMatch = raw.match(/"file_path"\s*:\s*"((?:[^"\\]|\\.)*)"/);
+        if (filePathMatch) {
+            recovered.file_path = JSON.parse(`"${filePathMatch[1]}"`);
+        }
+        // ── content (write / edit) — grab everything after "content":" ──
+        if (toolName === 'write' || toolName === 'edit' || toolName === 'multi_edit' || toolName === 'insert') {
+            const contentMatch = raw.match(/"content"\s*:\s*"/);
+            if (contentMatch) {
+                const contentStart = contentMatch.index + contentMatch[0].length;
+                let contentRaw = raw.slice(contentStart);
+                // Strip trailing "} or "}\n or just " at the very end
+                contentRaw = contentRaw.replace(/"?\s*\}?\s*$/, '');
+                // Unescape JSON escapes
+                try {
+                    recovered.content = JSON.parse(`"${contentRaw}"`);
+                }
+                catch {
+                    // If unescaping fails, use raw content
+                    recovered.content = contentRaw;
+                }
+            }
+        }
+        // ── path (generic) ───────────────────────────────────────
+        if (!recovered.file_path && !recovered.path) {
+            const pathMatch = raw.match(/"path"\s*:\s*"((?:[^"\\]|\\.)*)"/);
+            if (pathMatch) {
+                recovered.path = JSON.parse(`"${pathMatch[1]}"`);
+            }
+        }
+        // ── pattern (glob / grep) ────────────────────────────────
+        if (toolName === 'glob' || toolName === 'grep') {
+            const patternMatch = raw.match(/"pattern"\s*:\s*"((?:[^"\\]|\\.)*)"/);
+            if (patternMatch) {
+                recovered.pattern = JSON.parse(`"${patternMatch[1]}"`);
+            }
+        }
+        // ── command (bash) ───────────────────────────────────────
+        if (toolName === 'bash') {
+            const cmdMatch = raw.match(/"command"\s*:\s*"((?:[^"\\]|\\.)*)"/);
+            if (cmdMatch) {
+                recovered.command = JSON.parse(`"${cmdMatch[1]}"`);
+            }
+        }
+        return { recovered, complete: false, error };
+    }
+}
+/**
+ * Log a warning about tool call arguments that are empty or failed to parse.
+ */
+export function logToolArgsWarning(providerLabel, toolName, raw, error) {
+    const rawLen = raw?.length ?? 0;
+    const preview = (raw || '').slice(0, 500);
+    const suffix = rawLen > 500 ? `... (${rawLen - 500} more chars)` : '';
+    if (error) {
+        console.warn(`[${providerLabel}] JSON parse failed for tool "${toolName}": ${error}`);
+    }
+    else if (!raw || rawLen === 0) {
+        console.warn(`[${providerLabel}] Tool "${toolName}" called with EMPTY arguments (raw length: 0). The model may be hitting output limits or the stream chunk order is wrong.`);
+    }
+    console.warn(`[${providerLabel}] raw (first 500 chars): ${preview}${suffix}`);
+}
+//# sourceMappingURL=tool-args-recovery.js.map

package/dist/provider/user-id.d.ts

@@ -0,0 +1,13 @@
+export declare const DEFAULT_USER_ID = "hyacinth";
+/** 启动时调用，将前缀同步为配置中的 provider.userId */
+export declare function setUserIdPrefix(prefix: string): void;
+/** 主Agent 普通模式 */
+export declare function mainUserId(sessionTag: string): string;
+/** 主Agent 陪伴模式 */
+export declare function companionUserId(characterName: string): string;
+export declare function orchestratorUserId(): string;
+export declare function narrationUserId(): string;
+export declare function compressorUserId(): string;
+/** 子Agent（按名称 + 实例ID 隔离） */
+export declare function subAgentUserId(agentName: string, instanceId: string): string;
+//# sourceMappingURL=user-id.d.ts.map