@kweaver-ai/kweaver-sdk 0.6.10 → 0.7.1

package/README.md

@@ -143,15 +143,20 @@ const rows = await client.vega.sqlQuery(
   JSON.stringify({ query: "SELECT * FROM {{res-1}} LIMIT 5", resource_type: "mysql" }),
 );
 
-// Context Loader (semantic search over a BKN via MCP)
+// Context Loader (MCP search_schema plus generic tools/call)
 const cl      = client.contextLoader(mcpUrl, "bkn-id");
-const results = await cl.search({ query: "hypertension treatment" });
+const schema  = await cl.searchSchema({ query: "hypertension treatment" });
+const rawTool = await cl.callTool("search_schema", { query: "hypertension treatment" });
 
 // Skills (registry + market + progressive read)
 const skills = await client.skills.market({ name: "kweaver" });
 const skillMd = await client.skills.fetchContent("skill-id");
 ```
 
+`searchSchema()` is the typed wrapper for the Context Loader MCP `search_schema` tool. It defaults `response_format` to `json` and accepts `query`, `response_format`, `search_scope`, `max_concepts`, `schema_brief`, and `enable_rerank`. The parsed response may contain `object_types`, `relation_types`, `action_types`, and `metric_types`.
+
+Use `callTool(name, args)` when you need native MCP `tools/call` access for newly added server tools before the SDK adds a typed wrapper. Arguments are passed through unchanged.
+
 ## CLI Reference
 
 ```
@@ -184,7 +189,7 @@ kweaver agent list/get/create/update/delete/chat/sessions/history/publish/unpubl
 kweaver skill list/market/get/register/status/delete/content/read-file/download/install
 kweaver vega health/stats/inspect/sql/catalog/resource/connector-type
 kweaver context-loader config set/use/list/show
-kweaver context-loader kn-search/query-object-instance/...
+kweaver context-loader search-schema/tool-call/kn-search/query-object-instance/find-skills/...
 kweaver toolbox create/list/publish/unpublish/delete
 kweaver tool upload/list/enable/disable
 kweaver call <path> [-X METHOD] [-d BODY] [-H header] [-F key=value]

package/README.zh.md

@@ -136,15 +136,20 @@ const rows = await client.vega.sqlQuery(
   JSON.stringify({ query: "SELECT * FROM {{res-1}} LIMIT 5", resource_type: "mysql" }),
 );
 
-// Context Loader（通过 MCP 对 BKN 做语义搜索）
+// Context Loader（MCP search_schema + 通用 tools/call）
 const cl      = client.contextLoader(mcpUrl, "bkn-id");
-const results = await cl.search({ query: "高血压 治疗" });
+const schema  = await cl.searchSchema({ query: "高血压 治疗" });
+const rawTool = await cl.callTool("search_schema", { query: "高血压 治疗" });
 
 // Skill（注册表/市场/渐进式读取）
 const skills = await client.skills.market({ name: "kweaver" });
 const skillMd = await client.skills.fetchContent("skill-id");
 ```
 
+`searchSchema()` 是 Context Loader MCP `search_schema` 的类型化封装，默认 `response_format` 为 `json`，支持 `query`、`response_format`、`search_scope`、`max_concepts`、`schema_brief`、`enable_rerank`。解析后的返回结果可能包含 `object_types`、`relation_types`、`action_types`、`metric_types`。
+
+需要直接使用 MCP 原生 `tools/call` 时，使用 `callTool(name, args)`。这适用于服务端新增工具但 SDK 尚未提供类型化封装的场景，参数会原样透传。
+
 ## 命令速查
 
 ```
@@ -172,7 +177,7 @@ kweaver agent list/get/chat/sessions/history
 kweaver skill list/market/get/register/status/delete/content/read-file/download/install
 kweaver vega health|stats|inspect|sql|catalog|resource|connector-type
 kweaver context-loader config set/use/list/show
-kweaver context-loader kn-search/query-object-instance/...
+kweaver context-loader search-schema/tool-call/kn-search/query-object-instance/find-skills/...
 kweaver call <path> [-X METHOD] [-d BODY] [-H header]
 ```
 

package/dist/api/context-loader.d.ts

@@ -4,15 +4,28 @@ export interface ContextLoaderCallOptions {
     knId: string;
     accessToken: string;
 }
-/** Layer 1: kn_search arguments. */
-export interface KnSearchArgs {
-    query: string;
-    only_schema?: boolean;
+export interface SearchSchemaScope {
+    include_object_types?: boolean;
+    include_relation_types?: boolean;
+    include_action_types?: boolean;
+    include_metric_types?: boolean;
 }
-/** Layer 1: kn_schema_search arguments. */
-export interface KnSchemaSearchArgs {
+/** Layer 1: search_schema arguments. */
+export interface SearchSchemaArgs {
     query: string;
+    response_format?: "json" | "toon";
+    search_scope?: SearchSchemaScope;
     max_concepts?: number;
+    schema_brief?: boolean;
+    enable_rerank?: boolean;
+}
+/** Layer 1: search_schema result. */
+export interface SearchSchemaResult {
+    object_types?: unknown[];
+    relation_types?: unknown[];
+    action_types?: unknown[];
+    metric_types?: unknown[];
+    raw?: string;
 }
 /** Condition for query_object_instance and query_instance_subgraph. */
 export interface ConditionSpec {
@@ -60,6 +73,24 @@ export interface GetActionInfoArgs {
     at_id: string;
     _instance_identity: Record<string, string>;
 }
+/** Layer 3: find_skills arguments (object_type_id is required). */
+export interface FindSkillsArgs {
+    object_type_id: string;
+    response_format?: "json" | "toon";
+    instance_identities?: Record<string, unknown>[];
+    skill_query?: string;
+    /** 1..20, default 10 on the server side. */
+    top_k?: number;
+}
+/** Layer 3: find_skills result. */
+export interface FindSkillsResult {
+    entries: Array<{
+        skill_id: string;
+        name: string;
+        description?: string;
+    }>;
+    message?: string;
+}
 /** Error when get_logic_properties_values returns MISSING_INPUT_PARAMS. */
 export interface MissingInputParamsError {
     error_code: "MISSING_INPUT_PARAMS";
@@ -81,10 +112,9 @@ export declare function validateCondition(condition: unknown): void;
 export declare function validateInstanceIdentity(v: unknown, label: string): void;
 /** Guardrail: _instance_identities must be array of plain objects from Layer 2. */
 export declare function validateInstanceIdentities(v: unknown): void;
-/** Layer 1: kn_search. Returns object_types, relation_types, action_types. */
-export declare function knSearch(options: ContextLoaderCallOptions, args: KnSearchArgs): Promise<unknown>;
-/** Layer 1: kn_schema_search. Returns concepts (candidate discovery only). */
-export declare function knSchemaSearch(options: ContextLoaderCallOptions, args: KnSchemaSearchArgs): Promise<unknown>;
+export declare function callTool(options: ContextLoaderCallOptions, toolName: string, args: Record<string, unknown>): Promise<unknown>;
+/** Layer 1: search_schema. Returns object_types, relation_types, action_types, metric_types. */
+export declare function searchSchema(options: ContextLoaderCallOptions, args: SearchSchemaArgs): Promise<SearchSchemaResult>;
 /** Layer 2: query_object_instance. Returns datas with _instance_identity. */
 export declare function queryObjectInstance(options: ContextLoaderCallOptions, args: QueryObjectInstanceArgs): Promise<unknown>;
 /** Layer 2: query_instance_subgraph. Returns entries with nested _instance_identity. */
@@ -93,6 +123,11 @@ export declare function queryInstanceSubgraph(options: ContextLoaderCallOptions,
 export declare function getLogicPropertiesValues(options: ContextLoaderCallOptions, args: GetLogicPropertiesValuesArgs): Promise<unknown>;
 /** Layer 3: get_action_info. Returns _dynamic_tools. */
 export declare function getActionInfo(options: ContextLoaderCallOptions, args: GetActionInfoArgs): Promise<unknown>;
+/**
+ * Layer 3: find_skills. Recall skills attached to an object type or
+ * (optionally) narrowed to specific instances.
+ */
+export declare function findSkills(options: ContextLoaderCallOptions, args: FindSkillsArgs): Promise<FindSkillsResult>;
 /** MCP tools/list. Returns list of available tools. */
 export declare function listTools(options: ContextLoaderCallOptions, params?: {
     cursor?: string;

package/dist/api/context-loader.js

@@ -149,7 +149,7 @@ async function callMcpMethod(options, method, params = {}) {
     }
     throw new Error("Context-loader returned no result");
 }
-async function callTool(options, toolName, args) {
+export async function callTool(options, toolName, args) {
     const sessionId = await ensureSession(options);
     const id = (requestId += 1);
     const body = JSON.stringify({
@@ -208,13 +208,21 @@ async function callTool(options, toolName, args) {
     }
     throw new Error("Context-loader returned no result");
 }
-/** Layer 1: kn_search. Returns object_types, relation_types, action_types. */
-export async function knSearch(options, args) {
-    return callTool(options, "kn_search", { ...args });
-}
-/** Layer 1: kn_schema_search. Returns concepts (candidate discovery only). */
-export async function knSchemaSearch(options, args) {
-    return callTool(options, "kn_schema_search", { ...args });
+/** Layer 1: search_schema. Returns object_types, relation_types, action_types, metric_types. */
+export async function searchSchema(options, args) {
+    const toolArgs = {
+        query: args.query,
+        response_format: args.response_format ?? "json",
+    };
+    if (args.search_scope !== undefined)
+        toolArgs.search_scope = args.search_scope;
+    if (args.max_concepts !== undefined)
+        toolArgs.max_concepts = args.max_concepts;
+    if (args.schema_brief !== undefined)
+        toolArgs.schema_brief = args.schema_brief;
+    if (args.enable_rerank !== undefined)
+        toolArgs.enable_rerank = args.enable_rerank;
+    return (await callTool(options, "search_schema", toolArgs));
 }
 /** Layer 2: query_object_instance. Returns datas with _instance_identity. */
 export async function queryObjectInstance(options, args) {
@@ -240,6 +248,33 @@ export async function getActionInfo(options, args) {
     validateInstanceIdentity(args._instance_identity, "_instance_identity");
     return callTool(options, "get_action_info", { ...args });
 }
+/**
+ * Layer 3: find_skills. Recall skills attached to an object type or
+ * (optionally) narrowed to specific instances.
+ */
+export async function findSkills(options, args) {
+    if (!args.object_type_id || typeof args.object_type_id !== "string") {
+        throw new Error("find_skills: object_type_id is required.");
+    }
+    if (args.top_k !== undefined && (args.top_k < 1 || args.top_k > 20)) {
+        throw new Error("find_skills: top_k must be between 1 and 20.");
+    }
+    if (args.instance_identities !== undefined) {
+        validateInstanceIdentities(args.instance_identities);
+    }
+    const toolArgs = {
+        object_type_id: args.object_type_id,
+    };
+    if (args.response_format !== undefined)
+        toolArgs.response_format = args.response_format;
+    if (args.instance_identities !== undefined)
+        toolArgs.instance_identities = args.instance_identities;
+    if (args.skill_query !== undefined)
+        toolArgs.skill_query = args.skill_query;
+    if (args.top_k !== undefined)
+        toolArgs.top_k = args.top_k;
+    return (await callTool(options, "find_skills", toolArgs));
+}
 /** MCP tools/list. Returns list of available tools. */
 export async function listTools(options, params) {
     return callMcpMethod(options, "tools/list", params ? { cursor: params.cursor } : {});

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

@@ -10,3 +10,12 @@ export interface SemanticSearchOptions {
     returnQueryUnderstanding?: boolean;
 }
 export declare function semanticSearch(options: SemanticSearchOptions): Promise<string>;
+export interface KnSearchHttpOptions {
+    baseUrl: string;
+    accessToken: string;
+    knId: string;
+    query: string;
+    businessDomain?: string;
+    onlySchema?: boolean;
+}
+export declare function knSearchHttp(options: KnSearchHttpOptions): Promise<string>;

package/dist/api/semantic-search.js

@@ -22,3 +22,22 @@ export async function semanticSearch(options) {
     }
     return body;
 }
+export async function knSearchHttp(options) {
+    const { baseUrl, accessToken, knId, query, businessDomain = "bd_public", onlySchema = false, } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/agent-retrieval/v1/kn/kn_search`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: { ...buildHeaders(accessToken, businessDomain), "content-type": "application/json" },
+        body: JSON.stringify({
+            kn_id: knId,
+            query,
+            only_schema: onlySchema,
+        }),
+    });
+    const body = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, body);
+    }
+    return body;
+}

package/dist/api/toolboxes.d.ts

@@ -44,6 +44,18 @@ export interface ListToolsOptions extends BaseOpts {
     boxId: string;
 }
 export declare function listTools(opts: ListToolsOptions): Promise<string>;
+export type ImpexType = "toolbox" | "mcp" | "operator";
+export interface ExportConfigOptions extends BaseOpts {
+    id: string;
+    type?: ImpexType;
+}
+export declare function exportConfig(opts: ExportConfigOptions): Promise<Uint8Array>;
+export interface ImportConfigOptions extends BaseOpts {
+    /** Path to a previously exported `.adp` JSON file. */
+    filePath: string;
+    type?: ImpexType;
+}
+export declare function importConfig(opts: ImportConfigOptions): Promise<string>;
 export interface InvokeToolOptions extends BaseOpts {
     boxId: string;
     toolId: string;

package/dist/api/toolboxes.js

@@ -1,6 +1,6 @@
 import { readFile } from "node:fs/promises";
 import { basename } from "node:path";
-import { fetchTextOrThrow } from "../utils/http.js";
+import { HttpError, fetchTextOrThrow, fetchWithRetry } from "../utils/http.js";
 import { buildHeaders } from "./headers.js";
 // Backend endpoints under /api/agent-operator-integration/v1/tool-box.
 //
@@ -97,6 +97,48 @@ export async function listTools(opts) {
     });
     return body;
 }
+// ── impex (export / import) ──────────────────────────────────────────────────
+//
+// Backend mounts the impex endpoints on the same service but under a different
+// path:
+//
+//   GET  /api/agent-operator-integration/v1/impex/export/{type}/{id}
+//   POST /api/agent-operator-integration/v1/impex/import/{type}   (multipart, field "data")
+//
+// Supported {type} values today: "toolbox" | "mcp" | "operator".
+//
+// Export response is the raw JSON config (Content-Type: application/json) plus
+// a `Content-Disposition: attachment; filename=<type>_export_<ts>.adp` header.
+const IMPEX_PATH = "/api/agent-operator-integration/v1/impex";
+export async function exportConfig(opts) {
+    const t = opts.type ?? "toolbox";
+    const target = `${opts.baseUrl.replace(/\/+$/, "")}${IMPEX_PATH}/export/${encodeURIComponent(t)}/${encodeURIComponent(opts.id)}`;
+    // Use raw bytes (not text) so we never lose precision on non-ASCII payloads
+    // and stay symmetric with the Python SDK's `export_config -> bytes`.
+    const response = await fetchWithRetry(target, {
+        method: "GET",
+        headers: buildHeaders(opts.accessToken, opts.businessDomain ?? "bd_public"),
+    });
+    const buf = new Uint8Array(await response.arrayBuffer());
+    if (!response.ok) {
+        const text = new TextDecoder("utf-8").decode(buf);
+        throw new HttpError(response.status, response.statusText, text);
+    }
+    return buf;
+}
+export async function importConfig(opts) {
+    const buf = await readFile(opts.filePath);
+    const t = opts.type ?? "toolbox";
+    const form = new FormData();
+    form.append("data", new Blob([buf]), basename(opts.filePath));
+    const target = `${opts.baseUrl.replace(/\/+$/, "")}${IMPEX_PATH}/import/${encodeURIComponent(t)}`;
+    const { body } = await fetchTextOrThrow(target, {
+        method: "POST",
+        headers: buildHeaders(opts.accessToken, opts.businessDomain ?? "bd_public"),
+        body: form,
+    });
+    return body;
+}
 function buildEnvelope(opts) {
     const envelope = {};
     if (opts.timeout !== undefined)

package/dist/cli.js

@@ -39,26 +39,26 @@ Usage:
   kweaver token
 
   kweaver call <url> [-X METHOD] [-H "Name: value"] [-d BODY] [--data-raw BODY]
-             [--url URL] [--pretty] [--verbose] [-bd value]
+             [--url URL] [--verbose] [-bd value]
   (alias: kweaver curl ...)
 
   kweaver agent chat <agent_id> [-m "message"] [--version value] [--conversation-id id]
                 [--stream] [--no-stream] [--verbose] [-bd value]
-  kweaver agent list [--name X] [--limit N] [--offset N] [-bd value] [--pretty]
-  kweaver agent get <agent_id> [-bd value] [--pretty]
-  kweaver agent get-by-key <key> [-bd value] [--pretty]
-  kweaver agent sessions <agent_id> [-bd value] [--limit N] [--pretty]
-  kweaver agent history <conversation_id> [-bd value] [--limit N] [--pretty]
+  kweaver agent list [--name X] [--limit N] [--offset N] [-bd value]
+  kweaver agent get <agent_id> [-bd value]
+  kweaver agent get-by-key <key> [-bd value]
+  kweaver agent sessions <agent_id> [-bd value] [--limit N]
+  kweaver agent history <conversation_id> [-bd value] [--limit N]
   kweaver agent create [options]
   kweaver agent update <agent_id> [options]
   kweaver agent delete <agent_id> [-bd value]
   kweaver agent publish <agent_id> [-bd value]
   kweaver agent unpublish <agent_id> [-bd value]
 
-  kweaver ds list [--keyword X] [--type T] [-bd value] [--pretty]
+  kweaver ds list [--keyword X] [--type T] [-bd value]
   kweaver ds get <id>
   kweaver ds delete <id> [-y]
-  kweaver ds tables <id> [--keyword X] [--pretty]
+  kweaver ds tables <id> [--keyword X]
   kweaver ds connect <db_type> <host> <port> <database> --account X --password Y [--schema S] [--name N]
 
   kweaver dataflow list [-bd value]
@@ -66,15 +66,15 @@ Usage:
   kweaver dataflow runs <dagId> [--since <date-like>] [-bd value]
   kweaver dataflow logs <dagId> <instanceId> [--detail] [-bd value]
 
-  kweaver dataview list [--datasource-id id] [--type atomic|custom] [--limit n] [-bd value] [--pretty]
-  kweaver dataview find --name <name> [--exact] [--datasource-id id] [--wait] [--timeout ms] [-bd value] [--pretty]
-  kweaver dataview get <id> [-bd value] [--pretty]
-  kweaver dataview query <id> [--sql sql] [--limit n] [--offset n] [--need-total] [--raw-sql] [-bd value] [--pretty]
+  kweaver dataview list [--datasource-id id] [--type atomic|custom] [--limit n] [-bd value]
+  kweaver dataview find --name <name> [--exact] [--datasource-id id] [--wait] [--timeout ms] [-bd value]
+  kweaver dataview get <id> [-bd value]
+  kweaver dataview query <id> [--sql sql] [--limit n] [--offset n] [--need-total] [--raw-sql] [-bd value]
   kweaver dataview delete <id> [-y] [-bd value]
 
   kweaver bkn list [options]
   kweaver bkn get <kn-id> [options]
-  kweaver bkn search <kn-id> <query> [--max-concepts N] [--mode M] [--pretty] [-bd value]
+  kweaver bkn search <kn-id> <query> [--max-concepts N] [--mode M] [-bd value]
   kweaver bkn create [options]
   kweaver bkn create-from-ds [options]
   kweaver bkn update <kn-id> [options]
@@ -107,6 +107,8 @@ Usage:
   kweaver toolbox list [--keyword X] [--limit N] [--offset N] [-bd value]
   kweaver toolbox publish|unpublish <box-id> [-bd value]
   kweaver toolbox delete <box-id> [-y] [-bd value]
+  kweaver toolbox export <box-id> [-o <file>|-] [--type toolbox|mcp|operator]
+  kweaver toolbox import <file> [--type toolbox|mcp|operator]
 
   kweaver tool upload --toolbox <box-id> <openapi-spec-path> [--metadata-type openapi]
   kweaver tool list --toolbox <box-id> [-bd value]
@@ -125,13 +127,18 @@ Usage:
   kweaver context-loader tools|resources|templates|prompts [--cursor]
   kweaver context-loader resource <uri>
   kweaver context-loader prompt <name> [--args json]
-  kweaver context-loader kn-search <query> [--only-schema]
-  kweaver context-loader kn-schema-search <query> [--max N]
-  kweaver context-loader query-object-instance|query-instance-subgraph|get-logic-properties|get-action-info ...
+  kweaver context-loader search-schema <query> [--scope object,relation,action,metric] [--max N]
+  kweaver context-loader tool-call <name> --args '<json>'
+  kweaver context-loader kn-search <query> [--only-schema]      (compat HTTP)
+  kweaver context-loader kn-schema-search <query> [--max N]     (compat HTTP)
+  kweaver context-loader query-object-instance|query-instance-subgraph|get-logic-properties|get-action-info|find-skills ...
   (alias: kweaver context ...)
 
 Global options:
   --user <id|name>  Use a specific user's credentials for this command (env: KWEAVER_USER)
+  --pretty / --compact
+                    Toggle pretty-printed JSON output. Supported by every
+                    command that prints a JSON payload (default: pretty).
 
 Commands:
   auth           Login, list, inspect, and switch saved platform auth profiles
@@ -145,10 +152,10 @@ Commands:
                  object-type, relation-type, subgraph, action-type, action-execution, action-log)
   config         Per-platform configuration (business domain)
   skill          Skill registry and market (register, search, progressive read, download/install)
-  toolbox        Agent toolbox lifecycle (create, list, publish, delete)
+  toolbox        Agent toolbox lifecycle (create, list, publish, delete, export, import)
   tool           Tools inside a toolbox (upload OpenAPI spec, list, enable/disable)
   vega           Vega observability (catalog, resource, query/sql, connector-type, health/stats/inspect)
-  context-loader Context-loader MCP (config, tools, resources, prompts, kn-search, query-*, etc.)
+  context-loader Context-loader MCP/HTTP (config, tools, resources, search-schema, tool-call, query-*, etc.)
   help           Show this message`);
 }
 export async function run(argv) {

package/dist/commands/bkn-query.js

@@ -31,13 +31,18 @@ Query subgraph via ontology-query API. JSON body format see references/json-form
         return 1;
     }
     try {
-        // Auto-detect query_type=relation_path when body contains source_object_type_id
+        // Map body shape to ontology-query subgraph query_type:
+        // - relation_type_paths mode → ?query_type=relation_path
+        // - source_object_type_id mode → omit query_type (default path; do not send relation_path)
         let queryType;
         try {
             const parsedBody = JSON.parse(body);
-            if (parsedBody.source_object_type_id) {
+            if (Array.isArray(parsedBody.relation_type_paths)) {
                 queryType = "relation_path";
             }
+            else if (parsedBody.source_object_type_id) {
+                queryType = "";
+            }
         }
         catch {
             // Not valid JSON — let the API return the error

package/dist/commands/context-loader.js

@@ -1,6 +1,7 @@
 import { ensureValidToken, formatHttpError, resolveActivePlatform, with401RefreshRetry } from "../auth/oauth.js";
-import { knSearch, knSchemaSearch, queryObjectInstance, queryInstanceSubgraph, getLogicPropertiesValues, getActionInfo, listTools, listResources, readResource, listResourceTemplates, listPrompts, getPrompt, } from "../api/context-loader.js";
-import { addContextLoaderEntry, getCurrentContextLoaderKn, loadContextLoaderConfig, removeContextLoaderEntry, setCurrentContextLoader, } from "../config/store.js";
+import { callTool, searchSchema, queryObjectInstance, queryInstanceSubgraph, getLogicPropertiesValues, getActionInfo, findSkills, listTools, listResources, readResource, listResourceTemplates, listPrompts, getPrompt, } from "../api/context-loader.js";
+import { knSearchHttp, semanticSearch } from "../api/semantic-search.js";
+import { addContextLoaderEntry, getCurrentContextLoaderKn, loadContextLoaderConfig, removeContextLoaderEntry, resolveBusinessDomain, setCurrentContextLoader, } from "../config/store.js";
 const MCP_NOT_CONFIGURED = "Context-loader MCP is not configured. Run: kweaver context-loader config set --kn-id <kn-id>";
 function ensureContextLoaderConfig() {
     const active = resolveActivePlatform();
@@ -12,9 +13,11 @@ function ensureContextLoaderConfig() {
         throw new Error(MCP_NOT_CONFIGURED);
     }
     return {
+        baseUrl: active.url,
         mcpUrl: kn.mcpUrl,
         knId: kn.knId,
         accessToken: "", // filled by caller after ensureValidToken
+        businessDomain: resolveBusinessDomain(active.url),
     };
 }
 function formatOutput(value, pretty) {
@@ -38,16 +41,21 @@ Subcommands:
   templates                           resources/templates/list - list resource templates
   prompts                             prompts/list - list prompts
   prompt <name> [--args json]          prompts/get - get prompt by name
-  kn-search <query> [--only-schema]    Layer 1: Search schema (object_types, relation_types, action_types)
-  kn-schema-search <query> [--max N]   Layer 1: Discover candidate concepts
+  search-schema <query> [options]      MCP search_schema (object/relation/action/metric types)
+  tool-call <name> --args '<json>'     MCP tools/call for any server tool
+  kn-search <query> [--only-schema]    Compatibility: HTTP kn_search
+  kn-schema-search <query> [--max N]   Compatibility: HTTP semantic-search
   query-object-instance <json>         Layer 2: Query instances (args as JSON)
   query-instance-subgraph <json>       Layer 2: Query subgraph (args as JSON)
   get-logic-properties <json>          Layer 3: Get logic property values (args as JSON)
   get-action-info <json>               Layer 3: Get action info (args as JSON)
+  find-skills <ot_id> [options]        Layer 3: Recall skills for an object type
 
 Examples:
   kweaver context-loader config set --kn-id d5iv6c9818p72mpje8pg
   kweaver context-loader config set --kn-id xyz123 --name project-a
+  kweaver context-loader search-schema "利润率" --scope object,metric --max 5
+  kweaver context-loader tool-call search_schema --args '{"query":"利润率"}'
   kweaver context-loader kn-search "高血压 治疗 药品" --only-schema --pretty`);
         return 0;
     }
@@ -76,6 +84,10 @@ Examples:
             return runListPrompts(options, rest, pretty);
         if (subcommand === "prompt")
             return runGetPrompt(options, rest, pretty);
+        if (subcommand === "search-schema")
+            return runSearchSchema(options, rest, pretty);
+        if (subcommand === "tool-call")
+            return runToolCall(options, rest, pretty);
         if (subcommand === "kn-search")
             return runKnSearch(options, rest, pretty);
         if (subcommand === "kn-schema-search")
@@ -88,6 +100,8 @@ Examples:
             return runGetLogicProperties(options, rest, pretty);
         if (subcommand === "get-action-info")
             return runGetActionInfo(options, rest, pretty);
+        if (subcommand === "find-skills")
+            return runFindSkills(options, rest, pretty);
         return -1;
     };
     try {
@@ -279,6 +293,145 @@ async function runGetPrompt(options, args, pretty) {
     console.log(formatOutput(result, pretty));
     return 0;
 }
+function parseResponseText(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { raw: text };
+    }
+}
+function parseSearchSchemaScope(raw) {
+    const scope = {
+        include_object_types: false,
+        include_relation_types: false,
+        include_action_types: false,
+        include_metric_types: false,
+    };
+    const aliases = {
+        object: "include_object_types",
+        objects: "include_object_types",
+        object_type: "include_object_types",
+        object_types: "include_object_types",
+        relation: "include_relation_types",
+        relations: "include_relation_types",
+        relation_type: "include_relation_types",
+        relation_types: "include_relation_types",
+        action: "include_action_types",
+        actions: "include_action_types",
+        action_type: "include_action_types",
+        action_types: "include_action_types",
+        metric: "include_metric_types",
+        metrics: "include_metric_types",
+        metric_type: "include_metric_types",
+        metric_types: "include_metric_types",
+    };
+    for (const item of raw.split(",")) {
+        const key = item.trim().toLowerCase();
+        if (!key)
+            continue;
+        const field = aliases[key];
+        if (!field) {
+            throw new Error(`Invalid --scope value: ${item}`);
+        }
+        scope[field] = true;
+    }
+    return scope;
+}
+async function runSearchSchema(options, args, pretty) {
+    let query;
+    let responseFormat;
+    let searchScope;
+    let maxConcepts;
+    let schemaBrief;
+    let enableRerank;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if ((arg === "--format" || arg === "-f") && args[i + 1]) {
+            const value = args[i + 1];
+            if (value !== "json" && value !== "toon") {
+                console.error("Usage: kweaver context-loader search-schema <query> [--format json|toon] [--scope object,relation,action,metric] [--max N] [--brief] [--no-rerank]");
+                return 1;
+            }
+            responseFormat = value;
+            i += 1;
+        }
+        else if ((arg === "--scope" || arg === "-s") && args[i + 1]) {
+            try {
+                searchScope = parseSearchSchemaScope(args[i + 1]);
+            }
+            catch (error) {
+                console.error(error instanceof Error ? error.message : String(error));
+                return 1;
+            }
+            i += 1;
+        }
+        else if ((arg === "--max" || arg === "-n") && args[i + 1]) {
+            maxConcepts = parseInt(args[i + 1], 10);
+            if (!Number.isFinite(maxConcepts)) {
+                console.error("Usage: kweaver context-loader search-schema <query> [--max N]");
+                return 1;
+            }
+            i += 1;
+        }
+        else if (arg === "--brief") {
+            schemaBrief = true;
+        }
+        else if (arg === "--no-rerank") {
+            enableRerank = false;
+        }
+        else if (!arg.startsWith("-") && !query) {
+            query = arg;
+        }
+    }
+    if (!query) {
+        console.error("Usage: kweaver context-loader search-schema <query> [--format json|toon] [--scope object,relation,action,metric] [--max N] [--brief] [--no-rerank]");
+        return 1;
+    }
+    const result = await searchSchema(options, {
+        query,
+        response_format: responseFormat,
+        search_scope: searchScope,
+        max_concepts: maxConcepts,
+        schema_brief: schemaBrief,
+        enable_rerank: enableRerank,
+    });
+    console.log(formatOutput(result, pretty));
+    return 0;
+}
+async function runToolCall(options, args, pretty) {
+    let toolName;
+    let rawArgs;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if ((arg === "--args" || arg === "-a") && args[i + 1]) {
+            rawArgs = args[i + 1];
+            i += 1;
+        }
+        else if (!arg.startsWith("-") && !toolName) {
+            toolName = arg;
+        }
+    }
+    if (!toolName || rawArgs === undefined) {
+        console.error("Usage: kweaver context-loader tool-call <name> --args '<json>'");
+        return 1;
+    }
+    let parsedArgs;
+    try {
+        parsedArgs = JSON.parse(rawArgs);
+    }
+    catch {
+        console.error("Invalid --args JSON");
+        return 1;
+    }
+    if (parsedArgs === null || typeof parsedArgs !== "object" || Array.isArray(parsedArgs)) {
+        console.error("--args must be a JSON object");
+        return 1;
+    }
+    const result = await callTool(options, toolName, parsedArgs);
+    console.log(formatOutput(result, pretty));
+    return 0;
+}
 async function runKnSearch(options, args, pretty) {
     let query;
     let onlySchema = false;
@@ -300,8 +453,15 @@ async function runKnSearch(options, args, pretty) {
         console.error("Usage: kweaver context-loader kn-search <query> [--kn-id <id>] [--only-schema]");
         return 1;
     }
-    const effectiveOptions = knIdOverride ? { ...options, knId: knIdOverride } : options;
-    const result = await knSearch(effectiveOptions, { query, only_schema: onlySchema });
+    const raw = await knSearchHttp({
+        baseUrl: options.baseUrl,
+        accessToken: options.accessToken,
+        businessDomain: options.businessDomain,
+        knId: knIdOverride ?? options.knId,
+        query,
+        onlySchema,
+    });
+    const result = parseResponseText(raw);
     console.log(formatOutput(result, pretty));
     return 0;
 }
@@ -322,10 +482,15 @@ async function runKnSchemaSearch(options, args, pretty) {
         console.error("Usage: kweaver context-loader kn-schema-search <query> [--max N]");
         return 1;
     }
-    const result = await knSchemaSearch(options, {
+    const raw = await semanticSearch({
+        baseUrl: options.baseUrl,
+        accessToken: options.accessToken,
+        businessDomain: options.businessDomain,
+        knId: options.knId,
         query,
-        max_concepts: maxConcepts,
+        maxConcepts,
     });
+    const result = parseResponseText(raw);
     console.log(formatOutput(result, pretty));
     return 0;
 }
@@ -385,3 +550,66 @@ async function runGetActionInfo(options, args, pretty) {
     console.log(formatOutput(result, pretty));
     return 0;
 }
+async function runFindSkills(options, args, pretty) {
+    const usage = "Usage: kweaver context-loader find-skills <object_type_id> " +
+        "[--query <text>] [--top-k N] [--instance-identities <json>] [--format json|toon]";
+    let objectTypeId;
+    let skillQuery;
+    let topK;
+    let instanceIdentities;
+    let responseFormat;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if ((arg === "--query" || arg === "-q") && args[i + 1]) {
+            skillQuery = args[i + 1];
+            i += 1;
+        }
+        else if ((arg === "--top-k" || arg === "-n") && args[i + 1]) {
+            topK = parseInt(args[i + 1], 10);
+            if (!Number.isFinite(topK)) {
+                console.error(usage);
+                return 1;
+            }
+            i += 1;
+        }
+        else if ((arg === "--instance-identities" || arg === "-i") && args[i + 1]) {
+            try {
+                const parsed = JSON.parse(args[i + 1]);
+                if (!Array.isArray(parsed)) {
+                    throw new Error("--instance-identities must be a JSON array");
+                }
+                instanceIdentities = parsed;
+            }
+            catch (error) {
+                console.error(error instanceof Error ? error.message : String(error));
+                return 1;
+            }
+            i += 1;
+        }
+        else if ((arg === "--format" || arg === "-f") && args[i + 1]) {
+            const value = args[i + 1];
+            if (value !== "json" && value !== "toon") {
+                console.error(usage);
+                return 1;
+            }
+            responseFormat = value;
+            i += 1;
+        }
+        else if (!arg.startsWith("-") && !objectTypeId) {
+            objectTypeId = arg;
+        }
+    }
+    if (!objectTypeId) {
+        console.error(usage);
+        return 1;
+    }
+    const result = await findSkills(options, {
+        object_type_id: objectTypeId,
+        skill_query: skillQuery,
+        top_k: topK,
+        instance_identities: instanceIdentities,
+        response_format: responseFormat,
+    });
+    console.log(formatOutput(result, pretty));
+    return 0;
+}

package/dist/commands/toolbox.d.ts

@@ -1,3 +1,4 @@
+import { type ImpexType } from "../api/toolboxes.js";
 export declare function runToolboxCommand(args: string[]): Promise<number>;
 export interface ToolboxCreateOptions {
     name: string;
@@ -12,3 +13,17 @@ export interface ToolboxSetStatusOptions {
     businessDomain: string;
 }
 export declare function parseToolboxSetStatusArgs(args: string[]): ToolboxSetStatusOptions;
+export interface ToolboxExportOptions {
+    boxId: string;
+    output: string;
+    type: ImpexType;
+    businessDomain: string;
+}
+export declare function parseToolboxExportArgs(args: string[]): ToolboxExportOptions;
+export interface ToolboxImportOptions {
+    filePath: string;
+    type: ImpexType;
+    businessDomain: string;
+    pretty: boolean;
+}
+export declare function parseToolboxImportArgs(args: string[]): ToolboxImportOptions;

package/dist/commands/toolbox.js

@@ -1,8 +1,10 @@
+import { writeFile } from "node:fs/promises";
 import { createInterface } from "node:readline";
 import { ensureValidToken, formatHttpError, with401RefreshRetry } from "../auth/oauth.js";
-import { createToolbox, deleteToolbox, listToolboxes, setToolboxStatus } from "../api/toolboxes.js";
+import { createToolbox, deleteToolbox, exportConfig, importConfig, listToolboxes, setToolboxStatus, } from "../api/toolboxes.js";
 import { formatCallOutput } from "./call.js";
 import { resolveBusinessDomain } from "../config/store.js";
+const VALID_IMPEX_TYPES = new Set(["toolbox", "mcp", "operator"]);
 const HELP = `kweaver toolbox
 
 Subcommands:
@@ -11,6 +13,8 @@ Subcommands:
   publish <box-id>                                            Publish a toolbox (status=published)
   unpublish <box-id>                                          Unpublish (status=draft)
   delete <box-id> [-y|--yes]                                  Delete a toolbox
+  export <box-id> [-o <file>|-] [--type toolbox|mcp|operator] Export toolbox config (.adp JSON)
+  import <file> [--type toolbox|mcp|operator]                 Import a previously exported config
 
 Options:
   -bd, --biz-domain <s>   Business domain (default: bd_public)
@@ -33,6 +37,10 @@ export async function runToolboxCommand(args) {
             return runToolboxSetStatus(rest, "draft");
         if (subcommand === "delete")
             return runToolboxDelete(rest);
+        if (subcommand === "export")
+            return runToolboxExport(rest);
+        if (subcommand === "import")
+            return runToolboxImport(rest);
         return Promise.resolve(-1);
     };
     try {
@@ -254,3 +262,125 @@ async function runToolboxDelete(args) {
     console.error(`Deleted toolbox ${boxId}`);
     return 0;
 }
+export function parseToolboxExportArgs(args) {
+    let boxId = "";
+    let output = "";
+    let type = "toolbox";
+    let businessDomain = "";
+    for (let i = 0; i < args.length; i += 1) {
+        const a = args[i];
+        if ((a === "-o" || a === "--output") && args[i + 1] !== undefined) {
+            output = args[++i];
+            continue;
+        }
+        if (a === "--type" && args[i + 1]) {
+            const v = args[++i];
+            if (!VALID_IMPEX_TYPES.has(v)) {
+                throw new Error(`--type must be one of: ${[...VALID_IMPEX_TYPES].join(", ")}`);
+            }
+            type = v;
+            continue;
+        }
+        if ((a === "-bd" || a === "--biz-domain") && args[i + 1]) {
+            businessDomain = args[++i];
+            continue;
+        }
+        if (!a.startsWith("-")) {
+            boxId = a;
+            continue;
+        }
+    }
+    if (!boxId)
+        throw new Error("Missing required argument: <box-id>");
+    if (!businessDomain)
+        businessDomain = resolveBusinessDomain();
+    return { boxId, output, type, businessDomain };
+}
+async function runToolboxExport(args) {
+    let opts;
+    try {
+        opts = parseToolboxExportArgs(args);
+    }
+    catch (e) {
+        console.error(e instanceof Error ? e.message : String(e));
+        console.error("Usage: kweaver toolbox export <box-id> [-o <file>|-] [--type toolbox|mcp|operator]");
+        return 1;
+    }
+    const token = await ensureValidToken();
+    const buf = await exportConfig({
+        baseUrl: token.baseUrl,
+        accessToken: token.accessToken,
+        businessDomain: opts.businessDomain,
+        id: opts.boxId,
+        type: opts.type,
+    });
+    if (opts.output === "-") {
+        process.stdout.write(buf);
+        if (buf.length === 0 || buf[buf.length - 1] !== 0x0a)
+            process.stdout.write("\n");
+        return 0;
+    }
+    const target = opts.output || `${opts.type}_${opts.boxId}.adp`;
+    await writeFile(target, buf);
+    console.error(`Exported ${opts.type} ${opts.boxId} → ${target} (${buf.byteLength} bytes)`);
+    return 0;
+}
+export function parseToolboxImportArgs(args) {
+    let filePath = "";
+    let type = "toolbox";
+    let businessDomain = "";
+    let pretty = true;
+    for (let i = 0; i < args.length; i += 1) {
+        const a = args[i];
+        if (a === "--type" && args[i + 1]) {
+            const v = args[++i];
+            if (!VALID_IMPEX_TYPES.has(v)) {
+                throw new Error(`--type must be one of: ${[...VALID_IMPEX_TYPES].join(", ")}`);
+            }
+            type = v;
+            continue;
+        }
+        if ((a === "-bd" || a === "--biz-domain") && args[i + 1]) {
+            businessDomain = args[++i];
+            continue;
+        }
+        if (a === "--pretty") {
+            pretty = true;
+            continue;
+        }
+        if (a === "--compact") {
+            pretty = false;
+            continue;
+        }
+        if (!a.startsWith("-")) {
+            filePath = a;
+            continue;
+        }
+    }
+    if (!filePath)
+        throw new Error("Missing required argument: <file>");
+    if (!businessDomain)
+        businessDomain = resolveBusinessDomain();
+    return { filePath, type, businessDomain, pretty };
+}
+async function runToolboxImport(args) {
+    let opts;
+    try {
+        opts = parseToolboxImportArgs(args);
+    }
+    catch (e) {
+        console.error(e instanceof Error ? e.message : String(e));
+        console.error("Usage: kweaver toolbox import <file> [--type toolbox|mcp|operator]");
+        return 1;
+    }
+    const token = await ensureValidToken();
+    const body = await importConfig({
+        baseUrl: token.baseUrl,
+        accessToken: token.accessToken,
+        businessDomain: opts.businessDomain,
+        filePath: opts.filePath,
+        type: opts.type,
+    });
+    console.log(formatCallOutput(body, opts.pretty));
+    return 0;
+}

package/dist/config/store.js

@@ -783,8 +783,13 @@ export async function autoSelectBusinessDomain(baseUrl, accessToken, options) {
         return selected;
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.warn(`Could not fetch business domains: ${message}. Using bd_public.`);
+        // Endpoint may be unavailable on this deployment or for this account
+        // type — fall back silently. Set KWEAVER_DEBUG=1 to surface the
+        // underlying error during diagnostics.
+        if (process.env.KWEAVER_DEBUG) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`Business domain list unavailable (${message}); defaulting to bd_public.`);
+        }
         return "bd_public";
     }
 }

package/dist/index.d.ts

@@ -35,10 +35,10 @@ export type { ListAgentsOptions, GetAgentOptions, GetAgentByKeyOptions, CreateAg
 export { listAgents, getAgent, getAgentByKey, createAgent, updateAgent, deleteAgent, publishAgent, unpublishAgent, } 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 { SemanticSearchOptions, KnSearchHttpOptions } from "./api/semantic-search.js";
+export { semanticSearch, knSearchHttp } from "./api/semantic-search.js";
+export type { ContextLoaderCallOptions, SearchSchemaArgs, SearchSchemaScope, SearchSchemaResult, ConditionSpec, QueryObjectInstanceArgs, RelationTypePath, QueryInstanceSubgraphArgs, GetLogicPropertiesValuesArgs, GetActionInfoArgs, FindSkillsArgs, FindSkillsResult, MissingInputParamsError, } from "./api/context-loader.js";
+export { callTool, searchSchema, queryObjectInstance, queryInstanceSubgraph, getLogicPropertiesValues, getActionInfo, findSkills, 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";

package/dist/index.js

@@ -30,8 +30,8 @@ export { objectTypeQuery, objectTypeProperties, subgraph, actionTypeQuery, actio
 export { sendChatRequest, sendChatRequestStream, fetchAgentInfo, buildChatUrl, buildAgentInfoUrl, extractText, } from "./api/agent-chat.js";
 export { listAgents, getAgent, getAgentByKey, createAgent, updateAgent, deleteAgent, publishAgent, unpublishAgent, } 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 { semanticSearch, knSearchHttp } from "./api/semantic-search.js";
+export { callTool, searchSchema, queryObjectInstance, queryInstanceSubgraph, getLogicPropertiesValues, getActionInfo, findSkills, 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";

package/dist/resources/bkn.d.ts

@@ -48,7 +48,7 @@ export declare class BknResource {
     cancelActionLog(knId: string, logId: string): Promise<unknown>;
     /**
      * Search KN schema — finds matching object types, relation types, and action types.
-     * Uses MCP protocol via the context-loader (public endpoint).
+     * Uses the public agent-retrieval HTTP compatibility endpoint.
      */
     knSearch(knId: string, query: string, opts?: {
         onlySchema?: boolean;
@@ -56,6 +56,7 @@ export declare class BknResource {
         object_types?: unknown[];
         relation_types?: unknown[];
         action_types?: unknown[];
+        metric_types?: unknown[];
         nodes?: unknown[];
     }>;
 }

package/dist/resources/bkn.js

@@ -1,4 +1,5 @@
 import { buildHeaders } from "../api/headers.js";
+import { knSearchHttp } from "../api/semantic-search.js";
 import { objectTypeQuery, objectTypeProperties, subgraph, actionTypeQuery, actionTypeExecute, actionExecutionGet, actionLogsList, actionLogGet, actionLogCancel, } from "../api/ontology-query.js";
 import { fetchTextOrThrow } from "../utils/http.js";
 /** BKN engine resource — instance queries, subgraph, action execution and logs. */
@@ -88,14 +89,25 @@ export class BknResource {
     }
     /**
      * Search KN schema — finds matching object types, relation types, and action types.
-     * Uses MCP protocol via the context-loader (public endpoint).
+     * Uses the public agent-retrieval HTTP compatibility endpoint.
      */
     async knSearch(knId, query, opts = {}) {
-        const { ContextLoaderResource } = await import("./context-loader.js");
-        const { baseUrl } = this.ctx.base();
-        const mcpUrl = `${baseUrl}/api/agent-retrieval/v1/mcp`;
-        const cl = new ContextLoaderResource(this.ctx, mcpUrl, knId);
-        const result = await cl.search({ query, only_schema: opts.onlySchema ?? false });
-        return result;
+        const raw = await knSearchHttp({
+            ...this.ctx.base(),
+            knId,
+            query,
+            onlySchema: opts.onlySchema ?? false,
+        });
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            throw new Error(`kn_search returned non-JSON body (first 200 chars): ${raw.slice(0, 200)}`);
+        }
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new Error(`kn_search returned unexpected JSON shape (first 200 chars): ${raw.slice(0, 200)}`);
+        }
+        return parsed;
     }
 }

package/dist/resources/context-loader.d.ts

@@ -1,4 +1,4 @@
-import type { KnSearchArgs, KnSchemaSearchArgs, QueryObjectInstanceArgs, QueryInstanceSubgraphArgs, GetLogicPropertiesValuesArgs, GetActionInfoArgs } from "../api/context-loader.js";
+import type { SearchSchemaArgs, QueryObjectInstanceArgs, QueryInstanceSubgraphArgs, GetLogicPropertiesValuesArgs, GetActionInfoArgs, FindSkillsArgs, FindSkillsResult } from "../api/context-loader.js";
 import type { ClientContext } from "../client.js";
 export declare class ContextLoaderResource {
     private readonly ctx;
@@ -6,10 +6,11 @@ export declare class ContextLoaderResource {
     private readonly knId;
     constructor(ctx: ClientContext, mcpUrl: string, knId: string);
     private opts;
-    search(args: KnSearchArgs): Promise<unknown>;
-    schemaSearch(args: KnSchemaSearchArgs): Promise<unknown>;
+    callTool(toolName: string, args: Record<string, unknown>): Promise<unknown>;
+    searchSchema(args: SearchSchemaArgs): Promise<unknown>;
     queryInstances(args: QueryObjectInstanceArgs): Promise<unknown>;
     querySubgraph(args: QueryInstanceSubgraphArgs): Promise<unknown>;
     getLogicProperties(args: GetLogicPropertiesValuesArgs): Promise<unknown>;
     getActionInfo(args: GetActionInfoArgs): Promise<unknown>;
+    findSkills(args: FindSkillsArgs): Promise<FindSkillsResult>;
 }

package/dist/resources/context-loader.js

@@ -1,4 +1,4 @@
-import { knSearch, knSchemaSearch, queryObjectInstance, queryInstanceSubgraph, getLogicPropertiesValues, getActionInfo, } from "../api/context-loader.js";
+import { callTool, searchSchema, queryObjectInstance, queryInstanceSubgraph, getLogicPropertiesValues, getActionInfo, findSkills, } from "../api/context-loader.js";
 export class ContextLoaderResource {
     ctx;
     mcpUrl;
@@ -11,11 +11,11 @@ export class ContextLoaderResource {
     opts() {
         return { mcpUrl: this.mcpUrl, knId: this.knId, accessToken: this.ctx.base().accessToken };
     }
-    async search(args) {
-        return knSearch(this.opts(), args);
+    async callTool(toolName, args) {
+        return callTool(this.opts(), toolName, args);
     }
-    async schemaSearch(args) {
-        return knSchemaSearch(this.opts(), args);
+    async searchSchema(args) {
+        return searchSchema(this.opts(), args);
     }
     async queryInstances(args) {
         return queryObjectInstance(this.opts(), args);
@@ -29,4 +29,7 @@ export class ContextLoaderResource {
     async getActionInfo(args) {
         return getActionInfo(this.opts(), args);
     }
+    async findSkills(args) {
+        return findSkills(this.opts(), args);
+    }
 }

package/dist/resources/toolboxes.d.ts

@@ -1,4 +1,5 @@
 import type { ClientContext } from "../client.js";
+import { type ImpexType } from "../api/toolboxes.js";
 export interface InvokeToolArgs {
     /** Optional headers to forward to the downstream tool. Authorization is
      *  auto-injected from the client's access token when omitted; pass `{}` to
@@ -35,5 +36,19 @@ export declare class ToolboxesResource {
     execute(boxId: string, toolId: string, args?: InvokeToolArgs): Promise<string>;
     /** Debug a tool through the toolbox proxy (works on draft/disabled tools too). */
     debug(boxId: string, toolId: string, args?: InvokeToolArgs): Promise<string>;
+    /**
+     * Export a toolbox/mcp/operator config (.adp JSON) as raw bytes.
+     *
+     * Returned bytes are usually UTF-8 JSON; mirrors the Python SDK's
+     * `export_config -> bytes`. Use `new TextDecoder().decode(buf)` if you
+     * need a string.
+     */
+    exportConfig(id: string, opts?: {
+        type?: ImpexType;
+    }): Promise<Uint8Array>;
+    /** Import a previously exported config from disk. */
+    importConfig(filePath: string, opts?: {
+        type?: ImpexType;
+    }): Promise<string>;
     private injectAuth;
 }

package/dist/resources/toolboxes.js

@@ -1,4 +1,4 @@
-import { debugTool, executeTool, listTools, listToolboxes, setToolStatuses, uploadTool, } from "../api/toolboxes.js";
+import { debugTool, executeTool, exportConfig, importConfig, listTools, listToolboxes, setToolStatuses, uploadTool, } from "../api/toolboxes.js";
 /** Toolbox / tool management on the agent-operator-integration service. */
 export class ToolboxesResource {
     ctx;
@@ -40,6 +40,20 @@ export class ToolboxesResource {
             ...this.injectAuth(args),
         });
     }
+    /**
+     * Export a toolbox/mcp/operator config (.adp JSON) as raw bytes.
+     *
+     * Returned bytes are usually UTF-8 JSON; mirrors the Python SDK's
+     * `export_config -> bytes`. Use `new TextDecoder().decode(buf)` if you
+     * need a string.
+     */
+    async exportConfig(id, opts = {}) {
+        return exportConfig({ ...this.ctx.base(), id, type: opts.type });
+    }
+    /** Import a previously exported config from disk. */
+    async importConfig(filePath, opts = {}) {
+        return importConfig({ ...this.ctx.base(), filePath, type: opts.type });
+    }
     // The forwarder requires every header the downstream tool expects to be set
     // explicitly under `header`; most published tools declare an Authorization
     // parameter and would otherwise see no token. Auto-inject the active

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kweaver-ai/kweaver-sdk",
-  "version": "0.6.10",
+  "version": "0.7.1",
   "description": "KWeaver TypeScript SDK — CLI tool and programmatic API for knowledge networks and Decision Agents.",
   "type": "module",
   "main": "./dist/index.js",