@kweaver-ai/kweaver-sdk 0.6.10 → 0.7.2

package/dist/commands/ds.js

@@ -37,7 +37,10 @@ Subcommands:
   delete <id> [-y]                  Delete a datasource
   tables <id> [--keyword X]         List tables with columns
   connect <db_type> <host> <port> <database> --account X --password Y [--schema Z] [--name N]
+                                              [--reuse-existing|--force-new]
     Test connectivity, register datasource, and discover tables.
+    By default reuses an existing ds with the same (type, host, port, database, account)
+    instead of creating a duplicate. --force-new always creates a new entry.
   import-csv <ds-id> --files <glob_or_list> [--table-prefix X] [--batch-size N]
     Import CSV files into datasource tables via dataflow API.`);
         return 0;
@@ -206,6 +209,52 @@ async function runDsTablesCommand(args) {
     console.log(formatCallOutput(body, pretty));
     return 0;
 }
+export function findExistingDatasource(listBody, sig) {
+    const parsed = JSON.parse(listBody);
+    const entries = Array.isArray(parsed) ? parsed : (parsed.entries ?? []);
+    const tupleMatch = entries.find((e) => e.id &&
+        e.type === sig.type &&
+        e.bin_data?.host === sig.host &&
+        Number(e.bin_data?.port) === Number(sig.port) &&
+        e.bin_data?.database_name === sig.database &&
+        e.bin_data?.account === sig.account);
+    if (tupleMatch) {
+        return {
+            id: String(tupleMatch.id),
+            name: String(tupleMatch.name ?? ""),
+            matchedByName: tupleMatch.name === sig.name,
+            matchedByTuple: true,
+        };
+    }
+    if (sig.name) {
+        const nameMatch = entries.find((e) => e.id && e.name === sig.name);
+        if (nameMatch) {
+            return {
+                id: String(nameMatch.id),
+                name: String(nameMatch.name),
+                matchedByName: true,
+                matchedByTuple: false,
+            };
+        }
+    }
+    return undefined;
+}
+export function findDatasourceIdByName(listBody, name) {
+    const parsed = JSON.parse(listBody);
+    const entries = Array.isArray(parsed) ? parsed : (parsed.entries ?? []);
+    const hit = entries.find((e) => e.id && e.name === name);
+    return hit?.id ? String(hit.id) : undefined;
+}
+function isDuplicateNameError(err) {
+    if (!err || typeof err !== "object")
+        return false;
+    // HttpError.message is just "HTTP 400 ..."; the description lives in body.
+    const status = "status" in err ? Number(err.status) : NaN;
+    const body = "body" in err ? String(err.body) : "";
+    if (status !== 400)
+        return false;
+    return /数据源名称已存在|datasource name.*exist|already exists/i.test(body);
+}
 async function runDsConnectCommand(args) {
     let dbType = "";
     let host = "";
@@ -215,6 +264,7 @@ async function runDsConnectCommand(args) {
     let password = "";
     let schema;
     let name;
+    let forceNew = false;
     for (let i = 0; i < args.length; i += 1) {
         const arg = args[i];
         if (arg === "--account" && args[i + 1]) {
@@ -233,6 +283,14 @@ async function runDsConnectCommand(args) {
             name = args[++i];
             continue;
         }
+        if (arg === "--force-new") {
+            forceNew = true;
+            continue;
+        }
+        if (arg === "--reuse-existing") {
+            forceNew = false;
+            continue;
+        }
         if (!arg.startsWith("-")) {
             if (!dbType)
                 dbType = arg;
@@ -245,7 +303,7 @@ async function runDsConnectCommand(args) {
         }
     }
     if (!dbType || !host || !database || !account || !password) {
-        console.error("Usage: kweaver ds connect <db_type> <host> <port> <database> --account X --password Y [--schema Z] [--name N]");
+        console.error("Usage: kweaver ds connect <db_type> <host> <port> <database> --account X --password Y [--schema Z] [--name N] [--reuse-existing|--force-new]");
         return 1;
     }
     if (Number.isNaN(port) || port < 1) {
@@ -254,6 +312,28 @@ async function runDsConnectCommand(args) {
     }
     const token = await ensureValidToken();
     const base = { baseUrl: token.baseUrl, accessToken: token.accessToken };
+    const dsName = name ?? database;
+    // Pre-flight dedup: connection-tuple match is the silent-orphan vector.
+    // Backend already rejects duplicate names with 400, but won't notice
+    // tuple collisions, so we own that check.
+    if (!forceNew) {
+        const listBody = await listDatasources({ ...base });
+        const hit = findExistingDatasource(listBody, {
+            type: dbType,
+            host,
+            port,
+            database,
+            account,
+            name: dsName,
+        });
+        if (hit) {
+            const why = hit.matchedByTuple
+                ? "matched by (type,host,port,database,account)"
+                : "matched by --name";
+            console.error(`Reusing existing datasource ${hit.id} (${hit.name}); ${why}. Use --force-new to override.`);
+            return printDsConnectOutput(base, hit.id);
+        }
+    }
     console.error("Testing connectivity ...");
     await testDatasource({
         ...base,
@@ -265,27 +345,45 @@ async function runDsConnectCommand(args) {
         password,
         schema,
     });
-    const dsName = name ?? database;
-    const createBody = await createDatasource({
-        ...base,
-        name: dsName,
-        type: dbType,
-        host,
-        port,
-        database,
-        account,
-        password,
-        schema,
-    });
-    const dsId = extractDatasourceId(createBody);
+    let dsId = "";
+    try {
+        const createBody = await createDatasource({
+            ...base,
+            name: dsName,
+            type: dbType,
+            host,
+            port,
+            database,
+            account,
+            password,
+            schema,
+        });
+        dsId = extractDatasourceId(createBody);
+    }
+    catch (err) {
+        // Backend checks name uniqueness but not tuple. If we raced another caller
+        // (or tuple match got disabled by --force-new and the name still collides),
+        // turn the raw 400 into a useful pointer to the existing id.
+        if (isDuplicateNameError(err)) {
+            // Backend rejected the name; look it up specifically (not by tuple —
+            // sibling ds sharing the same connection would mislead the pointer).
+            const listBody = await listDatasources({ ...base });
+            const existingId = findDatasourceIdByName(listBody, dsName);
+            if (existingId) {
+                console.error(`Datasource name '${dsName}' already exists as ${existingId}. Re-run without --force-new to reuse it, or pick a different --name.`);
+                return 1;
+            }
+        }
+        throw err;
+    }
     if (!dsId) {
         console.error("Failed to get datasource ID from create response");
         return 1;
     }
-    const tablesBody = await listTablesWithColumns({
-        ...base,
-        id: dsId,
-    });
+    return printDsConnectOutput(base, dsId);
+}
+async function printDsConnectOutput(base, dsId) {
+    const tablesBody = await listTablesWithColumns({ ...base, id: dsId });
     const tables = JSON.parse(tablesBody);
     const output = {
         datasource_id: dsId,

package/dist/commands/skill.js

@@ -1,8 +1,9 @@
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { basename, dirname, resolve } from "node:path";
 import { ensureValidToken, formatHttpError, with401RefreshRetry } from "../auth/oauth.js";
 import { resolveBusinessDomain } from "../config/store.js";
-import { deleteSkill, downloadSkill, fetchSkillContent, fetchSkillFile, getSkill, getSkillContentIndex, installSkillArchive, listSkillMarket, listSkills, readSkillFile, registerSkillContent, registerSkillZip, updateSkillStatus, } from "../api/skills.js";
+import { deleteSkill, downloadSkill, fetchSkillContent, fetchSkillFile, getSkill, getSkillContentIndex, installSkillArchive, listSkillMarket, listSkills, readSkillFile, registerSkillZip, updateSkillStatus, } from "../api/skills.js";
+import { bundleSkillDirectoryToZip, bundleSkillFileToZip } from "../utils/skill-bundle.js";
 function printSkillHelp(subcommand) {
     if (subcommand === "list") {
         console.log(`kweaver skill list [--name kw] [--source src] [--status status] [--create-user user]
@@ -20,7 +21,15 @@ function printSkillHelp(subcommand) {
     }
     if (subcommand === "register") {
         console.log(`kweaver skill register (--content-file <path> | --zip-file <path>)
-                       [--source src] [--extend-info json] [-bd value] [--pretty|--compact]`);
+                       [--source src] [--extend-info json] [-bd value] [--pretty|--compact]
+
+  --content-file accepts either:
+    - a single file named SKILL.md (auto-bundled into a 1-file zip)
+    - a skill directory containing SKILL.md (bundled into a zip)
+  Both paths upload as multipart zip; the backend's file_type=content
+  registration is unreliable (publish-then-read returns 404) so the CLI
+  always goes through zip.
+  --zip-file accepts a pre-built .zip with SKILL.md at the archive root.`);
         return;
     }
     if (subcommand === "set-status" || subcommand === "status") {
@@ -54,6 +63,7 @@ Subcommands:
   market [--name kw] [--source src] [--page N] [--page-size N] [-bd value]
   get <skill-id> [-bd value]
   register --content-file <path> | --zip-file <path> [--source src] [--extend-info json]
+           (--content-file accepts a file named SKILL.md or a directory; both auto-zip)
   set-status <skill-id> <unpublish|published|offline> [-bd value]
   delete <skill-id> [-y] [-bd value]
   content <skill-id> [--raw] [--output file] [-bd value]
@@ -394,13 +404,23 @@ export async function runSkillCommand(args) {
             if (subcommand === "register") {
                 const opts = parseSkillRegisterArgs(rest);
                 if (opts.contentFile) {
-                    const content = readFileSync(resolve(opts.contentFile), "utf8");
-                    const result = await registerSkillContent({
+                    // Always bundle into zip — the backend's file_type=content path
+                    // doesn't write skill_file_index, so SKILL.md is unreachable
+                    // after publish via /skills/:id/content. Going through zip
+                    // (single SKILL.md or full directory) is the only path that
+                    // produces a readable skill end-to-end.
+                    const abs = resolve(opts.contentFile);
+                    const stat = statSync(abs);
+                    const bytes = stat.isDirectory()
+                        ? await bundleSkillDirectoryToZip(abs)
+                        : await bundleSkillFileToZip(abs);
+                    const result = await registerSkillZip({
                         ...token,
                         businessDomain: opts.businessDomain,
-                        content,
                         source: opts.source,
                         extendInfo: opts.extendInfo,
+                        filename: `${basename(abs).replace(/\.zip$/i, "")}.zip`,
+                        bytes,
                     });
                     console.log(format(result, opts.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/stateless.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Stateless token mode: user passed --token on the CLI for this invocation.
+ *
+ * In stateless mode the CLI must not mutate ~/.kweaver/ — we error out from
+ * any command that would write tokens, sessions, or per-platform config.
+ *
+ * KWEAVER_TOKEN env (without --token flag) is NOT considered stateless: the
+ * env-var path predates this feature and keeps its existing semantics for
+ * backward compatibility. The cli.ts argv parser sets KWEAVER_TOKEN_SOURCE=flag
+ * only when --token was passed explicitly.
+ */
+export declare function isStatelessTokenMode(): boolean;
+export declare function assertNotStatelessForWrite(commandName: string): void;

package/dist/config/stateless.js

@@ -0,0 +1,20 @@
+/**
+ * Stateless token mode: user passed --token on the CLI for this invocation.
+ *
+ * In stateless mode the CLI must not mutate ~/.kweaver/ — we error out from
+ * any command that would write tokens, sessions, or per-platform config.
+ *
+ * KWEAVER_TOKEN env (without --token flag) is NOT considered stateless: the
+ * env-var path predates this feature and keeps its existing semantics for
+ * backward compatibility. The cli.ts argv parser sets KWEAVER_TOKEN_SOURCE=flag
+ * only when --token was passed explicitly.
+ */
+export function isStatelessTokenMode() {
+    return process.env.KWEAVER_TOKEN_SOURCE === "flag";
+}
+export function assertNotStatelessForWrite(commandName) {
+    if (isStatelessTokenMode()) {
+        throw new Error(`Cannot run \`${commandName}\` with --token. The --token flag is for stateless invocations and ` +
+            `must not mutate ~/.kweaver/. Drop --token, or use \`kweaver auth login\` to obtain a saved session.`);
+    }
+}

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;
 }