@kweaver-ai/kweaver-sdk 0.6.9 → 0.7.1

package/dist/commands/tool.js

@@ -1,18 +1,29 @@
-import { access } from "node:fs/promises";
+import { access, readFile } from "node:fs/promises";
 import { ensureValidToken, formatHttpError, with401RefreshRetry } from "../auth/oauth.js";
-import { listTools, setToolStatuses, uploadTool } from "../api/toolboxes.js";
+import { debugTool, executeTool, listTools, setToolStatuses, uploadTool } from "../api/toolboxes.js";
 import { formatCallOutput } from "./call.js";
 import { resolveBusinessDomain } from "../config/store.js";
 const HELP = `kweaver tool
 
 Subcommands:
   upload --toolbox <box-id> <openapi-spec-path> [--metadata-type openapi]
-                                          Upload an OpenAPI spec file as a tool
-  list --toolbox <box-id>                  List tools in a toolbox
-  enable --toolbox <box-id> <tool-id>...   Enable one or more tools
-  disable --toolbox <box-id> <tool-id>...  Disable one or more tools
+                                              Upload an OpenAPI spec file as a tool
+  list --toolbox <box-id>                      List tools in a toolbox
+  enable --toolbox <box-id> <tool-id>...       Enable one or more tools
+  disable --toolbox <box-id> <tool-id>...      Disable one or more tools
+  execute --toolbox <box-id> <tool-id> [--body '<json>'|--body-file <path>]
+                                              Invoke a published+enabled tool
+  debug   --toolbox <box-id> <tool-id> [--body '<json>'|--body-file <path>]
+                                              Invoke a tool (works on draft/disabled too)
 
-Options:
+Options for execute/debug:
+  --header '<json>'       Headers map forwarded to the downstream tool
+                          (Authorization is auto-injected from current session
+                          when --header omits it; pass {} to send none)
+  --query  '<json>'       Query params map forwarded to the downstream tool
+  --timeout <seconds>     Per-call timeout (backend default applies when omitted)
+
+Common options:
   -bd, --biz-domain <s>   Business domain (default: bd_public)
   --pretty                Pretty-print JSON (default)
   --compact               Single-line JSON (pipeline-friendly)`;
@@ -31,6 +42,10 @@ export async function runToolCommand(args) {
             return runToolStatus(rest, "enabled");
         if (subcommand === "disable")
             return runToolStatus(rest, "disabled");
+        if (subcommand === "execute")
+            return runToolInvoke(rest, "execute");
+        if (subcommand === "debug")
+            return runToolInvoke(rest, "debug");
         return Promise.resolve(-1);
     };
     try {
@@ -206,3 +221,158 @@ async function runToolStatus(args, status) {
     console.error(`${status === "enabled" ? "Enabled" : "Disabled"} ${opts.toolIds.length} tool(s) in toolbox ${opts.boxId}`);
     return 0;
 }
+function parseJsonOption(name, raw) {
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch (e) {
+        throw new Error(`${name} must be valid JSON: ${e.message}`);
+    }
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${name} must be a JSON object`);
+    }
+    return value;
+}
+export function parseToolInvokeArgs(args) {
+    let boxId = "";
+    let toolId = "";
+    let businessDomain = "";
+    let pretty = true;
+    let header;
+    let query;
+    let body;
+    let bodyProvided = false;
+    let bodyFile;
+    let timeout;
+    for (let i = 0; i < args.length; i += 1) {
+        const a = args[i];
+        if (a === "--toolbox" && args[i + 1]) {
+            boxId = args[++i];
+            continue;
+        }
+        if (a === "--header" && args[i + 1]) {
+            header = parseJsonOption("--header", args[++i]);
+            continue;
+        }
+        if (a === "--query" && args[i + 1]) {
+            query = parseJsonOption("--query", args[++i]);
+            continue;
+        }
+        if (a === "--body" && args[i + 1]) {
+            const raw = args[++i];
+            try {
+                body = JSON.parse(raw);
+            }
+            catch (e) {
+                throw new Error(`--body must be valid JSON: ${e.message}`);
+            }
+            bodyProvided = true;
+            continue;
+        }
+        if (a === "--body-file" && args[i + 1]) {
+            bodyFile = args[++i];
+            bodyProvided = true;
+            continue;
+        }
+        if (a === "--timeout" && args[i + 1]) {
+            const t = Number(args[++i]);
+            if (!Number.isFinite(t) || t <= 0)
+                throw new Error("--timeout must be a positive number");
+            timeout = t;
+            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("-") && !toolId) {
+            toolId = a;
+            continue;
+        }
+    }
+    if (!boxId)
+        throw new Error("Missing required flag: --toolbox");
+    if (!toolId)
+        throw new Error("Missing required positional argument: <tool-id>");
+    if (bodyFile && body !== undefined)
+        throw new Error("--body and --body-file are mutually exclusive");
+    if (!businessDomain)
+        businessDomain = resolveBusinessDomain();
+    return {
+        boxId,
+        toolId,
+        header,
+        query,
+        body: bodyProvided ? body : undefined,
+        bodyFile,
+        timeout,
+        businessDomain,
+        pretty,
+    };
+}
+async function loadBodyFile(path) {
+    let raw;
+    try {
+        raw = await readFile(path, "utf8");
+    }
+    catch (e) {
+        throw new Error(`Cannot read --body-file ${path}: ${e.message}`);
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch (e) {
+        throw new Error(`--body-file ${path} is not valid JSON: ${e.message}`);
+    }
+}
+async function runToolInvoke(args, action) {
+    let opts;
+    try {
+        opts = parseToolInvokeArgs(args);
+    }
+    catch (e) {
+        console.error(e instanceof Error ? e.message : String(e));
+        return 1;
+    }
+    let body = opts.body;
+    if (opts.bodyFile !== undefined) {
+        try {
+            body = await loadBodyFile(opts.bodyFile);
+        }
+        catch (e) {
+            console.error(e instanceof Error ? e.message : String(e));
+            return 1;
+        }
+    }
+    const token = await ensureValidToken();
+    // Auto-inject Authorization unless caller already provided one — most tools
+    // declare an `Authorization` header parameter and would otherwise be called
+    // anonymously, which the downstream tool answers with 401 token expired.
+    const header = { ...(opts.header ?? {}) };
+    const hasAuth = Object.keys(header).some((k) => k.toLowerCase() === "authorization");
+    if (!hasAuth)
+        header.Authorization = `Bearer ${token.accessToken}`;
+    const fn = action === "execute" ? executeTool : debugTool;
+    const responseBody = await fn({
+        baseUrl: token.baseUrl,
+        accessToken: token.accessToken,
+        businessDomain: opts.businessDomain,
+        boxId: opts.boxId,
+        toolId: opts.toolId,
+        header,
+        query: opts.query,
+        body,
+        timeout: opts.timeout,
+    });
+    console.log(formatCallOutput(responseBody, 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/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";
@@ -50,6 +50,8 @@ export { BknResource } from "./resources/bkn.js";
 export { ConversationsResource } from "./resources/conversations.js";
 export { ContextLoaderResource } from "./resources/context-loader.js";
 export { SkillsResource } from "./resources/skills.js";
+export { ToolboxesResource } from "./resources/toolboxes.js";
+export type { InvokeToolArgs } from "./resources/toolboxes.js";
 export type { SkillStatus, SkillSummary, SkillInfo, SkillFileSummary, SkillContentIndex, SkillFileReadResult, RegisterSkillResult, DeleteSkillResult, UpdateSkillStatusResult, SkillListResult, ListSkillsOptions, ListSkillMarketOptions, GetSkillOptions, RegisterSkillContentOptions, RegisterSkillZipOptions, UpdateSkillStatusOptions, ReadSkillFileOptions, DownloadSkillOptions, DownloadedSkillArchive, } from "./api/skills.js";
 export { listSkills, listSkillMarket, getSkill, deleteSkill, updateSkillStatus, registerSkillContent, registerSkillZip, getSkillContentIndex, fetchSkillContent, readSkillFile, fetchSkillFile, downloadSkill, installSkillArchive, } from "./api/skills.js";
 export type { ViewField, DataView, CreateDataViewOptions, GetDataViewOptions, ListDataViewsOptions, DeleteDataViewOptions, FindDataViewOptions, QueryDataViewOptions, DataViewQueryResult, } from "./api/dataviews.js";
@@ -57,6 +59,8 @@ export { parseDataView, createDataView, getDataView, listDataViews, deleteDataVi
 export { DataViewsResource } from "./resources/dataviews.js";
 export type { BusinessDomain, ListBusinessDomainsOptions } from "./api/business-domains.js";
 export { listBusinessDomains } from "./api/business-domains.js";
+export type { CreateToolboxOptions, DeleteToolboxOptions, SetToolboxStatusOptions, UploadToolOptions, SetToolStatusesOptions, ListToolboxesOptions, ListToolsOptions, InvokeToolOptions, } from "./api/toolboxes.js";
+export { createToolbox, deleteToolbox, setToolboxStatus, uploadTool, setToolStatuses, listToolboxes, listTools, executeTool, debugTool, } from "./api/toolboxes.js";
 export { HttpError, NetworkRequestError, fetchTextOrThrow } from "./utils/http.js";
 export type { TokenConfig, ContextLoaderEntry, ContextLoaderConfig, } from "./config/store.js";
 export type { UserProfile } from "./config/store.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";
@@ -40,10 +40,12 @@ export { BknResource } from "./resources/bkn.js";
 export { ConversationsResource } from "./resources/conversations.js";
 export { ContextLoaderResource } from "./resources/context-loader.js";
 export { SkillsResource } from "./resources/skills.js";
+export { ToolboxesResource } from "./resources/toolboxes.js";
 export { listSkills, listSkillMarket, getSkill, deleteSkill, updateSkillStatus, registerSkillContent, registerSkillZip, getSkillContentIndex, fetchSkillContent, readSkillFile, fetchSkillFile, downloadSkill, installSkillArchive, } from "./api/skills.js";
 export { parseDataView, createDataView, getDataView, listDataViews, deleteDataView, findDataView, queryDataView, } from "./api/dataviews.js";
 export { DataViewsResource } from "./resources/dataviews.js";
 export { listBusinessDomains } from "./api/business-domains.js";
+export { createToolbox, deleteToolbox, setToolboxStatus, uploadTool, setToolStatuses, listToolboxes, listTools, executeTool, debugTool, } from "./api/toolboxes.js";
 // ── HTTP utilities ────────────────────────────────────────────────────────────
 export { HttpError, NetworkRequestError, fetchTextOrThrow } from "./utils/http.js";
 export { NO_AUTH_TOKEN, isNoAuth, saveNoAuthPlatform, autoSelectBusinessDomain, getConfigDir, getCurrentPlatform, getActiveUser, setActiveUser, listUsers, listUserProfiles, resolveUserId, extractUserId, } from "./config/store.js";

package/dist/resources/agents.js

@@ -11,11 +11,25 @@ export class AgentsResource {
         const { keyword, ...rest } = opts;
         const raw = await listAgents({ ...this.ctx.base(), name: keyword, ...rest });
         const parsed = JSON.parse(raw);
-        const items = parsed && typeof parsed === "object" && "data" in parsed
-            ? parsed.data?.records ?? []
-            : Array.isArray(parsed)
-                ? parsed
-                : [];
+        const items = (() => {
+            if (Array.isArray(parsed))
+                return parsed;
+            if (!parsed || typeof parsed !== "object")
+                return [];
+            const obj = parsed;
+            if (Array.isArray(obj.entries))
+                return obj.entries;
+            if (Array.isArray(obj.data))
+                return obj.data;
+            if (obj.data && typeof obj.data === "object") {
+                const dataObj = obj.data;
+                if (Array.isArray(dataObj.records))
+                    return dataObj.records;
+                if (Array.isArray(dataObj.entries))
+                    return dataObj.entries;
+            }
+            return [];
+        })();
         return items;
     }
     // ── Get by ID ────────────────────────────────────────────────────────────

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

@@ -0,0 +1,54 @@
+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
+     *  send no headers. */
+    header?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    body?: unknown;
+    /** Per-call timeout in seconds (backend default applies when omitted). */
+    timeout?: number;
+}
+/** Toolbox / tool management on the agent-operator-integration service. */
+export declare class ToolboxesResource {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    list(opts?: {
+        keyword?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<string>;
+    listToolsIn(boxId: string): Promise<string>;
+    uploadTool(opts: {
+        boxId: string;
+        filePath: string;
+        metadataType?: "openapi";
+    }): Promise<string>;
+    setToolStatuses(opts: {
+        boxId: string;
+        updates: Array<{
+            toolId: string;
+            status: "enabled" | "disabled";
+        }>;
+    }): Promise<void>;
+    /** Execute a published+enabled tool through the toolbox proxy. */
+    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;
+}