@ty_krystal/sei-ai 0.1.8 → 0.1.12

package/dist/core/sei-client.js

@@ -0,0 +1,535 @@
+import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, resolve } from 'node:path';
+import { createHash } from 'node:crypto';
+import { ACCOUNT_CHECK_CODE_PATH, ACCOUNT_LOGIN_DEFAULT_CHECKCODE, ACCOUNT_LOGIN_DEFAULT_OS, ACCOUNT_LOGIN_DEFAULT_PROJECT, ACCOUNT_LOGIN_DEFAULT_TYPE, DDL_EXECUTE_PATH, DEFAULT_AI_KEY, DEFAULT_QUERY_SQL_PAGE, DEFAULT_QUERY_SQL_SIZE, DEFAULT_TIMEOUT_MS, LOGIN_PATH, OPENAPI_DOCS_PATH, QUERY_PATH, QUERY_SQL_PATH, SAVE_PATH, TOKEN_CACHE_DIR_NAME, TOKEN_CACHE_FILE_PREFIX, TOKEN_CACHE_FILE_SUFFIX, TOKEN_CACHE_VERSION, } from './constants.js';
+import { SeiMcpError } from './errors.js';
+import { makeUrl, normalizeBaseUrl, toPositiveInteger, truncateText } from './utils.js';
+export function createSeiClient(config, logger, fetchImpl = fetch) {
+    const settings = createSeiAuthSettings(config);
+    const auth = createAuthManager(settings, logger, fetchImpl, { useCache: false });
+    return {
+        query(payload) {
+            return requestSeiJson(settings, logger, fetchImpl, auth, 'POST', QUERY_PATH, payload, {
+                allowFailure: false,
+            });
+        },
+        save(payload) {
+            return requestSeiJson(settings, logger, fetchImpl, auth, 'POST', SAVE_PATH, payload, {
+                allowFailure: false,
+            });
+        },
+        querySql(payload) {
+            return requestSeiJson(settings, logger, fetchImpl, auth, 'POST', QUERY_SQL_PATH, buildQuerySqlPayload(payload.sql, payload.page, payload.size), {
+                allowFailure: false,
+            });
+        },
+        describeTable(tableName) {
+            const sql = `SELECT COLUMN_NAME, DATA_TYPE, COLUMN_COMMENT ` +
+                `FROM information_schema.COLUMNS ` +
+                `WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = '${escapeSqlLiteral(tableName)}' ` +
+                `ORDER BY ORDINAL_POSITION`;
+            return requestSeiJson(settings, logger, fetchImpl, auth, 'POST', QUERY_SQL_PATH, buildQuerySqlPayload(sql, 1, 200), {
+                allowFailure: false,
+            });
+        },
+    };
+}
+export function createSeiAuthSettings(config, options = {}) {
+    return {
+        baseUrl: normalizeBaseUrl(options.baseUrl ?? config.baseUrl),
+        mode: config.auth.mode,
+        token: firstText(options.token, config.auth.token, process.env.SEI_TOKEN),
+        aiKey: firstText(options.aiKey, config.auth.aiKey, process.env.SEI_AI_LOGIN_KEY, DEFAULT_AI_KEY),
+        role: resolveRole(options.role, config.auth.role),
+        account: firstText(options.account, config.auth.account, process.env.SEI_AI_LOGIN_ACCOUNT),
+        accountProject: firstText(options.accountProject, process.env.SEI_AI_LOGIN_ACCOUNT_PROJECT, ACCOUNT_LOGIN_DEFAULT_PROJECT),
+        accountCheckcode: firstText(options.accountCheckcode, process.env.SEI_AI_LOGIN_ACCOUNT_CHECKCODE, ACCOUNT_LOGIN_DEFAULT_CHECKCODE),
+        timeoutMs: normalizeTimeout(options.timeoutMs),
+    };
+}
+export function createCliSeiClient(settings, logger, fetchImpl = fetch) {
+    const auth = createAuthManager(settings, logger, fetchImpl, { useCache: true });
+    return {
+        async call(method, path, payload, options = {}) {
+            return requestSeiJson(settings, logger, fetchImpl, auth, method, path, payload, options);
+        },
+        async query(payload, options = {}) {
+            return requestSeiJson(settings, logger, fetchImpl, auth, 'POST', QUERY_PATH, payload, options);
+        },
+        async save(payload, options = {}) {
+            return requestSeiJson(settings, logger, fetchImpl, auth, 'POST', SAVE_PATH, payload, options);
+        },
+        async querySql(sql, page, size, options = {}) {
+            return requestSeiJson(settings, logger, fetchImpl, auth, 'POST', QUERY_SQL_PATH, buildQuerySqlPayload(sql, page, size), options);
+        },
+        async readApiDocs() {
+            return requestJsonRaw(settings, logger, fetchImpl, 'GET', OPENAPI_DOCS_PATH, undefined, {
+                skipAuth: true,
+            });
+        },
+        async relogin() {
+            if (settings.mode === 'token') {
+                throw new SeiMcpError('token 模式不支持重新登录，请改用 --token 或 ai-login 模式', 'INVALID_REQUEST');
+            }
+            const state = await loginThroughSettings(settings, logger, fetchImpl, { useCache: true });
+            return state.token;
+        },
+        async executeDdlStatements(statements, options = {}) {
+            const results = [];
+            for (const [index, statement] of statements.entries()) {
+                const response = await requestSeiJson(settings, logger, fetchImpl, auth, 'POST', DDL_EXECUTE_PATH, { ddl: statement }, options);
+                results.push({
+                    index: index + 1,
+                    response,
+                });
+            }
+            return results;
+        },
+    };
+}
+export function buildQuerySqlPayload(sql, page, size) {
+    const normalizedSql = stripTrailingQuerySqlLimit(toText(sql));
+    if (!normalizedSql) {
+        throw new SeiMcpError('SQL 不能为空', 'INVALID_PARAMS');
+    }
+    return {
+        sql: normalizedSql,
+        page: toPositiveInteger(page, DEFAULT_QUERY_SQL_PAGE),
+        size: toPositiveInteger(size, DEFAULT_QUERY_SQL_SIZE),
+    };
+}
+export function stripTrailingQuerySqlLimit(sql) {
+    return sql
+        .trim()
+        .replace(/\s+LIMIT\s+\d+(?:\s*,\s*\d+|\s+OFFSET\s+\d+)?\s*;?\s*$/i, '')
+        .replace(/;+\s*$/g, '')
+        .trim();
+}
+async function requestSeiJson(settings, logger, fetchImpl, auth, method, path, payload, options = {}) {
+    const response = await requestJsonRaw(settings, logger, fetchImpl, method, path, payload, options, auth);
+    validateSeiEnvelope(response, path, options.allowFailure === true, options.allowEmpty === true);
+    return response;
+}
+async function requestJsonRaw(settings, logger, fetchImpl, method, path, payload, options = {}, auth) {
+    const token = options.skipAuth ? null : await resolveRequestToken(settings, auth, options);
+    const response = await requestJsonOnce(settings, logger, fetchImpl, method, path, payload, token, options);
+    if (!options.skipAuth && auth && isUnauthenticatedResponse(response) && auth.canRefresh()) {
+        const refreshedToken = await auth.refreshToken();
+        const retried = await requestJsonOnce(settings, logger, fetchImpl, method, path, payload, refreshedToken, options);
+        return retried;
+    }
+    return response;
+}
+async function requestJsonOnce(settings, logger, fetchImpl, method, path, payload, token, options = {}) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? settings.timeoutMs);
+    const headers = {
+        Accept: 'application/json, text/plain, */*',
+        'X-Requested-With': 'XMLHttpRequest',
+    };
+    if (token) {
+        headers.token = token;
+        headers.Authorization = `Bearer ${token}`;
+    }
+    if (payload !== undefined && method.toUpperCase() !== 'GET') {
+        headers['Content-Type'] = 'application/json';
+    }
+    if (options.extraHeaders) {
+        for (const [key, value] of Object.entries(options.extraHeaders)) {
+            headers[key] = value;
+        }
+    }
+    try {
+        logger.debug('SEI request', { method: method.toUpperCase(), path, hasToken: Boolean(token) });
+        const response = await fetchImpl(makeUrl(settings.baseUrl, path), {
+            method: method.toUpperCase(),
+            headers,
+            body: payload !== undefined && method.toUpperCase() !== 'GET' ? JSON.stringify(payload ?? {}) : undefined,
+            signal: controller.signal,
+        });
+        const text = await response.text();
+        if (!response.ok) {
+            throw new SeiMcpError(`SEI HTTP ${response.status}`, 'INVALID_REQUEST', {
+                status: response.status,
+                body: truncateText(text, 2000),
+            });
+        }
+        if (!text.trim()) {
+            return null;
+        }
+        try {
+            return JSON.parse(text);
+        }
+        catch (error) {
+            throw new SeiMcpError('SEI 返回不是 JSON', 'INVALID_REQUEST', {
+                body: truncateText(text, 2000),
+                cause: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    catch (error) {
+        if (error instanceof SeiMcpError) {
+            throw error;
+        }
+        throw new SeiMcpError('SEI 请求失败', 'INVALID_REQUEST', {
+            path,
+            cause: error instanceof Error ? error.message : String(error),
+        });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function createAuthManager(settings, logger, fetchImpl, options) {
+    let state = null;
+    let pending = null;
+    return {
+        canRefresh() {
+            return state?.canRefresh !== false;
+        },
+        async resolveToken() {
+            if (state) {
+                return state.token;
+            }
+            if (!pending) {
+                pending = resolveAuthState(settings, logger, fetchImpl, options);
+            }
+            state = await pending;
+            return state.token;
+        },
+        async refreshToken() {
+            if (state?.source === 'explicit' && state.token) {
+                return state.token;
+            }
+            pending = loginThroughSettings(settings, logger, fetchImpl, options);
+            state = await pending;
+            return state.token;
+        },
+    };
+}
+async function resolveAuthState(settings, logger, fetchImpl, options) {
+    if (settings.token) {
+        return {
+            token: settings.token,
+            source: 'explicit',
+            canRefresh: false,
+        };
+    }
+    if (options.useCache) {
+        const cachedToken = await loadCachedToken(settings);
+        if (cachedToken) {
+            return {
+                token: cachedToken,
+                source: 'cache',
+                canRefresh: true,
+            };
+        }
+    }
+    return loginThroughSettings(settings, logger, fetchImpl, options);
+}
+async function loginThroughSettings(settings, logger, fetchImpl, options) {
+    if (settings.account) {
+        const token = await loginAsAccount(settings, logger, fetchImpl);
+        if (options.useCache) {
+            await saveCachedToken(settings, token, logger);
+        }
+        return {
+            token,
+            source: 'account-login',
+            canRefresh: true,
+        };
+    }
+    const token = await loginWithAi(settings, logger, fetchImpl, settings.role || null);
+    if (options.useCache) {
+        await saveCachedToken(settings, token, logger);
+    }
+    return {
+        token,
+        source: 'login',
+        canRefresh: true,
+    };
+}
+async function loginWithAi(settings, logger, fetchImpl, role) {
+    if (!settings.aiKey) {
+        throw new SeiMcpError('ai-login 模式需要配置 aiKey', 'INVALID_REQUEST');
+    }
+    const payload = { mcp: settings.aiKey };
+    if (role) {
+        payload.role = role;
+    }
+    const response = await requestJsonOnce(settings, logger, fetchImpl, 'POST', LOGIN_PATH, payload, null, {
+        timeoutMs: settings.timeoutMs,
+    });
+    const token = extractToken(response);
+    return token;
+}
+async function loginAsAccount(settings, logger, fetchImpl) {
+    const adminToken = await loginWithAi(settings, logger, fetchImpl, null);
+    const row = await fetchAccountLoginRow(settings, logger, fetchImpl, adminToken, settings.account);
+    const passport = toText(getRowField(row, '_UID', 'uid', 'passport')) || settings.account;
+    const password = toText(getRowField(row, '_PWD', 'pwd', 'password'));
+    if (!password) {
+        throw new SeiMcpError(`账号 ${settings.account} 没有可用于登录的 _PWD`, 'INVALID_REQUEST');
+    }
+    const project = resolveAccountProject(row, settings.accountProject);
+    const cookieHeader = await requestCookieHeader(settings, logger, fetchImpl, {
+        os: ACCOUNT_LOGIN_DEFAULT_OS,
+        project,
+        type: ACCOUNT_LOGIN_DEFAULT_TYPE,
+    });
+    const payload = {
+        passport,
+        password,
+        os: ACCOUNT_LOGIN_DEFAULT_OS,
+        project,
+        type: ACCOUNT_LOGIN_DEFAULT_TYPE,
+        checkcode: settings.accountCheckcode,
+    };
+    const response = await requestJsonOnce(settings, logger, fetchImpl, 'POST', LOGIN_PATH, payload, null, {
+        extraHeaders: cookieHeader ? { Cookie: cookieHeader } : undefined,
+        timeoutMs: settings.timeoutMs,
+    });
+    return extractToken(response);
+}
+async function fetchAccountLoginRow(settings, logger, fetchImpl, adminToken, account) {
+    const sql = `SELECT _UID,_PWD,_SYSID,_STATUS FROM _SYS_USER WHERE _UID = '${escapeSqlLiteral(account)}'`;
+    const response = await requestJsonOnce(settings, logger, fetchImpl, 'POST', QUERY_SQL_PATH, buildQuerySqlPayload(sql, 1, 1), adminToken, {
+        timeoutMs: settings.timeoutMs,
+    });
+    validateSeiEnvelope(response, `${QUERY_SQL_PATH} 查询账号 ${account}`, false, false);
+    const rows = extractResponseRows(response);
+    if (rows.length === 0) {
+        throw new SeiMcpError(`未找到账号：${account}`, 'INVALID_REQUEST');
+    }
+    const row = rows[0];
+    if (!isObject(row)) {
+        throw new SeiMcpError(`账号 ${account} 查询结果不是 JSON 对象`, 'INVALID_REQUEST');
+    }
+    return row;
+}
+async function requestCookieHeader(settings, logger, fetchImpl, payload) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), settings.timeoutMs);
+    try {
+        logger.debug('SEI request', { method: 'POST', path: ACCOUNT_CHECK_CODE_PATH, hasToken: false });
+        const response = await fetchImpl(makeUrl(settings.baseUrl, ACCOUNT_CHECK_CODE_PATH), {
+            method: 'POST',
+            headers: {
+                Accept: 'application/json, text/plain, */*',
+                'Content-Type': 'application/json',
+                'X-Requested-With': 'XMLHttpRequest',
+            },
+            body: JSON.stringify(payload),
+            signal: controller.signal,
+        });
+        await response.text();
+        if (!response.ok) {
+            return null;
+        }
+        const cookies = response.headers.getSetCookie?.() ?? response.headers.get('set-cookie')?.split(',') ?? [];
+        const cookieParts = cookies
+            .map((item) => item.split(';', 1)[0]?.trim())
+            .filter((item) => Boolean(item));
+        return cookieParts.length > 0 ? cookieParts.join('; ') : null;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function resolveRequestToken(settings, auth, options) {
+    if (typeof options.token === 'string') {
+        return options.token;
+    }
+    if (!auth) {
+        return settings.token || null;
+    }
+    return auth.resolveToken();
+}
+function validateSeiEnvelope(response, context, allowFailure, allowEmpty) {
+    if (response === null && allowEmpty) {
+        return;
+    }
+    if (!isObject(response)) {
+        throw new SeiMcpError(`${context} 响应不是 JSON 对象`, 'INVALID_REQUEST');
+    }
+    if (!allowFailure && isSeiFailure(response)) {
+        throw new SeiMcpError(`${context} 失败：${String(response.message ?? response.msg ?? response.code ?? '未知错误')}`, 'INVALID_REQUEST', {
+            response: safeResponse(response),
+        });
+    }
+}
+function extractToken(response) {
+    validateSeiEnvelope(response, 'login', false, false);
+    if (!isObject(response) || !isObject(response.data) || typeof response.data.token !== 'string' || !response.data.token.trim()) {
+        throw new SeiMcpError('登录响应中没有 data.token', 'INVALID_REQUEST');
+    }
+    return response.data.token.trim();
+}
+function extractResponseRows(response) {
+    if (!isObject(response)) {
+        return [];
+    }
+    const data = response.data;
+    if (Array.isArray(data)) {
+        return data;
+    }
+    if (isObject(data)) {
+        for (const key of ['rows', 'records', 'list', 'data']) {
+            const value = data[key];
+            if (Array.isArray(value)) {
+                return value;
+            }
+            if (typeof value === 'string' && value.trim()) {
+                try {
+                    const parsed = JSON.parse(value);
+                    if (Array.isArray(parsed)) {
+                        return parsed;
+                    }
+                }
+                catch {
+                    return [];
+                }
+            }
+        }
+    }
+    return [];
+}
+function resolveAccountProject(row, requestedProject) {
+    const normalizedProject = toText(requestedProject);
+    if (normalizedProject) {
+        return normalizedProject;
+    }
+    const sysid = toText(getRowField(row, '_SYSID', 'sysid'));
+    if (!sysid) {
+        return ACCOUNT_LOGIN_DEFAULT_PROJECT;
+    }
+    return sysid.split(',', 1)[0]?.trim().replace(/^['"]|['"]$/g, '') || ACCOUNT_LOGIN_DEFAULT_PROJECT;
+}
+function getRowField(row, ...names) {
+    for (const name of names) {
+        if (name in row) {
+            return row[name];
+        }
+    }
+    const lowered = new Map(Object.entries(row).map(([key, value]) => [key.toLowerCase(), value]));
+    for (const name of names) {
+        if (lowered.has(name.toLowerCase())) {
+            return lowered.get(name.toLowerCase());
+        }
+    }
+    return undefined;
+}
+async function loadCachedToken(settings) {
+    const path = getTokenCachePath(settings);
+    try {
+        const raw = await readFile(path, 'utf8');
+        const data = JSON.parse(raw);
+        if (data.version !== TOKEN_CACHE_VERSION) {
+            return null;
+        }
+        if (data.baseUrl !== normalizeBaseUrl(settings.baseUrl)) {
+            return null;
+        }
+        if ((toText(data.role) || null) !== (settings.account ? null : settings.role || null)) {
+            return null;
+        }
+        if ((toText(data.account) || null) !== (settings.account || null)) {
+            return null;
+        }
+        return typeof data.token === 'string' && data.token.trim() ? data.token.trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function saveCachedToken(settings, token, logger) {
+    const path = getTokenCachePath(settings);
+    try {
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, JSON.stringify({
+            version: TOKEN_CACHE_VERSION,
+            baseUrl: normalizeBaseUrl(settings.baseUrl),
+            role: settings.account ? null : settings.role || null,
+            account: settings.account || null,
+            token: token.trim(),
+        }, null, 2) + '\n', 'utf8');
+        await chmod(path, 0o600).catch(() => undefined);
+    }
+    catch (error) {
+        logger.warn('写入 token 缓存失败', {
+            cause: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+function getTokenCachePath(settings) {
+    const identity = settings.account ? `account:${settings.account}` : `role:${settings.role || '__default__'}`;
+    const scope = `${normalizeBaseUrl(settings.baseUrl)}\0${identity}`;
+    const hash = createHash('sha256').update(scope).digest('hex').slice(0, 16);
+    return resolve(getTokenCacheDir(), `${TOKEN_CACHE_FILE_PREFIX}${hash}${TOKEN_CACHE_FILE_SUFFIX}`);
+}
+function getTokenCacheDir() {
+    const xdg = toText(process.env.XDG_CACHE_HOME);
+    if (xdg) {
+        return resolve(xdg, TOKEN_CACHE_DIR_NAME);
+    }
+    return resolve(homedir(), '.cache', TOKEN_CACHE_DIR_NAME);
+}
+function escapeSqlLiteral(value) {
+    return String(value).replace(/'/g, "''");
+}
+function isUnauthenticatedResponse(response) {
+    if (!isObject(response)) {
+        return false;
+    }
+    return Number(response.code) === -2;
+}
+function isSeiFailure(response) {
+    if (!isObject(response)) {
+        return false;
+    }
+    if (response.success === false) {
+        return true;
+    }
+    const code = Number(response.code);
+    return Number.isFinite(code) && code < 1;
+}
+function safeResponse(response) {
+    if (!isObject(response)) {
+        return response;
+    }
+    return {
+        code: response.code,
+        success: response.success,
+        message: response.message,
+    };
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function normalizeTimeout(value) {
+    const numeric = typeof value === 'number' ? value : Number(value);
+    if (Number.isFinite(numeric) && numeric > 0) {
+        return numeric < 1000 ? Math.round(numeric * 1000) : Math.round(numeric);
+    }
+    const env = Number(process.env.SEI_TIMEOUT ?? '');
+    if (Number.isFinite(env) && env > 0) {
+        return env < 1000 ? Math.round(env * 1000) : Math.round(env);
+    }
+    return DEFAULT_TIMEOUT_MS;
+}
+function resolveRole(role, fallback) {
+    return firstText(role, fallback, process.env.SEI_AI_LOGIN_ROLE).toLowerCase();
+}
+function firstText(...values) {
+    for (const value of values) {
+        const text = toText(value);
+        if (text) {
+            return text;
+        }
+    }
+    return '';
+}
+function toText(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}

package/dist/core/types.d.ts

@@ -0,0 +1,139 @@
+import type { JsonValue } from './utils.js';
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug';
+export interface Logger {
+    debug(message: string, meta?: JsonValue): void;
+    info(message: string, meta?: JsonValue): void;
+    warn(message: string, meta?: JsonValue): void;
+    error(message: string, meta?: JsonValue): void;
+}
+export interface SeiMcpConfig {
+    baseUrl: string;
+    auth: {
+        mode: 'ai-login' | 'token';
+        token: string;
+        tokenEnv: string;
+        aiKey: string;
+        aiKeyEnv: string;
+        account: string;
+        accountEnv: string;
+        role: string;
+        roleEnv: string;
+    };
+    tools: {
+        query: boolean;
+        save: boolean;
+        schema: boolean;
+        querySql: boolean;
+    };
+    targets: {
+        modules: Record<string, TargetConfig>;
+        tables: Record<string, TargetConfig>;
+        sources: Record<string, TargetConfig>;
+        views: Record<string, TargetConfig>;
+    };
+}
+export type RuntimeTransport = 'stdio' | 'streamable-http';
+export type RuntimeCommand = 'serve' | 'cli' | 'help';
+export interface HttpRuntimeOptions {
+    command: RuntimeCommand;
+    transport: RuntimeTransport;
+    host: string;
+    port: number;
+    path: string;
+    enableJsonResponse: boolean;
+    cliArgs: string[];
+}
+export interface HttpServerHandle {
+    url: URL;
+    close(): Promise<void>;
+}
+export interface TargetConfig {
+    mainTable?: string;
+    query?: {
+        fields?: string[];
+        defaultFields?: string[];
+        allowAllFields?: boolean;
+    };
+    save?: {
+        actions?: string[];
+        fields?: string[];
+    };
+}
+export interface AuthHeaders {
+    token: string;
+    authorization?: string;
+}
+export interface QueryToolInput {
+    head: Record<string, string>;
+    option?: {
+        fields?: string;
+        response_format?: 'markdown' | 'json';
+        [key: string]: unknown;
+    };
+}
+export interface SaveToolInput {
+    head: Record<string, string>;
+    data: Array<{
+        action: string;
+        rows?: Array<{
+            keyVal?: unknown;
+            row?: Record<string, unknown>;
+        }>;
+    }>;
+    query?: Record<string, unknown>;
+}
+export interface QuerySqlToolInput {
+    sql: string;
+    page?: number;
+    size?: number;
+    response_format?: 'markdown' | 'json';
+}
+export interface SeiAuthSettings {
+    baseUrl: string;
+    mode: 'ai-login' | 'token';
+    token: string;
+    aiKey: string;
+    role: string;
+    account: string;
+    accountProject: string;
+    accountCheckcode: string;
+    timeoutMs: number;
+}
+export interface SeiCommandOptions {
+    baseUrl?: string;
+    token?: string;
+    aiKey?: string;
+    role?: string;
+    account?: string;
+    accountProject?: string;
+    accountCheckcode?: string;
+    timeoutMs?: number;
+    noToken?: boolean;
+    allowFailure?: boolean;
+    allowEmpty?: boolean;
+}
+export interface SeiRequestOptions {
+    token?: string | null;
+    timeoutMs?: number;
+    extraHeaders?: Record<string, string>;
+}
+export interface SeiResponseValidationOptions {
+    context: string;
+    allowFailure?: boolean;
+    allowEmpty?: boolean;
+}
+export interface ToolRuntime {
+    config: SeiMcpConfig;
+    client: SeiClient;
+    logger: Logger;
+}
+export interface SeiClient {
+    query(payload: Record<string, unknown>): Promise<unknown>;
+    save(payload: Record<string, unknown>): Promise<unknown>;
+    querySql(payload: {
+        sql: string;
+        page: number;
+        size: number;
+    }): Promise<unknown>;
+    describeTable(tableName: string): Promise<unknown>;
+}

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/utils.d.ts

@@ -0,0 +1,12 @@
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export declare function isObject(value: unknown): value is Record<string, unknown>;
+export declare function toTrimmedString(value: unknown): string;
+export declare function stringifySafe(value: unknown): string;
+export declare function truncateText(value: unknown, limit: number): string;
+export declare function uniqueStrings(values: Iterable<string>): string[];
+export declare function normalizeBaseUrl(value: unknown): string;
+export declare function normalizePath(value: unknown): string;
+export declare function makeUrl(baseUrl: string, path: string): string;
+export declare function toPositiveInteger(value: unknown, fallback: number): number;