@kweaver-ai/kweaver-sdk 0.4.0

package/dist/api/ontology-query.js

@@ -0,0 +1,238 @@
+import { HttpError } from "../utils/http.js";
+function buildHeaders(accessToken, businessDomain) {
+    return {
+        accept: "application/json, text/plain, */*",
+        "accept-language": "zh-cn",
+        authorization: `Bearer ${accessToken}`,
+        token: accessToken,
+        "x-business-domain": businessDomain,
+        "x-language": "zh-cn",
+    };
+}
+export async function objectTypeQuery(options) {
+    const { baseUrl, accessToken, knId, otId, body, businessDomain = "bd_public", includeTypeInfo, includeLogicParams, excludeSystemProperties, } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}/api/ontology-query/v1/knowledge-networks/${encodeURIComponent(knId)}/object-types/${encodeURIComponent(otId)}`);
+    if (includeTypeInfo !== undefined) {
+        url.searchParams.set("include_type_info", String(includeTypeInfo));
+    }
+    if (includeLogicParams !== undefined) {
+        url.searchParams.set("include_logic_params", String(includeLogicParams));
+    }
+    if (excludeSystemProperties?.length) {
+        for (const p of excludeSystemProperties) {
+            url.searchParams.append("exclude_system_properties", p);
+        }
+    }
+    const headers = {
+        ...buildHeaders(accessToken, businessDomain),
+        "content-type": "application/json",
+        "X-HTTP-Method-Override": "GET",
+    };
+    const response = await fetch(url.toString(), {
+        method: "POST",
+        headers,
+        body,
+    });
+    const responseBody = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+    return responseBody;
+}
+export async function objectTypeProperties(options) {
+    const { baseUrl, accessToken, knId, otId, body, businessDomain = "bd_public", excludeSystemProperties, } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}/api/ontology-query/v1/knowledge-networks/${encodeURIComponent(knId)}/object-types/${encodeURIComponent(otId)}/properties`);
+    if (excludeSystemProperties?.length) {
+        for (const p of excludeSystemProperties) {
+            url.searchParams.append("exclude_system_properties", p);
+        }
+    }
+    const headers = {
+        ...buildHeaders(accessToken, businessDomain),
+        "content-type": "application/json",
+        "X-HTTP-Method-Override": "GET",
+    };
+    const response = await fetch(url.toString(), {
+        method: "POST",
+        headers,
+        body,
+    });
+    const responseBody = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+    return responseBody;
+}
+export async function subgraph(options) {
+    const { baseUrl, accessToken, knId, body, businessDomain = "bd_public", includeLogicParams, excludeSystemProperties, queryType, } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}/api/ontology-query/v1/knowledge-networks/${encodeURIComponent(knId)}/subgraph`);
+    if (includeLogicParams !== undefined) {
+        url.searchParams.set("include_logic_params", String(includeLogicParams));
+    }
+    if (excludeSystemProperties?.length) {
+        for (const p of excludeSystemProperties) {
+            url.searchParams.append("exclude_system_properties", p);
+        }
+    }
+    if (queryType !== undefined && queryType !== "") {
+        url.searchParams.set("query_type", queryType);
+    }
+    const headers = {
+        ...buildHeaders(accessToken, businessDomain),
+        "content-type": "application/json",
+    };
+    const response = await fetch(url.toString(), {
+        method: "POST",
+        headers,
+        body,
+    });
+    const responseBody = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+    return responseBody;
+}
+export async function actionTypeQuery(options) {
+    const { baseUrl, accessToken, knId, atId, body, businessDomain = "bd_public", includeTypeInfo, excludeSystemProperties, } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}/api/ontology-query/v1/knowledge-networks/${encodeURIComponent(knId)}/action-types/${encodeURIComponent(atId)}/`);
+    if (includeTypeInfo !== undefined) {
+        url.searchParams.set("include_type_info", String(includeTypeInfo));
+    }
+    if (excludeSystemProperties?.length) {
+        for (const p of excludeSystemProperties) {
+            url.searchParams.append("exclude_system_properties", p);
+        }
+    }
+    const headers = {
+        ...buildHeaders(accessToken, businessDomain),
+        "content-type": "application/json",
+        "X-HTTP-Method-Override": "GET",
+    };
+    const response = await fetch(url.toString(), {
+        method: "POST",
+        headers,
+        body,
+    });
+    const responseBody = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+    return responseBody;
+}
+export async function actionTypeExecute(options) {
+    const { baseUrl, accessToken, knId, atId, body, businessDomain = "bd_public" } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/ontology-query/v1/knowledge-networks/${encodeURIComponent(knId)}/action-types/${encodeURIComponent(atId)}/execute`;
+    const headers = {
+        ...buildHeaders(accessToken, businessDomain),
+        "content-type": "application/json",
+    };
+    const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body,
+    });
+    const responseBody = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+    return responseBody;
+}
+export async function actionExecutionGet(options) {
+    const { baseUrl, accessToken, knId, executionId, businessDomain = "bd_public" } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/ontology-query/v1/knowledge-networks/${encodeURIComponent(knId)}/action-executions/${encodeURIComponent(executionId)}`;
+    const response = await fetch(url, {
+        method: "GET",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    const body = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, body);
+    }
+    return body;
+}
+export async function actionLogsList(options) {
+    const { baseUrl, accessToken, knId, businessDomain = "bd_public", actionTypeId, status, triggerType, startTimeFrom, startTimeTo, limit, needTotal, searchAfter, } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}/api/ontology-query/v1/knowledge-networks/${encodeURIComponent(knId)}/action-logs`);
+    if (actionTypeId !== undefined && actionTypeId !== "") {
+        url.searchParams.set("action_type_id", actionTypeId);
+    }
+    if (status !== undefined && status !== "") {
+        url.searchParams.set("status", status);
+    }
+    if (triggerType !== undefined && triggerType !== "") {
+        url.searchParams.set("trigger_type", triggerType);
+    }
+    if (startTimeFrom !== undefined) {
+        url.searchParams.set("start_time_from", String(startTimeFrom));
+    }
+    if (startTimeTo !== undefined) {
+        url.searchParams.set("start_time_to", String(startTimeTo));
+    }
+    if (limit !== undefined) {
+        url.searchParams.set("limit", String(limit));
+    }
+    if (needTotal !== undefined) {
+        url.searchParams.set("need_total", String(needTotal));
+    }
+    if (searchAfter !== undefined && searchAfter !== "") {
+        url.searchParams.set("search_after", searchAfter);
+    }
+    const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    const body = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, body);
+    }
+    return body;
+}
+export async function actionLogGet(options) {
+    const { baseUrl, accessToken, knId, logId, businessDomain = "bd_public", resultsLimit, resultsOffset, resultsStatus, } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}/api/ontology-query/v1/knowledge-networks/${encodeURIComponent(knId)}/action-logs/${encodeURIComponent(logId)}`);
+    if (resultsLimit !== undefined) {
+        url.searchParams.set("results_limit", String(resultsLimit));
+    }
+    if (resultsOffset !== undefined) {
+        url.searchParams.set("results_offset", String(resultsOffset));
+    }
+    if (resultsStatus !== undefined) {
+        url.searchParams.set("results_status", resultsStatus);
+    }
+    const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    const body = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, body);
+    }
+    return body;
+}
+export async function actionLogCancel(options) {
+    const { baseUrl, accessToken, knId, logId, body = "{}", businessDomain = "bd_public" } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/ontology-query/v1/knowledge-networks/${encodeURIComponent(knId)}/action-logs/${encodeURIComponent(logId)}/cancel`;
+    const headers = {
+        ...buildHeaders(accessToken, businessDomain),
+        "content-type": "application/json",
+    };
+    const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body,
+    });
+    const responseBody = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+    return responseBody;
+}

package/dist/api/semantic-search.d.ts

@@ -0,0 +1,12 @@
+export interface SemanticSearchOptions {
+    baseUrl: string;
+    accessToken: string;
+    knId: string;
+    query: string;
+    businessDomain?: string;
+    mode?: string;
+    rerankAction?: string;
+    maxConcepts?: number;
+    returnQueryUnderstanding?: boolean;
+}
+export declare function semanticSearch(options: SemanticSearchOptions): Promise<string>;

package/dist/api/semantic-search.js

@@ -0,0 +1,34 @@
+import { HttpError } from "../utils/http.js";
+function buildHeaders(accessToken, businessDomain) {
+    return {
+        accept: "application/json, text/plain, */*",
+        "accept-language": "zh-cn",
+        authorization: `Bearer ${accessToken}`,
+        token: accessToken,
+        "x-business-domain": businessDomain,
+        "x-language": "zh-cn",
+        "content-type": "application/json",
+    };
+}
+export async function semanticSearch(options) {
+    const { baseUrl, accessToken, knId, query, businessDomain = "bd_public", mode = "keyword_vector_retrieval", rerankAction = "default", maxConcepts = 10, returnQueryUnderstanding = false, } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/agent-retrieval/v1/kn/semantic-search`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: buildHeaders(accessToken, businessDomain),
+        body: JSON.stringify({
+            kn_id: knId,
+            query,
+            mode,
+            rerank_action: rerankAction,
+            max_concepts: maxConcepts,
+            return_query_understanding: returnQueryUnderstanding,
+        }),
+    });
+    const body = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, body);
+    }
+    return body;
+}

package/dist/auth/oauth.d.ts

@@ -0,0 +1,75 @@
+import { type CallbackSession, type ClientConfig, type TokenConfig } from "../config/store.js";
+interface RegisterClientOptions {
+    baseUrl: string;
+    clientName: string;
+    redirectUri: string;
+    logoutRedirectUri: string;
+    lang?: string;
+    product?: string;
+    xForwardedPrefix?: string;
+}
+export declare function normalizeBaseUrl(value: string): string;
+export declare function getAuthorizationSuccessMessage(): string;
+export declare function registerClient(options: RegisterClientOptions): Promise<ClientConfig>;
+export interface EnsureClientOptions {
+    baseUrl: string;
+    port: number;
+    clientName: string;
+    forceRegister: boolean;
+    host?: string;
+    redirectUriOverride?: string;
+    lang?: string;
+    product?: string;
+    xForwardedPrefix?: string;
+}
+export interface EnsuredClientConfig {
+    client: ClientConfig;
+    created: boolean;
+}
+export interface AuthRedirectConfig {
+    redirectUri: string;
+    logoutRedirectUri: string;
+    listenHost: string;
+    listenPort: number;
+    callbackPath: string;
+}
+export declare function buildAuthRedirectConfig(options: {
+    port: number;
+    host?: string;
+    redirectUriOverride?: string;
+}): AuthRedirectConfig;
+export declare function ensureClientConfig(options: EnsureClientOptions): Promise<EnsuredClientConfig>;
+export declare function buildAuthorizationUrl(client: ClientConfig, state?: string): string;
+/**
+ * Call the platform's end-session endpoint so the server invalidates the session.
+ * Best-effort: failures are ignored so local logout still proceeds.
+ */
+export declare function callLogoutEndpoint(client: ClientConfig, token: TokenConfig | null): Promise<void>;
+export declare function refreshAccessToken(client: ClientConfig, refreshToken: string): Promise<TokenConfig>;
+export declare function ensureValidToken(): Promise<TokenConfig>;
+export interface AuthLoginOptions {
+    baseUrl: string;
+    port: number;
+    clientName: string;
+    open: boolean;
+    forceRegister: boolean;
+    host?: string;
+    redirectUriOverride?: string;
+    lang?: string;
+    product?: string;
+    xForwardedPrefix?: string;
+}
+export declare function login(options: AuthLoginOptions): Promise<{
+    client: ClientConfig;
+    token: TokenConfig;
+    authorizationUrl: string;
+    callback: CallbackSession;
+    created: boolean;
+}>;
+export declare function getStoredAuthSummary(baseUrl?: string): {
+    client: ClientConfig | null;
+    token: TokenConfig | null;
+    callback: CallbackSession | null;
+};
+export declare function formatHttpError(error: unknown): string;
+export {};