@kweaver-ai/kweaver-sdk 0.6.9 → 0.7.1

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/bkn-schema.d.ts

@@ -95,6 +95,33 @@ export interface KnActionTypeExecuteOptions {
     timeout: number;
 }
 export declare function parseKnActionTypeExecuteArgs(args: string[]): KnActionTypeExecuteOptions;
+/**
+ * Assemble the action-type execute envelope from CLI flags. Each flag is
+ * parsed as JSON; instance entries must be JSON objects; dynamic_params must
+ * be a JSON object. The shape produced is the contract documented in
+ * skills/kweaver-core/references/bkn.md.
+ */
+export declare function buildExecuteEnvelope(opts: {
+    triggerType: string;
+    dynamicParamsJson?: string;
+    instanceJsons: string[];
+}): string;
+export interface InputParameterSummary {
+    name: string;
+    type?: string;
+    source?: string;
+    required?: boolean;
+    description?: string;
+}
+/**
+ * Walk a getActionType response and collect parameters where
+ * `value_from === "input"`. The exact response shape varies (sometimes the
+ * action-type is at the root, sometimes nested under data/result/...), so we
+ * search a few likely locations.
+ */
+export declare function extractInputParameters(rawJson: string): InputParameterSummary[];
+export declare function buildDynamicParamsTemplate(inputs: InputParameterSummary[]): Record<string, unknown>;
+export declare function renderInputsTable(atId: string, inputs: InputParameterSummary[]): string;
 /** Parse relation-type create args: --name --source --target [--mapping src:tgt ...] */
 export declare function parseRelationTypeCreateArgs(args: string[]): {
     knId: string;

package/dist/commands/bkn-schema.js

@@ -562,6 +562,9 @@ export function parseKnActionTypeExecuteArgs(args) {
     let businessDomain = "";
     let wait = true;
     let timeout = 300;
+    let dynamicParamsJson;
+    let triggerType;
+    const instanceJsons = [];
     const positional = [];
     for (let i = 0; i < args.length; i += 1) {
         const arg = args[i];
@@ -592,11 +595,41 @@ export function parseKnActionTypeExecuteArgs(args) {
             i += 1;
             continue;
         }
+        if (arg === "--dynamic-params" && args[i + 1]) {
+            dynamicParamsJson = args[++i];
+            continue;
+        }
+        if (arg === "--instance" && args[i + 1]) {
+            instanceJsons.push(args[++i]);
+            continue;
+        }
+        if (arg === "--trigger-type" && args[i + 1]) {
+            triggerType = args[++i];
+            continue;
+        }
         positional.push(arg);
     }
-    const [knId, atId, body] = positional;
-    if (!knId || !atId || !body) {
-        throw new Error("Missing kn-id, at-id, or body. Usage: kweaver bkn action-type execute <kn-id> <at-id> '<json>' [options]");
+    const usingFlags = dynamicParamsJson !== undefined || instanceJsons.length > 0 || triggerType !== undefined;
+    const [knId, atId, positionalBody] = positional;
+    if (!knId || !atId) {
+        throw new Error("Missing kn-id or at-id. Usage: kweaver bkn action-type execute <kn-id> <at-id> [<json>|--dynamic-params '<json>' --instance '<json>'] [options]");
+    }
+    if (positionalBody && usingFlags) {
+        throw new Error("Positional body and --dynamic-params/--instance/--trigger-type are mutually exclusive. Use one form.");
+    }
+    if (!positionalBody && !usingFlags) {
+        throw new Error("Missing body. Provide a positional JSON envelope, or use --dynamic-params / --instance / --trigger-type.");
+    }
+    let body;
+    if (positionalBody) {
+        body = positionalBody;
+    }
+    else {
+        body = buildExecuteEnvelope({
+            triggerType: triggerType ?? "manual",
+            dynamicParamsJson,
+            instanceJsons,
+        });
     }
     if (!businessDomain)
         businessDomain = resolveBusinessDomain();
@@ -610,6 +643,143 @@ export function parseKnActionTypeExecuteArgs(args) {
         timeout,
     };
 }
+/**
+ * Assemble the action-type execute envelope from CLI flags. Each flag is
+ * parsed as JSON; instance entries must be JSON objects; dynamic_params must
+ * be a JSON object. The shape produced is the contract documented in
+ * skills/kweaver-core/references/bkn.md.
+ */
+export function buildExecuteEnvelope(opts) {
+    const envelope = {
+        trigger_type: opts.triggerType,
+        _instance_identities: opts.instanceJsons.map((s, idx) => {
+            let parsed;
+            try {
+                parsed = JSON.parse(s);
+            }
+            catch (e) {
+                throw new Error(`--instance #${idx + 1} is not valid JSON: ${e.message}`);
+            }
+            if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+                throw new Error(`--instance #${idx + 1} must be a JSON object, got ${Array.isArray(parsed) ? "array" : typeof parsed}`);
+            }
+            return parsed;
+        }),
+    };
+    if (opts.dynamicParamsJson !== undefined) {
+        let parsed;
+        try {
+            parsed = JSON.parse(opts.dynamicParamsJson);
+        }
+        catch (e) {
+            throw new Error(`--dynamic-params is not valid JSON: ${e.message}`);
+        }
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new Error(`--dynamic-params must be a JSON object, got ${Array.isArray(parsed) ? "array" : typeof parsed}`);
+        }
+        envelope.dynamic_params = parsed;
+    }
+    else {
+        envelope.dynamic_params = {};
+    }
+    return JSON.stringify(envelope);
+}
+/**
+ * Walk a getActionType response and collect parameters where
+ * `value_from === "input"`. The exact response shape varies (sometimes the
+ * action-type is at the root, sometimes nested under data/result/...), so we
+ * search a few likely locations.
+ */
+export function extractInputParameters(rawJson) {
+    let root;
+    try {
+        root = JSON.parse(rawJson);
+    }
+    catch {
+        return [];
+    }
+    const candidates = collectParameterArrays(root);
+    const seen = new Set();
+    const out = [];
+    for (const params of candidates) {
+        for (const p of params) {
+            if (!p || typeof p !== "object")
+                continue;
+            const obj = p;
+            if (obj.value_from !== "input")
+                continue;
+            const name = typeof obj.name === "string" ? obj.name : "";
+            if (!name || seen.has(name))
+                continue;
+            seen.add(name);
+            out.push({
+                name,
+                type: typeof obj.type === "string" ? obj.type : undefined,
+                source: typeof obj.source === "string" ? obj.source : undefined,
+                required: typeof obj.required === "boolean" ? obj.required : undefined,
+                description: typeof obj.description === "string" ? obj.description : undefined,
+            });
+        }
+    }
+    return out;
+}
+function collectParameterArrays(node, acc = []) {
+    if (!node)
+        return acc;
+    if (Array.isArray(node)) {
+        for (const item of node)
+            collectParameterArrays(item, acc);
+        return acc;
+    }
+    if (typeof node !== "object")
+        return acc;
+    const obj = node;
+    if (Array.isArray(obj.parameters))
+        acc.push(obj.parameters);
+    for (const v of Object.values(obj))
+        collectParameterArrays(v, acc);
+    return acc;
+}
+export function buildDynamicParamsTemplate(inputs) {
+    const tpl = {};
+    for (const p of inputs) {
+        tpl[p.name] = placeholderForType(p);
+    }
+    return tpl;
+}
+function placeholderForType(p) {
+    const hint = p.description ? ` (${p.description})` : "";
+    const t = (p.type ?? "").toLowerCase();
+    if (t === "int" || t === "integer" || t === "long" || t === "number" || t === "float" || t === "double")
+        return 0;
+    if (t === "bool" || t === "boolean")
+        return false;
+    if (t === "array" || t === "list")
+        return [];
+    if (t === "object" || t === "dict" || t === "map")
+        return {};
+    return `<${p.type ?? "string"}${p.required === false ? "?" : ""}>${hint}`;
+}
+export function renderInputsTable(atId, inputs) {
+    if (inputs.length === 0) {
+        return `Action type ${atId} has no parameters with value_from=input. dynamic_params can be {}.`;
+    }
+    const rows = inputs.map(p => [
+        p.name,
+        p.type ?? "-",
+        p.source ?? "-",
+        p.required === undefined ? "-" : p.required ? "yes" : "no",
+        truncate(p.description ?? "", 60),
+    ]);
+    const header = ["NAME", "TYPE", "SOURCE", "REQUIRED", "DESCRIPTION"];
+    const widths = header.map((h, i) => Math.max(h.length, ...rows.map(r => r[i].length)));
+    const fmt = (cols) => cols.map((c, i) => c.padEnd(widths[i])).join("  ");
+    const lines = [fmt(header), fmt(widths.map(w => "-".repeat(w))), ...rows.map(fmt)];
+    return `Action type ${atId} input parameters (value_from=input):\n${lines.join("\n")}`;
+}
+function truncate(s, n) {
+    return s.length <= n ? s : s.slice(0, n - 1) + "…";
+}
 // ── Action-type execute helpers ────────────────────────────────────────────────
 const TERMINAL_STATUSES = ["SUCCESS", "FAILED", "CANCELLED"];
 function extractExecutionId(body) {
@@ -1123,17 +1293,30 @@ kweaver bkn action-type create <kn-id> '<json>' [--pretty] [-bd value]
 kweaver bkn action-type update <kn-id> <at-id> '<json>' [--pretty] [-bd value]
 kweaver bkn action-type delete <kn-id> <at-ids> [-y] [--pretty] [-bd value]
 kweaver bkn action-type query <kn-id> <at-id> '<json>' [--pretty] [-bd value]
-kweaver bkn action-type execute <kn-id> <at-id> '<json>' [--pretty] [-bd value] [--wait|--no-wait] [--timeout n]
+kweaver bkn action-type inputs <kn-id> <at-id> [--json|--template] [-bd value]
+kweaver bkn action-type execute <kn-id> <at-id> [<json>|--dynamic-params '<json>' --instance '<json>' --trigger-type <v>] [--pretty] [-bd value] [--wait|--no-wait] [--timeout n]
 
 list: List action types (schema) from ontology-manager.
 get: Get a single action type by ID.
 create: Create action type(s) (POST JSON body).
 update: Update an action type (PUT JSON body).
 delete: Delete action type(s) by ID(s).
-query/execute: Query or execute actions. execute has side effects - only use when explicitly requested.
+query: Query actions backing this action type.
+inputs: List parameters with value_from=input that the caller MUST supply.
+        Default prints a table + a starter dynamic_params template.
+        --json     dump filtered parameters as raw JSON
+        --template print only the dynamic_params template object
+execute: Run an action (has side effects - only use when explicitly requested).
+  Body forms (mutually exclusive):
+    1. Positional envelope JSON: '{"trigger_type":"manual","_instance_identities":[],"dynamic_params":{...}}'
+    2. Flag form (CLI assembles the envelope):
+         --dynamic-params '<json object>'   parameters with value_from=input
+         --instance '<json object>'         repeatable; one per identity
+         --trigger-type <value>             defaults to "manual"
   --wait (default)    Poll until execution completes
   --no-wait           Return immediately after starting execution
-  --timeout <seconds> Max wait time when --wait (default: 300)`);
+  --timeout <seconds> Max wait time when --wait (default: 300)
+See skills/kweaver-core/references/bkn.md for the full payload contract.`);
         return 0;
     }
     if (action === "list") {
@@ -1283,6 +1466,48 @@ query/execute: Query or execute actions. execute has side effects - only use whe
             return 1;
         }
     }
+    if (action === "inputs") {
+        const parsed = parseOntologyQueryFlags(rest);
+        const flags = new Set(parsed.filteredArgs.filter(a => a.startsWith("--")));
+        const positional = parsed.filteredArgs.filter(a => !a.startsWith("--"));
+        const [knId, atId] = positional;
+        if (!knId || !atId) {
+            console.error("Usage: kweaver bkn action-type inputs <kn-id> <at-id> [--json|--template]");
+            return 1;
+        }
+        if (flags.has("--json") && flags.has("--template")) {
+            console.error("--json and --template are mutually exclusive.");
+            return 1;
+        }
+        try {
+            const token = await ensureValidToken();
+            const raw = await getActionType({
+                baseUrl: token.baseUrl,
+                accessToken: token.accessToken,
+                knId,
+                atId,
+                businessDomain: parsed.businessDomain,
+            });
+            const inputs = extractInputParameters(raw);
+            if (flags.has("--json")) {
+                console.log(formatCallOutput(JSON.stringify(inputs), parsed.pretty));
+                return 0;
+            }
+            const template = buildDynamicParamsTemplate(inputs);
+            if (flags.has("--template")) {
+                console.log(JSON.stringify(template, null, 2));
+                return 0;
+            }
+            console.log(renderInputsTable(atId, inputs));
+            console.log("\n# Starter dynamic_params (fill in real values, then pass via --dynamic-params):");
+            console.log(JSON.stringify(template, null, 2));
+            return 0;
+        }
+        catch (error) {
+            console.error(formatHttpError(error));
+            return 1;
+        }
+    }
     if (action === "execute") {
         let options;
         try {
@@ -1349,7 +1574,7 @@ query/execute: Query or execute actions. execute has side effects - only use whe
             return 1;
         }
     }
-    console.error(`Unknown action-type action: ${action}. Use list, get, create, update, delete, query, or execute.`);
+    console.error(`Unknown action-type action: ${action}. Use list, get, create, update, delete, query, inputs, or execute.`);
     return 1;
 }
 export function parseConceptGroupArgs(args) {

package/dist/commands/bkn.js

@@ -393,7 +393,8 @@ Subcommands:
   action-type update <kn-id> <at-id> '<json>'   Update action type
   action-type delete <kn-id> <at-ids> [-y]   Delete action type(s)
   action-type query <kn-id> <at-id> '<json>'   Query action info
-  action-type execute <kn-id> <at-id> '<json>'   Execute action (has side effects)
+  action-type inputs <kn-id> <at-id>   List value_from=input params + dynamic_params template
+  action-type execute <kn-id> <at-id> '<envelope-json>' | --dynamic-params '<json>' [--instance '<json>']... [--trigger-type <v>]   Execute action (has side effects)
   action-execution get <kn-id> <execution-id>   Get execution status
   action-log list <kn-id> [options]   List action execution logs
   action-log get <kn-id> <log-id>   Get single execution log

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/tool.d.ts

@@ -14,3 +14,15 @@ export interface ToolStatusOptions {
     businessDomain: string;
 }
 export declare function parseToolStatusArgs(args: string[], status: "enabled" | "disabled"): ToolStatusOptions;
+export interface ToolInvokeOptions {
+    boxId: string;
+    toolId: string;
+    header?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    body?: unknown;
+    bodyFile?: string;
+    timeout?: number;
+    businessDomain: string;
+    pretty: boolean;
+}
+export declare function parseToolInvokeArgs(args: string[]): ToolInvokeOptions;