@kweaver-ai/kweaver-sdk 0.4.0

package/dist/config/store.js

@@ -0,0 +1,380 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const MCP_PATH = "/api/agent-retrieval/v1/mcp";
+function buildMcpUrl(baseUrl) {
+    return baseUrl.replace(/\/+$/, "") + MCP_PATH;
+}
+const CONFIG_DIR = process.env.KWEAVERC_CONFIG_DIR || join(homedir(), ".kweaver");
+function getConfigDirPath() {
+    return process.env.KWEAVERC_CONFIG_DIR || join(homedir(), ".kweaver");
+}
+function getPlatformsDirPath() {
+    return join(getConfigDirPath(), "platforms");
+}
+function getStateFilePath() {
+    return join(getConfigDirPath(), "state.json");
+}
+function getLegacyClientFilePath() {
+    return join(getConfigDirPath(), "client.json");
+}
+function getLegacyTokenFilePath() {
+    return join(getConfigDirPath(), "token.json");
+}
+function getLegacyCallbackFilePath() {
+    return join(getConfigDirPath(), "callback.json");
+}
+function ensureDir(path) {
+    if (!existsSync(path)) {
+        mkdirSync(path, { recursive: true, mode: 0o700 });
+    }
+}
+function ensureConfigDir() {
+    ensureDir(getConfigDirPath());
+    ensureDir(getPlatformsDirPath());
+}
+function readJsonFile(filePath) {
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    return JSON.parse(readFileSync(filePath, "utf8"));
+}
+function writeJsonFile(filePath, value) {
+    ensureConfigDir();
+    writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+    chmodSync(filePath, 0o600);
+}
+function encodePlatformKey(baseUrl) {
+    return Buffer.from(baseUrl, "utf8")
+        .toString("base64")
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_")
+        .replace(/=+$/g, "");
+}
+function getPlatformDir(baseUrl) {
+    return join(getPlatformsDirPath(), encodePlatformKey(baseUrl));
+}
+function getPlatformFile(baseUrl, filename) {
+    return join(getPlatformDir(baseUrl), filename);
+}
+function ensurePlatformDir(baseUrl) {
+    ensureDir(getPlatformDir(baseUrl));
+}
+function readState() {
+    return readJsonFile(getStateFilePath()) ?? {};
+}
+function writeState(state) {
+    writeJsonFile(getStateFilePath(), state);
+}
+function normalizeAlias(value) {
+    return value.trim().toLowerCase();
+}
+function migrateLegacyFilesIfNeeded() {
+    const legacyClientFile = getLegacyClientFilePath();
+    const legacyTokenFile = getLegacyTokenFilePath();
+    const legacyCallbackFile = getLegacyCallbackFilePath();
+    const hasLegacy = existsSync(legacyClientFile) || existsSync(legacyTokenFile) || existsSync(legacyCallbackFile);
+    if (!hasLegacy) {
+        return;
+    }
+    const legacyClient = readJsonFile(legacyClientFile);
+    const legacyToken = readJsonFile(legacyTokenFile);
+    const legacyCallback = readJsonFile(legacyCallbackFile);
+    const baseUrl = legacyClient?.baseUrl ?? legacyToken?.baseUrl ?? legacyCallback?.baseUrl;
+    if (!baseUrl) {
+        return;
+    }
+    const platformClientFile = getPlatformFile(baseUrl, "client.json");
+    const platformTokenFile = getPlatformFile(baseUrl, "token.json");
+    const platformCallbackFile = getPlatformFile(baseUrl, "callback.json");
+    ensurePlatformDir(baseUrl);
+    if (legacyClient && !existsSync(platformClientFile)) {
+        writeJsonFile(platformClientFile, legacyClient);
+    }
+    if (legacyToken && !existsSync(platformTokenFile)) {
+        writeJsonFile(platformTokenFile, legacyToken);
+    }
+    if (legacyCallback && !existsSync(platformCallbackFile)) {
+        writeJsonFile(platformCallbackFile, legacyCallback);
+    }
+    const state = readState();
+    if (!state.currentPlatform) {
+        writeState({ ...state, currentPlatform: baseUrl });
+    }
+}
+function ensureStoreReady() {
+    ensureConfigDir();
+    migrateLegacyFilesIfNeeded();
+}
+export function getConfigDir() {
+    return getConfigDirPath();
+}
+export function getCurrentPlatform() {
+    ensureStoreReady();
+    return readState().currentPlatform ?? null;
+}
+export function setCurrentPlatform(baseUrl) {
+    ensureStoreReady();
+    const state = readState();
+    writeState({ ...state, currentPlatform: baseUrl });
+}
+export function setPlatformAlias(baseUrl, alias) {
+    ensureStoreReady();
+    const normalizedAlias = normalizeAlias(alias);
+    if (!normalizedAlias) {
+        throw new Error("Alias cannot be empty.");
+    }
+    const state = readState();
+    const aliases = { ...(state.aliases ?? {}) };
+    const existing = aliases[normalizedAlias];
+    if (existing && existing !== baseUrl) {
+        throw new Error(`Alias '${normalizedAlias}' is already assigned to ${existing}.`);
+    }
+    aliases[normalizedAlias] = baseUrl;
+    writeState({ ...state, aliases });
+}
+export function deletePlatformAlias(baseUrl) {
+    ensureStoreReady();
+    const state = readState();
+    const aliases = { ...(state.aliases ?? {}) };
+    let changed = false;
+    for (const [alias, targetBaseUrl] of Object.entries(aliases)) {
+        if (targetBaseUrl === baseUrl) {
+            delete aliases[alias];
+            changed = true;
+        }
+    }
+    if (!changed) {
+        return;
+    }
+    writeState({
+        ...state,
+        aliases: Object.keys(aliases).length > 0 ? aliases : undefined,
+    });
+}
+export function getPlatformAlias(baseUrl) {
+    ensureStoreReady();
+    const aliases = readState().aliases ?? {};
+    for (const [alias, targetBaseUrl] of Object.entries(aliases)) {
+        if (targetBaseUrl === baseUrl) {
+            return alias;
+        }
+    }
+    return null;
+}
+export function resolvePlatformIdentifier(value) {
+    ensureStoreReady();
+    const normalized = value.trim();
+    if (!normalized) {
+        return null;
+    }
+    const aliases = readState().aliases ?? {};
+    const aliasTarget = aliases[normalizeAlias(normalized)];
+    if (aliasTarget) {
+        return aliasTarget;
+    }
+    return normalized;
+}
+export function loadClientConfig(baseUrl) {
+    ensureStoreReady();
+    const targetBaseUrl = baseUrl ?? getCurrentPlatform();
+    if (!targetBaseUrl) {
+        return null;
+    }
+    return readJsonFile(getPlatformFile(targetBaseUrl, "client.json"));
+}
+export function saveClientConfig(config) {
+    ensureStoreReady();
+    ensurePlatformDir(config.baseUrl);
+    writeJsonFile(getPlatformFile(config.baseUrl, "client.json"), config);
+}
+export function loadTokenConfig(baseUrl) {
+    ensureStoreReady();
+    const targetBaseUrl = baseUrl ?? getCurrentPlatform();
+    if (!targetBaseUrl) {
+        return null;
+    }
+    return readJsonFile(getPlatformFile(targetBaseUrl, "token.json"));
+}
+export function saveTokenConfig(config) {
+    ensureStoreReady();
+    ensurePlatformDir(config.baseUrl);
+    writeJsonFile(getPlatformFile(config.baseUrl, "token.json"), config);
+}
+export function loadCallbackSession(baseUrl) {
+    ensureStoreReady();
+    const targetBaseUrl = baseUrl ?? getCurrentPlatform();
+    if (!targetBaseUrl) {
+        return null;
+    }
+    return readJsonFile(getPlatformFile(targetBaseUrl, "callback.json"));
+}
+export function saveCallbackSession(session) {
+    ensureStoreReady();
+    ensurePlatformDir(session.baseUrl);
+    writeJsonFile(getPlatformFile(session.baseUrl, "callback.json"), session);
+}
+function migrateLegacyContextLoader(raw) {
+    const leg = raw;
+    if (leg?.knId && !Array.isArray(raw.configs)) {
+        return {
+            configs: [{ name: "default", knId: leg.knId }],
+            current: "default",
+        };
+    }
+    return raw;
+}
+export function loadContextLoaderConfig(baseUrl) {
+    ensureStoreReady();
+    const targetBaseUrl = baseUrl ?? getCurrentPlatform();
+    if (!targetBaseUrl) {
+        return null;
+    }
+    const raw = readJsonFile(getPlatformFile(targetBaseUrl, "context-loader.json"));
+    if (!raw)
+        return null;
+    const migrated = migrateLegacyContextLoader(raw);
+    if (!Array.isArray(migrated.configs) ||
+        migrated.configs.length === 0 ||
+        !migrated.current) {
+        return null;
+    }
+    const hasCurrent = migrated.configs.some((c) => c.name === migrated.current);
+    if (!hasCurrent)
+        return null;
+    const isLegacy = raw?.knId && !raw.configs;
+    if (isLegacy) {
+        saveContextLoaderConfig(targetBaseUrl, migrated);
+    }
+    return migrated;
+}
+export function saveContextLoaderConfig(baseUrl, config) {
+    ensureStoreReady();
+    ensurePlatformDir(baseUrl);
+    writeJsonFile(getPlatformFile(baseUrl, "context-loader.json"), config);
+}
+export function getCurrentContextLoaderKn(baseUrl) {
+    ensureStoreReady();
+    const targetBaseUrl = baseUrl ?? getCurrentPlatform();
+    if (!targetBaseUrl)
+        return null;
+    const client = loadClientConfig(targetBaseUrl);
+    if (!client?.baseUrl)
+        return null;
+    const config = loadContextLoaderConfig(targetBaseUrl);
+    if (!config)
+        return null;
+    const entry = config.configs.find((c) => c.name === config.current);
+    if (!entry)
+        return null;
+    return {
+        mcpUrl: buildMcpUrl(client.baseUrl),
+        knId: entry.knId,
+    };
+}
+export function addContextLoaderEntry(baseUrl, name, knId) {
+    ensureStoreReady();
+    const existing = loadContextLoaderConfig(baseUrl);
+    const configs = existing?.configs ?? [];
+    const idx = configs.findIndex((c) => c.name === name);
+    const entry = { name, knId };
+    const newConfigs = idx >= 0
+        ? configs.map((c, i) => (i === idx ? entry : c))
+        : [...configs, entry];
+    const current = existing?.current ?? name;
+    const hasCurrent = newConfigs.some((c) => c.name === current);
+    saveContextLoaderConfig(baseUrl, {
+        configs: newConfigs,
+        current: hasCurrent ? current : name,
+    });
+}
+export function setCurrentContextLoader(baseUrl, name) {
+    ensureStoreReady();
+    const config = loadContextLoaderConfig(baseUrl);
+    if (!config) {
+        throw new Error("Context-loader is not configured. Run: kweaver context-loader config set --kn-id <id>");
+    }
+    const hasName = config.configs.some((c) => c.name === name);
+    if (!hasName) {
+        throw new Error(`No context-loader config named '${name}'. Use config list to see available configs.`);
+    }
+    saveContextLoaderConfig(baseUrl, { ...config, current: name });
+}
+export function removeContextLoaderEntry(baseUrl, name) {
+    ensureStoreReady();
+    const config = loadContextLoaderConfig(baseUrl);
+    if (!config)
+        return;
+    const newConfigs = config.configs.filter((c) => c.name !== name);
+    if (newConfigs.length === 0) {
+        const file = getPlatformFile(baseUrl, "context-loader.json");
+        if (existsSync(file))
+            rmSync(file, { force: true });
+        return;
+    }
+    let newCurrent = config.current;
+    if (config.current === name) {
+        newCurrent = newConfigs[0].name;
+    }
+    saveContextLoaderConfig(baseUrl, { configs: newConfigs, current: newCurrent });
+}
+export function hasPlatform(baseUrl) {
+    ensureStoreReady();
+    return existsSync(getPlatformFile(baseUrl, "client.json"));
+}
+/**
+ * Remove token and callback for a platform so the next auth will do a full login.
+ * Keeps client config so the same app registration can be reused.
+ */
+export function clearPlatformSession(baseUrl) {
+    ensureStoreReady();
+    const tokenFile = getPlatformFile(baseUrl, "token.json");
+    const callbackFile = getPlatformFile(baseUrl, "callback.json");
+    if (existsSync(tokenFile)) {
+        rmSync(tokenFile, { force: true });
+    }
+    if (existsSync(callbackFile)) {
+        rmSync(callbackFile, { force: true });
+    }
+}
+export function deletePlatform(baseUrl) {
+    ensureStoreReady();
+    const platformDir = getPlatformDir(baseUrl);
+    if (!existsSync(platformDir)) {
+        return;
+    }
+    deletePlatformAlias(baseUrl);
+    rmSync(platformDir, { recursive: true, force: true });
+    const state = readState();
+    if (state.currentPlatform !== baseUrl) {
+        return;
+    }
+    const remainingPlatforms = listPlatforms();
+    writeState({
+        ...readState(),
+        currentPlatform: remainingPlatforms[0]?.baseUrl,
+    });
+}
+export function listPlatforms() {
+    ensureStoreReady();
+    const currentPlatform = getCurrentPlatform();
+    const items = [];
+    for (const entry of readdirSync(getPlatformsDirPath())) {
+        const dirPath = join(getPlatformsDirPath(), entry);
+        if (!statSync(dirPath).isDirectory()) {
+            continue;
+        }
+        const client = readJsonFile(join(dirPath, "client.json"));
+        if (!client?.baseUrl) {
+            continue;
+        }
+        items.push({
+            baseUrl: client.baseUrl,
+            hasToken: existsSync(join(dirPath, "token.json")),
+            isCurrent: client.baseUrl === currentPlatform,
+            alias: getPlatformAlias(client.baseUrl) ?? undefined,
+        });
+    }
+    items.sort((a, b) => a.baseUrl.localeCompare(b.baseUrl));
+    return items;
+}

package/dist/index.d.ts

@@ -0,0 +1,53 @@
+/**
+ * KWeaver TypeScript SDK — public API entry point.
+ *
+ * ## Recommended: KWeaverClient (high-level)
+ *
+ * ```typescript
+ * import { KWeaverClient } from "kweaver-sdk";
+ *
+ * const client = new KWeaverClient({ baseUrl, accessToken });
+ * const kns  = await client.knowledgeNetworks.list();
+ * const reply = await client.agents.chat("agent-id", "你好");
+ * ```
+ *
+ * ## Advanced: raw API functions (low-level)
+ *
+ * All API functions take explicit `baseUrl` and `accessToken` parameters.
+ * Use `getCurrentPlatform` / `getConfigDir` to read credentials saved by the CLI.
+ *
+ * @example
+ * ```typescript
+ * import { listKnowledgeNetworks, sendChatRequest } from "kweaver-sdk";
+ *
+ * const kns = await listKnowledgeNetworks({ baseUrl, accessToken });
+ * const reply = await sendChatRequest({ baseUrl, accessToken, agentId, agentKey, agentVersion, query, stream: false });
+ * console.log(reply.text);
+ * ```
+ */
+export type { ListKnowledgeNetworksOptions, GetKnowledgeNetworkOptions, CreateKnowledgeNetworkOptions, UpdateKnowledgeNetworkOptions, DeleteKnowledgeNetworkOptions, ListSchemaTypesOptions, } from "./api/knowledge-networks.js";
+export { listKnowledgeNetworks, getKnowledgeNetwork, createKnowledgeNetwork, updateKnowledgeNetwork, deleteKnowledgeNetwork, listObjectTypes, listRelationTypes, listActionTypes, } from "./api/knowledge-networks.js";
+export type { OntologyQueryBaseOptions, ObjectTypeQueryOptions, ObjectTypePropertiesOptions, SubgraphOptions, ActionTypeQueryOptions, ActionTypeExecuteOptions, ActionExecutionGetOptions, ActionLogsListOptions, ActionLogGetOptions, ActionLogCancelOptions, } from "./api/ontology-query.js";
+export { objectTypeQuery, objectTypeProperties, subgraph, actionTypeQuery, actionTypeExecute, actionExecutionGet, actionLogsList, actionLogGet, actionLogCancel, } from "./api/ontology-query.js";
+export type { SendChatRequestOptions, SendChatRequestStreamCallbacks, ChatResult, ProgressItem, AgentInfo, } from "./api/agent-chat.js";
+export { sendChatRequest, sendChatRequestStream, fetchAgentInfo, buildChatUrl, buildAgentInfoUrl, extractText, } from "./api/agent-chat.js";
+export type { ListAgentsOptions } from "./api/agent-list.js";
+export { listAgents } from "./api/agent-list.js";
+export type { ListConversationsOptions, ListMessagesOptions } from "./api/conversations.js";
+export { listConversations, listMessages } from "./api/conversations.js";
+export type { SemanticSearchOptions } from "./api/semantic-search.js";
+export { semanticSearch } from "./api/semantic-search.js";
+export type { ContextLoaderCallOptions, KnSearchArgs, KnSchemaSearchArgs, ConditionSpec, QueryObjectInstanceArgs, RelationTypePath, QueryInstanceSubgraphArgs, GetLogicPropertiesValuesArgs, GetActionInfoArgs, MissingInputParamsError, } from "./api/context-loader.js";
+export { knSearch, knSchemaSearch, queryObjectInstance, queryInstanceSubgraph, getLogicPropertiesValues, getActionInfo, formatMissingInputParamsHint, validateCondition, validateInstanceIdentity, validateInstanceIdentities, } from "./api/context-loader.js";
+export type { ConfigureOptions } from "./kweaver.js";
+export { configure, search, agents, chat, bkns, weaver, getClient } from "./kweaver.js";
+export type { KWeaverClientOptions, ClientContext } from "./client.js";
+export { KWeaverClient } from "./client.js";
+export { KnowledgeNetworksResource } from "./resources/knowledge-networks.js";
+export { AgentsResource } from "./resources/agents.js";
+export { BknResource } from "./resources/bkn.js";
+export { ConversationsResource } from "./resources/conversations.js";
+export { ContextLoaderResource } from "./resources/context-loader.js";
+export { HttpError, NetworkRequestError, fetchTextOrThrow } from "./utils/http.js";
+export type { ClientConfig, TokenConfig, ContextLoaderEntry, ContextLoaderConfig, PlatformSummary, } from "./config/store.js";
+export { getConfigDir, getCurrentPlatform } from "./config/store.js";

package/dist/index.js

@@ -0,0 +1,44 @@
+/**
+ * KWeaver TypeScript SDK — public API entry point.
+ *
+ * ## Recommended: KWeaverClient (high-level)
+ *
+ * ```typescript
+ * import { KWeaverClient } from "kweaver-sdk";
+ *
+ * const client = new KWeaverClient({ baseUrl, accessToken });
+ * const kns  = await client.knowledgeNetworks.list();
+ * const reply = await client.agents.chat("agent-id", "你好");
+ * ```
+ *
+ * ## Advanced: raw API functions (low-level)
+ *
+ * All API functions take explicit `baseUrl` and `accessToken` parameters.
+ * Use `getCurrentPlatform` / `getConfigDir` to read credentials saved by the CLI.
+ *
+ * @example
+ * ```typescript
+ * import { listKnowledgeNetworks, sendChatRequest } from "kweaver-sdk";
+ *
+ * const kns = await listKnowledgeNetworks({ baseUrl, accessToken });
+ * const reply = await sendChatRequest({ baseUrl, accessToken, agentId, agentKey, agentVersion, query, stream: false });
+ * console.log(reply.text);
+ * ```
+ */
+export { listKnowledgeNetworks, getKnowledgeNetwork, createKnowledgeNetwork, updateKnowledgeNetwork, deleteKnowledgeNetwork, listObjectTypes, listRelationTypes, listActionTypes, } from "./api/knowledge-networks.js";
+export { objectTypeQuery, objectTypeProperties, subgraph, actionTypeQuery, actionTypeExecute, actionExecutionGet, actionLogsList, actionLogGet, actionLogCancel, } from "./api/ontology-query.js";
+export { sendChatRequest, sendChatRequestStream, fetchAgentInfo, buildChatUrl, buildAgentInfoUrl, extractText, } from "./api/agent-chat.js";
+export { listAgents } from "./api/agent-list.js";
+export { listConversations, listMessages } from "./api/conversations.js";
+export { semanticSearch } from "./api/semantic-search.js";
+export { knSearch, knSchemaSearch, queryObjectInstance, queryInstanceSubgraph, getLogicPropertiesValues, getActionInfo, formatMissingInputParamsHint, validateCondition, validateInstanceIdentity, validateInstanceIdentities, } from "./api/context-loader.js";
+export { configure, search, agents, chat, bkns, weaver, getClient } from "./kweaver.js";
+export { KWeaverClient } from "./client.js";
+export { KnowledgeNetworksResource } from "./resources/knowledge-networks.js";
+export { AgentsResource } from "./resources/agents.js";
+export { BknResource } from "./resources/bkn.js";
+export { ConversationsResource } from "./resources/conversations.js";
+export { ContextLoaderResource } from "./resources/context-loader.js";
+// ── HTTP utilities ────────────────────────────────────────────────────────────
+export { HttpError, NetworkRequestError, fetchTextOrThrow } from "./utils/http.js";
+export { getConfigDir, getCurrentPlatform } from "./config/store.js";

package/dist/kweaver.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Module-level simple API — cognee-style usage without instantiating KWeaverClient.
+ *
+ * @example Read-only (search + chat, no weaver needed)
+ * ```typescript
+ * import kweaver from "kweaver-sdk/kweaver";
+ *
+ * kweaver.configure({ config: true, bknId: "your-bkn-id", agentId: "your-agent-id" });
+ *
+ * const results = await kweaver.search("供应链有哪些风险？");
+ * const reply   = await kweaver.chat("总结前三大风险");
+ * console.log(reply.text);
+ * ```
+ *
+ * @example Write then build
+ * ```typescript
+ * kweaver.configure({ baseUrl: "https://...", accessToken: "token", bknId: "abc" });
+ * // ... add datasource, object types via kweaver.client ...
+ * await kweaver.weaver({ wait: true });
+ * const results = await kweaver.search("新接入的数据");
+ * ```
+ */
+import { KWeaverClient } from "./client.js";
+import type { ChatResult } from "./api/agent-chat.js";
+import type { SemanticSearchResult } from "./resources/bkn.js";
+import type { BuildStatus } from "./resources/knowledge-networks.js";
+export interface ConfigureOptions {
+    /**
+     * KWeaver base URL. Required unless config=true or KWEAVER_BASE_URL is set.
+     */
+    baseUrl?: string;
+    /** Bearer access token. Required unless config=true or KWEAVER_TOKEN is set. */
+    accessToken?: string;
+    /**
+     * If true, read credentials from ~/.kweaver/ (saved by `kweaver auth login`).
+     * When config=true, baseUrl is ignored — the URL comes from the saved platform
+     * config, preventing accidental cross-environment credential leaks.
+     */
+    config?: boolean;
+    /** Default BKN ID used by search() and weaver(). */
+    bknId?: string;
+    /** Default agent ID used by chat(). */
+    agentId?: string;
+    /** x-business-domain header. Defaults to "bd_public". */
+    businessDomain?: string;
+}
+/**
+ * Initialize the default KWeaver client.
+ * Must be called before any other kweaver.* function.
+ *
+ * @example
+ * ```typescript
+ * kweaver.configure({ config: true, bknId: "abc", agentId: "ag1" });
+ * kweaver.configure({ baseUrl: "https://...", accessToken: "token", bknId: "abc" });
+ * ```
+ */
+export declare function configure(opts: ConfigureOptions): void;
+/**
+ * Semantic search over a BKN.
+ *
+ * @example
+ * ```typescript
+ * const results = await kweaver.search("供应链风险");
+ * for (const c of results.concepts) console.log(c.concept_name);
+ * ```
+ */
+export declare function search(query: string, opts?: {
+    bknId?: string;
+    mode?: string;
+    maxConcepts?: number;
+}): Promise<SemanticSearchResult>;
+/**
+ * List published agents.
+ *
+ * @example
+ * ```typescript
+ * const list = await kweaver.agents({ keyword: "supply" });
+ * list.forEach(a => console.log(a));
+ * ```
+ */
+export declare function agents(opts?: {
+    keyword?: string;
+    limit?: number;
+}): Promise<unknown[]>;
+/**
+ * Send a message to an agent.
+ *
+ * @example
+ * ```typescript
+ * const reply = await kweaver.chat("分析供应链风险");
+ * console.log(reply.text);
+ * ```
+ */
+export declare function chat(message: string, opts?: {
+    agentId?: string;
+    conversationId?: string;
+}): Promise<ChatResult>;
+/**
+ * List BKNs (Business Knowledge Networks).
+ *
+ * @example
+ * ```typescript
+ * const list = await kweaver.bkns();
+ * list.forEach(b => console.log(b));
+ * ```
+ */
+export declare function bkns(opts?: {
+    limit?: number;
+    name_pattern?: string;
+}): Promise<unknown[]>;
+/**
+ * Trigger a full build (index rebuild) of a BKN.
+ *
+ * Only needed after write-side changes (added datasource, modified object/relation
+ * types). Pure read-only usage (search, chat) does not require weaver().
+ *
+ * @param opts.wait     If true, poll until completed and return the final BuildStatus.
+ * @param opts.timeout  Max wait time in **milliseconds** (default 300_000 = 5 min).
+ *                      Note: Python SDK uses seconds; multiply by 1000 when porting.
+ * @param opts.interval Poll interval in **milliseconds** (default 2_000).
+ *
+ * @example
+ * ```typescript
+ * await kweaver.weaver({ wait: true });              // block until done
+ * await kweaver.weaver({ wait: true, timeout: 60_000 }); // 60-second timeout
+ * await kweaver.weaver();                            // fire-and-forget (returns void)
+ * ```
+ */
+export declare function weaver(opts?: {
+    bknId?: string;
+    wait?: boolean;
+    timeout?: number;
+    interval?: number;
+}): Promise<BuildStatus | void>;
+/** Access the underlying KWeaverClient for advanced operations. */
+export declare function getClient(): KWeaverClient;
+declare const _default: {
+    configure: typeof configure;
+    search: typeof search;
+    agents: typeof agents;
+    chat: typeof chat;
+    bkns: typeof bkns;
+    weaver: typeof weaver;
+    getClient: typeof getClient;
+};
+export default _default;