@tablestore/tablestore-agent-cli 0.3.1 → 0.4.0

package/dist/dashboard-runtime/node_modules/@tablestore/agent-storage/dist/src/core/http/ots-json-client.js

@@ -0,0 +1,151 @@
+import { OTSClientError } from '../errors/client-error.js';
+import { OTSServiceError } from '../errors/service-error.js';
+import { SignV2 } from '../auth/sign-v2.js';
+import { SignV4 } from '../auth/sign-v4.js';
+import { buildRequestHeaders } from './headers.js';
+import { md5Base64 } from './md5.js';
+import { RequestContext as RequestContextImpl } from '../auth/request-context.js';
+import { DEFAULT_USER_AGENT } from '../version.js';
+function normalizeHeaders(headers) {
+    const normalized = {};
+    headers.forEach((value, key) => {
+        normalized[key.toLowerCase()] = value;
+    });
+    return normalized;
+}
+export class OTSJSONClient {
+    endpoint;
+    instanceName;
+    credentials;
+    apiKey;
+    fetchImpl;
+    signer;
+    userAgent;
+    extraHeaders;
+    constructor(options) {
+        if (!options.credentials && !options.apiKey) {
+            throw new OTSClientError('Either credentials (accessKeyId/accessKeySecret) or apiKey must be provided.');
+        }
+        if (options.apiKey && !options.endpoint.startsWith('https://')) {
+            throw new OTSClientError('API key authentication requires HTTPS. Endpoint must start with https://.');
+        }
+        this.endpoint = options.endpoint.replace(/\/+$/, '');
+        this.instanceName = options.instanceName;
+        this.credentials = options.credentials;
+        this.apiKey = options.apiKey;
+        this.fetchImpl = options.fetch;
+        this.userAgent = options.userAgent ?? DEFAULT_USER_AGENT;
+        this.extraHeaders = options.extraHeaders;
+        if (options.credentials) {
+            this.signer =
+                (options.signVersion ?? 'v2') === 'v4'
+                    ? new SignV4({ region: options.region })
+                    : new SignV2();
+        }
+    }
+    buildHeaders(action, body) {
+        let headers;
+        let requestContext;
+        if (this.apiKey) {
+            headers = {
+                'x-ots-instancename': this.instanceName,
+                'x-ots-apikey': this.apiKey,
+                'Content-Type': 'application/json',
+                'User-Agent': this.userAgent,
+            };
+            if (this.extraHeaders) {
+                for (const [key, value] of Object.entries(this.extraHeaders)) {
+                    headers[key] = value;
+                }
+            }
+        }
+        else {
+            requestContext = new RequestContextImpl(this.credentials);
+            headers = buildRequestHeaders({
+                body: new TextEncoder().encode(body),
+                query: `/${action}`,
+                instanceName: this.instanceName,
+                credentials: this.credentials,
+                signer: this.signer,
+                requestContext,
+                userAgent: this.userAgent,
+                extraHeaders: this.extraHeaders,
+            });
+            headers['Content-Type'] = 'application/json';
+        }
+        return { headers, requestContext };
+    }
+    async request(action, payload) {
+        if (!this.fetchImpl) {
+            throw new OTSClientError('fetch implementation is required.');
+        }
+        const body = JSON.stringify(payload);
+        const { headers, requestContext } = this.buildHeaders(action, body);
+        let response;
+        try {
+            response = await this.fetchImpl(`${this.endpoint}/${action}`, {
+                method: 'POST',
+                headers,
+                body,
+            });
+        }
+        catch (error) {
+            throw new OTSClientError(`Failed to send request: ${String(error)}`);
+        }
+        const responseText = await response.text();
+        const responseBytes = new TextEncoder().encode(responseText);
+        const responseHeaders = normalizeHeaders(response.headers);
+        if (!this.apiKey) {
+            this.validateResponseHeaders(responseHeaders, responseBytes, response.status, requestContext, `/${action}`);
+        }
+        if (!response.ok) {
+            let errorPayload = {};
+            try {
+                errorPayload = responseText ? JSON.parse(responseText) : {};
+            }
+            catch {
+                errorPayload = {};
+            }
+            throw new OTSServiceError(String(errorPayload.message ?? response.statusText), {
+                statusCode: response.status,
+                requestId: responseHeaders['x-ots-requestid'],
+                code: typeof errorPayload.code === 'string' ? errorPayload.code : undefined,
+            });
+        }
+        try {
+            return JSON.parse(responseText);
+        }
+        catch (error) {
+            throw new OTSClientError(`Failed to parse JSON response: ${String(error)}`);
+        }
+    }
+    validateResponseHeaders(headers, body, status, requestContext, query) {
+        if (status >= 200 && status < 300) {
+            for (const header of ['x-ots-contentmd5', 'x-ots-requestid', 'x-ots-date', 'x-ots-contenttype']) {
+                if (!(header in headers)) {
+                    throw new OTSClientError(`"${header}" is missing in response header.`);
+                }
+            }
+        }
+        if (headers['x-ots-contentmd5'] && md5Base64(body) !== headers['x-ots-contentmd5']) {
+            throw new OTSClientError('MD5 mismatch in response.');
+        }
+        const authorization = headers.authorization;
+        if (!authorization) {
+            if (status >= 200 && status < 300) {
+                throw new OTSClientError('"Authorization" is missing in response header.');
+            }
+            return;
+        }
+        if (!authorization.startsWith('OTS ')) {
+            throw new OTSClientError('Invalid Authorization in response.');
+        }
+        const [accessKeyId, signature] = authorization.slice(4).split(':');
+        if (accessKeyId !== this.credentials.accessKeyId) {
+            throw new OTSClientError('Invalid access key id in response.');
+        }
+        if (signature !== this.signer.makeResponseSignature(query, headers, this.signer.getSigningKey(requestContext))) {
+            throw new OTSClientError('Invalid signature in response.');
+        }
+    }
+}

package/dist/dashboard-runtime/node_modules/@tablestore/agent-storage/dist/src/core/models/base.d.ts

@@ -0,0 +1,5 @@
+export interface JsonRequestConvertible<T = Record<string, unknown>> {
+    toJSONRequest(): T;
+}
+export declare function assignIfPresent(target: Record<string, unknown>, key: string, value: unknown): void;
+export declare function toJsonValue(value: unknown): unknown;

package/dist/dashboard-runtime/node_modules/@tablestore/agent-storage/dist/src/core/models/base.js

@@ -0,0 +1,15 @@
+import { isUnset } from './unset.js';
+export function assignIfPresent(target, key, value) {
+    if (!isUnset(value)) {
+        target[key] = value;
+    }
+}
+export function toJsonValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => toJsonValue(item));
+    }
+    if (value && typeof value === 'object' && 'toJSONRequest' in value && typeof value.toJSONRequest === 'function') {
+        return value.toJSONRequest();
+    }
+    return value;
+}

package/dist/dashboard-runtime/node_modules/@tablestore/agent-storage/dist/src/core/models/chunk.d.ts

@@ -0,0 +1,47 @@
+import type { JsonRequestConvertible } from './base.js';
+import type { Unset } from './unset.js';
+export declare class UpdateChunkItem implements JsonRequestConvertible {
+    readonly chunkId: number;
+    readonly docId?: string;
+    readonly ossKey?: string;
+    readonly title?: string | null | Unset;
+    readonly content?: string | null | Unset;
+    readonly status?: string;
+    constructor(options: {
+        chunkId: number;
+        docId?: string;
+        ossKey?: string;
+        title?: string | null | Unset;
+        content?: string | null | Unset;
+        status?: string;
+    });
+    toJSONRequest(): Record<string, unknown>;
+}
+export declare class UpdateChunksRequest implements JsonRequestConvertible {
+    readonly knowledgeBaseName: string;
+    readonly chunks: UpdateChunkItem[];
+    readonly subspace?: string;
+    constructor(options: {
+        knowledgeBaseName: string;
+        chunks: UpdateChunkItem[];
+        subspace?: string;
+    });
+    toJSONRequest(): Record<string, unknown>;
+}
+export declare class ListChunksRequest implements JsonRequestConvertible {
+    readonly knowledgeBaseName: string;
+    readonly subspace?: string;
+    readonly docId?: string;
+    readonly ossKey?: string;
+    readonly maxResults?: number;
+    readonly nextToken?: string;
+    constructor(options: {
+        knowledgeBaseName: string;
+        subspace?: string;
+        docId?: string;
+        ossKey?: string;
+        maxResults?: number;
+        nextToken?: string;
+    });
+    toJSONRequest(): Record<string, unknown>;
+}

package/dist/dashboard-runtime/node_modules/@tablestore/agent-storage/dist/src/core/models/chunk.js

@@ -0,0 +1,61 @@
+import { assignIfPresent } from './base.js';
+export class UpdateChunkItem {
+    chunkId;
+    docId;
+    ossKey;
+    title;
+    content;
+    status;
+    constructor(options) {
+        Object.assign(this, options);
+        this.chunkId = options.chunkId;
+    }
+    toJSONRequest() {
+        const result = { chunkId: this.chunkId };
+        assignIfPresent(result, 'docId', this.docId);
+        assignIfPresent(result, 'ossKey', this.ossKey);
+        assignIfPresent(result, 'title', this.title);
+        assignIfPresent(result, 'content', this.content);
+        assignIfPresent(result, 'status', this.status);
+        return result;
+    }
+}
+export class UpdateChunksRequest {
+    knowledgeBaseName;
+    chunks;
+    subspace;
+    constructor(options) {
+        Object.assign(this, options);
+        this.knowledgeBaseName = options.knowledgeBaseName;
+        this.chunks = options.chunks;
+    }
+    toJSONRequest() {
+        const result = {
+            knowledgeBaseName: this.knowledgeBaseName,
+            chunks: this.chunks.map((item) => item.toJSONRequest()),
+        };
+        assignIfPresent(result, 'subspace', this.subspace);
+        return result;
+    }
+}
+export class ListChunksRequest {
+    knowledgeBaseName;
+    subspace;
+    docId;
+    ossKey;
+    maxResults;
+    nextToken;
+    constructor(options) {
+        Object.assign(this, options);
+        this.knowledgeBaseName = options.knowledgeBaseName;
+    }
+    toJSONRequest() {
+        const result = { knowledgeBaseName: this.knowledgeBaseName };
+        assignIfPresent(result, 'subspace', this.subspace);
+        assignIfPresent(result, 'docId', this.docId);
+        assignIfPresent(result, 'ossKey', this.ossKey);
+        assignIfPresent(result, 'maxResults', this.maxResults);
+        assignIfPresent(result, 'nextToken', this.nextToken);
+        return result;
+    }
+}

package/dist/dashboard-runtime/node_modules/@tablestore/agent-storage/dist/src/core/models/document.d.ts

@@ -0,0 +1,107 @@
+import type { JsonRequestConvertible } from './base.js';
+import type { Unset } from './unset.js';
+export declare class AddDocumentItem implements JsonRequestConvertible {
+    readonly ossKey: string;
+    readonly metadata?: Record<string, unknown>;
+    readonly inclusionFilters?: string[];
+    readonly exclusionFilters?: string[];
+    constructor(options: {
+        ossKey: string;
+        metadata?: Record<string, unknown>;
+        inclusionFilters?: string[];
+        exclusionFilters?: string[];
+    });
+    toJSONRequest(): Record<string, unknown>;
+}
+export declare class UploadDocumentItem implements JsonRequestConvertible {
+    readonly filePath: string;
+    readonly metadata?: Record<string, unknown>;
+    constructor(options: {
+        filePath: string;
+        metadata?: Record<string, unknown>;
+    });
+    toJSONRequest(): Record<string, unknown>;
+}
+export declare class DeleteDocumentItem implements JsonRequestConvertible {
+    readonly docId?: string;
+    readonly ossKey?: string;
+    constructor(options: {
+        docId?: string;
+        ossKey?: string;
+    });
+    toJSONRequest(): Record<string, unknown>;
+}
+export declare class AddDocumentsRequest implements JsonRequestConvertible {
+    readonly knowledgeBaseName: string;
+    readonly documents: AddDocumentItem[];
+    readonly subspace?: string;
+    constructor(options: {
+        knowledgeBaseName: string;
+        documents: AddDocumentItem[];
+        subspace?: string;
+    });
+    toJSONRequest(): Record<string, unknown>;
+}
+export declare class UploadDocumentsRequest implements JsonRequestConvertible {
+    readonly knowledgeBaseName: string;
+    readonly documents: UploadDocumentItem[];
+    readonly subspace?: string;
+    constructor(options: {
+        knowledgeBaseName: string;
+        documents: UploadDocumentItem[];
+        subspace?: string;
+    });
+    toJSONRequest(): Record<string, unknown>;
+}
+export declare class GetDocumentRequest implements JsonRequestConvertible {
+    readonly knowledgeBaseName: string;
+    readonly docId?: string;
+    readonly ossKey?: string;
+    readonly subspace?: string;
+    constructor(options: {
+        knowledgeBaseName: string;
+        docId?: string;
+        ossKey?: string;
+        subspace?: string;
+    });
+    toJSONRequest(): Record<string, unknown>;
+}
+export declare class ListDocumentsRequest implements JsonRequestConvertible {
+    readonly knowledgeBaseName: string;
+    readonly subspace?: string[];
+    readonly maxResults?: number;
+    readonly nextToken?: string;
+    constructor(options: {
+        knowledgeBaseName: string;
+        subspace?: string[];
+        maxResults?: number;
+        nextToken?: string;
+    });
+    toJSONRequest(): Record<string, unknown>;
+}
+export declare class DeleteDocumentsRequest implements JsonRequestConvertible {
+    readonly knowledgeBaseName: string;
+    readonly documents: DeleteDocumentItem[];
+    readonly subspace?: string;
+    constructor(options: {
+        knowledgeBaseName: string;
+        documents: DeleteDocumentItem[];
+        subspace?: string;
+    });
+    toJSONRequest(): Record<string, unknown>;
+}
+export declare class UpdateDocumentRequest implements JsonRequestConvertible {
+    readonly knowledgeBaseName: string;
+    readonly subspace?: string;
+    readonly ossKey?: string;
+    readonly docId?: string;
+    readonly metadata?: Record<string, unknown> | null | Unset;
+    constructor(options: {
+        knowledgeBaseName: string;
+        subspace?: string;
+        ossKey?: string;
+        docId?: string;
+        metadata?: Record<string, unknown> | null | Unset;
+    });
+    toJSONRequest(): Record<string, unknown>;
+}

package/dist/dashboard-runtime/node_modules/@tablestore/agent-storage/dist/src/core/models/document.js

@@ -0,0 +1,151 @@
+import { assignIfPresent } from './base.js';
+export class AddDocumentItem {
+    ossKey;
+    metadata;
+    inclusionFilters;
+    exclusionFilters;
+    constructor(options) {
+        Object.assign(this, options);
+        this.ossKey = options.ossKey;
+    }
+    toJSONRequest() {
+        const result = { ossKey: this.ossKey };
+        assignIfPresent(result, 'metadata', this.metadata);
+        assignIfPresent(result, 'inclusionFilters', this.inclusionFilters);
+        assignIfPresent(result, 'exclusionFilters', this.exclusionFilters);
+        return result;
+    }
+}
+export class UploadDocumentItem {
+    filePath;
+    metadata;
+    constructor(options) {
+        Object.assign(this, options);
+        this.filePath = options.filePath;
+    }
+    toJSONRequest() {
+        const result = { filePath: this.filePath };
+        assignIfPresent(result, 'metadata', this.metadata);
+        return result;
+    }
+}
+export class DeleteDocumentItem {
+    docId;
+    ossKey;
+    constructor(options) {
+        Object.assign(this, options);
+    }
+    toJSONRequest() {
+        const result = {};
+        assignIfPresent(result, 'docId', this.docId);
+        assignIfPresent(result, 'ossKey', this.ossKey);
+        return result;
+    }
+}
+export class AddDocumentsRequest {
+    knowledgeBaseName;
+    documents;
+    subspace;
+    constructor(options) {
+        Object.assign(this, options);
+        this.knowledgeBaseName = options.knowledgeBaseName;
+        this.documents = options.documents;
+    }
+    toJSONRequest() {
+        const result = {
+            knowledgeBaseName: this.knowledgeBaseName,
+            documents: this.documents.map((item) => item.toJSONRequest()),
+        };
+        assignIfPresent(result, 'subspace', this.subspace);
+        return result;
+    }
+}
+export class UploadDocumentsRequest {
+    knowledgeBaseName;
+    documents;
+    subspace;
+    constructor(options) {
+        Object.assign(this, options);
+        this.knowledgeBaseName = options.knowledgeBaseName;
+        this.documents = options.documents;
+    }
+    toJSONRequest() {
+        const result = {
+            knowledgeBaseName: this.knowledgeBaseName,
+            documents: this.documents.map((item) => item.toJSONRequest()),
+        };
+        assignIfPresent(result, 'subspace', this.subspace);
+        return result;
+    }
+}
+export class GetDocumentRequest {
+    knowledgeBaseName;
+    docId;
+    ossKey;
+    subspace;
+    constructor(options) {
+        Object.assign(this, options);
+        this.knowledgeBaseName = options.knowledgeBaseName;
+    }
+    toJSONRequest() {
+        const result = { knowledgeBaseName: this.knowledgeBaseName };
+        assignIfPresent(result, 'docId', this.docId);
+        assignIfPresent(result, 'ossKey', this.ossKey);
+        assignIfPresent(result, 'subspace', this.subspace);
+        return result;
+    }
+}
+export class ListDocumentsRequest {
+    knowledgeBaseName;
+    subspace;
+    maxResults;
+    nextToken;
+    constructor(options) {
+        Object.assign(this, options);
+        this.knowledgeBaseName = options.knowledgeBaseName;
+    }
+    toJSONRequest() {
+        const result = { knowledgeBaseName: this.knowledgeBaseName };
+        assignIfPresent(result, 'subspace', this.subspace);
+        assignIfPresent(result, 'maxResults', this.maxResults);
+        assignIfPresent(result, 'nextToken', this.nextToken);
+        return result;
+    }
+}
+export class DeleteDocumentsRequest {
+    knowledgeBaseName;
+    documents;
+    subspace;
+    constructor(options) {
+        Object.assign(this, options);
+        this.knowledgeBaseName = options.knowledgeBaseName;
+        this.documents = options.documents;
+    }
+    toJSONRequest() {
+        const result = {
+            knowledgeBaseName: this.knowledgeBaseName,
+            documents: this.documents.map((item) => item.toJSONRequest()),
+        };
+        assignIfPresent(result, 'subspace', this.subspace);
+        return result;
+    }
+}
+export class UpdateDocumentRequest {
+    knowledgeBaseName;
+    subspace;
+    ossKey;
+    docId;
+    metadata;
+    constructor(options) {
+        Object.assign(this, options);
+        this.knowledgeBaseName = options.knowledgeBaseName;
+    }
+    toJSONRequest() {
+        const result = { knowledgeBaseName: this.knowledgeBaseName };
+        assignIfPresent(result, 'subspace', this.subspace);
+        assignIfPresent(result, 'ossKey', this.ossKey);
+        assignIfPresent(result, 'docId', this.docId);
+        assignIfPresent(result, 'metadata', this.metadata);
+        return result;
+    }
+}

package/dist/dashboard-runtime/node_modules/@tablestore/agent-storage/dist/src/core/models/enums.d.ts

@@ -0,0 +1,24 @@
+export declare enum MetadataFieldType {
+    STRING = "string",
+    LONG = "long",
+    DOUBLE = "double",
+    BOOLEAN = "boolean",
+    DATE = "date",
+    STRING_LIST = "string_list",
+    LONG_LIST = "long_list",
+    DOUBLE_LIST = "double_list",
+    BOOLEAN_LIST = "boolean_list",
+    DATE_LIST = "date_list"
+}
+export declare enum SearchType {
+    DENSE_VECTOR = "DENSE_VECTOR",
+    FULL_TEXT = "FULL_TEXT"
+}
+export declare enum RerankingType {
+    RRF = "RRF",
+    MODEL = "MODEL",
+    WEIGHT = "WEIGHT"
+}
+export declare enum RetrievalQueryType {
+    TEXT = "TEXT"
+}

package/dist/dashboard-runtime/node_modules/@tablestore/agent-storage/dist/src/core/models/enums.js

@@ -0,0 +1,28 @@
+export var MetadataFieldType;
+(function (MetadataFieldType) {
+    MetadataFieldType["STRING"] = "string";
+    MetadataFieldType["LONG"] = "long";
+    MetadataFieldType["DOUBLE"] = "double";
+    MetadataFieldType["BOOLEAN"] = "boolean";
+    MetadataFieldType["DATE"] = "date";
+    MetadataFieldType["STRING_LIST"] = "string_list";
+    MetadataFieldType["LONG_LIST"] = "long_list";
+    MetadataFieldType["DOUBLE_LIST"] = "double_list";
+    MetadataFieldType["BOOLEAN_LIST"] = "boolean_list";
+    MetadataFieldType["DATE_LIST"] = "date_list";
+})(MetadataFieldType || (MetadataFieldType = {}));
+export var SearchType;
+(function (SearchType) {
+    SearchType["DENSE_VECTOR"] = "DENSE_VECTOR";
+    SearchType["FULL_TEXT"] = "FULL_TEXT";
+})(SearchType || (SearchType = {}));
+export var RerankingType;
+(function (RerankingType) {
+    RerankingType["RRF"] = "RRF";
+    RerankingType["MODEL"] = "MODEL";
+    RerankingType["WEIGHT"] = "WEIGHT";
+})(RerankingType || (RerankingType = {}));
+export var RetrievalQueryType;
+(function (RetrievalQueryType) {
+    RetrievalQueryType["TEXT"] = "TEXT";
+})(RetrievalQueryType || (RetrievalQueryType = {}));