@kweaver-ai/kweaver-sdk 0.7.3 → 0.8.1

package/dist/api/models.js

@@ -0,0 +1,183 @@
+import { buildHeaders } from "./headers.js";
+import { HttpError } from "../utils/http.js";
+export const MF_MODEL_MANAGER_PATH_PREFIX = "/api/mf-model-manager/v1";
+function resolveManagerOrigin(options) {
+    const env = process.env.KWEAVER_MF_MODEL_MANAGER_URL;
+    const raw = options.mfManagerBaseUrl ?? (env && env.length > 0 ? env : undefined) ?? options.baseUrl;
+    return raw.replace(/\/+$/, "");
+}
+function managerEndpoint(options, relPath) {
+    const origin = resolveManagerOrigin(options);
+    const path = relPath.startsWith("/") ? relPath : `/${relPath}`;
+    return `${origin}${MF_MODEL_MANAGER_PATH_PREFIX}${path}`;
+}
+async function fetchJson(url, accessToken, businessDomain, init) {
+    const headers = {
+        ...buildHeaders(accessToken, businessDomain),
+        ...(init.headers ?? {}),
+    };
+    const response = await fetch(url, { ...init, headers });
+    const text = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, text);
+    }
+    if (!text.trim())
+        return null;
+    return JSON.parse(text);
+}
+// ── Client-side validation (mirrors mf-model-manager mutual exclusion) ─────
+/**
+ * Ensure small-model request bodies do not combine direct `model_config` with adapter mode.
+ */
+export function assertSmallModelConfigAdapterExclusive(body) {
+    const cfg = body.model_config;
+    const hasConfig = cfg != null &&
+        typeof cfg === "object" &&
+        !Array.isArray(cfg) &&
+        Object.keys(cfg).length > 0;
+    const adapter = body.adapter === true;
+    const code = typeof body.adapter_code === "string" && body.adapter_code.length > 0;
+    if (hasConfig && (adapter
+        || code)) {
+        throw new Error("model_config cannot be combined with adapter or adapter_code.");
+    }
+    if (!hasConfig && (!adapter
+        || !code)) {
+        throw new Error("Either model_config (non-empty) or adapter=true with adapter_code is required.");
+    }
+    if (adapter && !code) {
+        throw new Error("adapter=true requires adapter_code.");
+    }
+}
+/** For edit: validate mutual exclusion only when config or adapter fields are present. */
+export function assertSmallModelEditBody(body) {
+    const cfg = body.model_config;
+    const hasConfig = cfg != null &&
+        typeof cfg === "object" &&
+        !Array.isArray(cfg) &&
+        Object.keys(cfg).length > 0;
+    const adapter = body.adapter === true;
+    const code = typeof body.adapter_code === "string" && body.adapter_code.length > 0;
+    if (!hasConfig && !adapter && !code) {
+        return;
+    }
+    assertSmallModelConfigAdapterExclusive(body);
+}
+export async function listLlmModels(options) {
+    const { accessToken, businessDomain = "bd_public", page, size, order = "desc", rule = "update_time", series = "all", name = "", apiModel = "", modelType = "", quota, } = options;
+    const params = new URLSearchParams({
+        page: String(page),
+        size: String(size),
+        order,
+        rule,
+        series,
+        name,
+        api_model: apiModel,
+        model_type: modelType,
+    });
+    if (quota !== undefined) {
+        params.set("quota", String(quota));
+    }
+    const url = `${managerEndpoint(options, "/llm/list")}?${params.toString()}`;
+    return fetchJson(url, accessToken, businessDomain, { method: "GET" });
+}
+export async function getLlmModel(options) {
+    const { accessToken, businessDomain = "bd_public", modelId } = options;
+    const params = new URLSearchParams({ model_id: modelId });
+    const url = `${managerEndpoint(options, "/llm/get")}?${params.toString()}`;
+    return fetchJson(url, accessToken, businessDomain, { method: "GET" });
+}
+export async function addLlmModel(options) {
+    const { accessToken, businessDomain = "bd_public", body } = options;
+    const url = managerEndpoint(options, "/llm/add");
+    return fetchJson(url, accessToken, businessDomain, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+    });
+}
+export async function editLlmModel(options) {
+    const { accessToken, businessDomain = "bd_public", body } = options;
+    const url = managerEndpoint(options, "/llm/edit");
+    return fetchJson(url, accessToken, businessDomain, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+    });
+}
+export async function deleteLlmModels(options) {
+    const { accessToken, businessDomain = "bd_public", modelIds } = options;
+    const url = managerEndpoint(options, "/llm/delete");
+    return fetchJson(url, accessToken, businessDomain, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ model_ids: modelIds }),
+    });
+}
+export async function testLlmModel(options) {
+    const { accessToken, businessDomain = "bd_public", body } = options;
+    const url = managerEndpoint(options, "/llm/test");
+    return fetchJson(url, accessToken, businessDomain, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+    });
+}
+export async function listSmallModels(options) {
+    const { accessToken, businessDomain = "bd_public", page, size, order = "desc", rule = "update_time", modelName = "", modelType = "", modelSeries = "", } = options;
+    const params = new URLSearchParams({
+        order,
+        rule,
+        page: String(page),
+        size: String(size),
+        model_name: modelName,
+        model_type: modelType,
+        model_series: modelSeries,
+    });
+    const url = `${managerEndpoint(options, "/small-model/list")}?${params.toString()}`;
+    return fetchJson(url, accessToken, businessDomain, { method: "GET" });
+}
+export async function getSmallModel(options) {
+    const { accessToken, businessDomain = "bd_public", modelId } = options;
+    const params = new URLSearchParams({ model_id: modelId });
+    const url = `${managerEndpoint(options, "/small-model/get")}?${params.toString()}`;
+    return fetchJson(url, accessToken, businessDomain, { method: "GET" });
+}
+export async function addSmallModel(options) {
+    assertSmallModelConfigAdapterExclusive(options.body);
+    const { accessToken, businessDomain = "bd_public", body } = options;
+    const url = managerEndpoint(options, "/small-model/add");
+    return fetchJson(url, accessToken, businessDomain, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+    });
+}
+export async function editSmallModel(options) {
+    assertSmallModelEditBody(options.body);
+    const { accessToken, businessDomain = "bd_public", body } = options;
+    const url = managerEndpoint(options, "/small-model/edit");
+    return fetchJson(url, accessToken, businessDomain, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+    });
+}
+export async function deleteSmallModels(options) {
+    const { accessToken, businessDomain = "bd_public", modelIds } = options;
+    const url = managerEndpoint(options, "/small-model/delete");
+    return fetchJson(url, accessToken, businessDomain, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ model_ids: modelIds }),
+    });
+}
+export async function testSmallModel(options) {
+    const { accessToken, businessDomain = "bd_public", body } = options;
+    const url = managerEndpoint(options, "/small-model/test");
+    return fetchJson(url, accessToken, businessDomain, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+    });
+}

package/dist/api/ontology-query-metrics.d.ts

@@ -0,0 +1,14 @@
+import type { OntologyQueryBaseOptions } from "./ontology-query.js";
+export interface MetricQueryDataOptions extends OntologyQueryBaseOptions {
+    metricId: string;
+    body: string;
+    branch?: string;
+    fillNull?: boolean;
+}
+export interface MetricDryRunOptions extends OntologyQueryBaseOptions {
+    body: string;
+    branch?: string;
+    fillNull?: boolean;
+}
+export declare function metricQueryData(options: MetricQueryDataOptions): Promise<string>;
+export declare function metricDryRun(options: MetricDryRunOptions): Promise<string>;

package/dist/api/ontology-query-metrics.js

@@ -0,0 +1,30 @@
+import { fetchWithRetry } from "./ontology-query.js";
+import { buildHeaders } from "./headers.js";
+function appendMetricQueryParams(url, branch, fillNull) {
+    if (branch !== undefined)
+        url.searchParams.set("branch", branch);
+    if (fillNull !== undefined)
+        url.searchParams.set("fill_null", String(fillNull));
+}
+export async function metricQueryData(options) {
+    const { baseUrl, accessToken, knId, metricId, body, businessDomain = "bd_public", branch, fillNull, } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}/api/ontology-query/v1/knowledge-networks/${encodeURIComponent(knId)}/metrics/${encodeURIComponent(metricId)}/data`);
+    appendMetricQueryParams(url, branch, fillNull);
+    const headers = {
+        ...buildHeaders(accessToken, businessDomain),
+        "content-type": "application/json",
+    };
+    return fetchWithRetry(url.toString(), { method: "POST", headers, body });
+}
+export async function metricDryRun(options) {
+    const { baseUrl, accessToken, knId, body, businessDomain = "bd_public", branch, fillNull, } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}/api/ontology-query/v1/knowledge-networks/${encodeURIComponent(knId)}/metrics/dry-run`);
+    appendMetricQueryParams(url, branch, fillNull);
+    const headers = {
+        ...buildHeaders(accessToken, businessDomain),
+        "content-type": "application/json",
+    };
+    return fetchWithRetry(url.toString(), { method: "POST", headers, body });
+}

package/dist/api/trace.d.ts

@@ -0,0 +1,44 @@
+/**
+ * `RawSpan`-flavored view of conversation trace data, for diagnose rule
+ * predicates. The HTTP / two-hop / auth concerns live in `./agent-observability`;
+ * this module only normalizes the raw `_source` documents into the minimal
+ * span shape rules read.
+ */
+export { TraceFetchError } from "./agent-observability.js";
+export interface GetSpansByConversationIdOpts {
+    baseUrl: string;
+    token: string;
+    businessDomain: string;
+    conversationId: string;
+    /** Cap on `terms` aggregation bucket count. Default 100. */
+    maxTraceIds?: number;
+    /** Cap on spans returned by the second query. Default 2000. */
+    maxSpans?: number;
+}
+export interface RawSpan {
+    spanId: string;
+    parentSpanId: string | null;
+    name?: string;
+    startTimeUnixNano?: string;
+    endTimeUnixNano?: string;
+    status?: {
+        code?: string;
+    };
+    attributes?: Record<string, unknown>;
+    /** OTel traceId for the trace this span belongs to (when known). */
+    traceId?: string;
+}
+export interface GetSpansByConversationIdResult {
+    /** Distinct traceIds observed for this conversation. */
+    traceIds: string[];
+    /** All spans across all observed traceIds, mapped to `RawSpan` shape. */
+    spans: RawSpan[];
+    /** True if the agg saw `sum_other_doc_count > 0` (more traceIds than maxTraceIds). */
+    truncated: boolean;
+}
+/**
+ * ISO timestamp → nanos-since-epoch string. Preserves up to 9 fractional digits.
+ * Falls back to ms precision when the input lacks a fractional component.
+ */
+export declare function isoToNanos(iso: string | undefined): string | undefined;
+export declare function getSpansByConversationId(opts: GetSpansByConversationIdOpts): Promise<GetSpansByConversationIdResult>;

package/dist/api/trace.js

@@ -0,0 +1,81 @@
+/**
+ * `RawSpan`-flavored view of conversation trace data, for diagnose rule
+ * predicates. The HTTP / two-hop / auth concerns live in `./agent-observability`;
+ * this module only normalizes the raw `_source` documents into the minimal
+ * span shape rules read.
+ */
+import { fetchRawSpansByConversation } from "./agent-observability.js";
+export { TraceFetchError } from "./agent-observability.js";
+/**
+ * ISO timestamp → nanos-since-epoch string. Preserves up to 9 fractional digits.
+ * Falls back to ms precision when the input lacks a fractional component.
+ */
+export function isoToNanos(iso) {
+    if (!iso)
+        return undefined;
+    // "YYYY-MM-DDTHH:MM:SS.fffffffffZ" or "...+08:00"
+    const m = iso.match(/^(.+?)\.(\d{1,9})(Z|[+-]\d{2}:?\d{2})$/);
+    if (!m) {
+        const ms = Date.parse(iso);
+        if (Number.isNaN(ms))
+            return undefined;
+        return (BigInt(ms) * 1000000n).toString();
+    }
+    const ms = Date.parse(m[1] + m[3]);
+    if (Number.isNaN(ms))
+        return undefined;
+    const frac = m[2].padEnd(9, "0").slice(0, 9);
+    const seconds = BigInt(Math.floor(ms / 1000));
+    return (seconds * 1000000000n + BigInt(frac)).toString();
+}
+function normalizeToRawSpan(source) {
+    const spanIdRaw = source.spanId ?? source.span_id;
+    const spanId = typeof spanIdRaw === "string" ? spanIdRaw : "";
+    if (!spanId)
+        return null;
+    const parentRaw = source.parentSpanId ?? source.parent_span_id ?? source.parentSpanID;
+    const parentSpanId = typeof parentRaw === "string" && parentRaw !== "" && parentRaw !== "0" ? parentRaw : null;
+    // Prefer pre-normalized nanos (synthetic fixtures); else derive from ISO.
+    let startTimeUnixNano;
+    let endTimeUnixNano;
+    if (typeof source.startTimeUnixNano === "string")
+        startTimeUnixNano = source.startTimeUnixNano;
+    else if (typeof source.startTime === "string")
+        startTimeUnixNano = isoToNanos(source.startTime);
+    if (typeof source.endTimeUnixNano === "string")
+        endTimeUnixNano = source.endTimeUnixNano;
+    else if (typeof source.endTime === "string")
+        endTimeUnixNano = isoToNanos(source.endTime);
+    const status = source.status;
+    const attributes = source.attributes;
+    const name = typeof source.name === "string" ? source.name : undefined;
+    const traceIdRaw = source.traceId ?? source.trace_id;
+    const traceId = typeof traceIdRaw === "string" ? traceIdRaw : undefined;
+    return {
+        spanId,
+        parentSpanId,
+        name,
+        startTimeUnixNano,
+        endTimeUnixNano,
+        status,
+        attributes,
+        traceId,
+    };
+}
+export async function getSpansByConversationId(opts) {
+    const fetched = await fetchRawSpansByConversation({
+        baseUrl: opts.baseUrl,
+        accessToken: opts.token,
+        businessDomain: opts.businessDomain,
+        conversationId: opts.conversationId,
+        maxTraceIds: opts.maxTraceIds,
+        maxSpans: opts.maxSpans,
+    });
+    const spans = [];
+    for (const src of fetched.rawSources) {
+        const span = normalizeToRawSpan(src);
+        if (span)
+            spans.push(span);
+    }
+    return { traceIds: fetched.traceIds, spans, truncated: fetched.truncated };
+}

package/dist/api/vega.d.ts

@@ -238,3 +238,56 @@ export interface ListAllVegaResourcesOptions {
 /** List all Vega resources (no catalog filter). Uses GET /resources — not /resources/list, which
  * conflicts with GET /resources/{id} on some gateways (path segment "list" is treated as an id). */
 export declare function listAllVegaResources(options: ListAllVegaResourcesOptions): Promise<string>;
+export interface ListTablesWithColumnsOptions {
+    baseUrl: string;
+    accessToken: string;
+    /** A vega catalog id, not a legacy data-connection datasource UUID. */
+    id: string;
+    keyword?: string;
+    limit?: number;
+    offset?: number;
+    businessDomain?: string;
+    autoScan?: boolean;
+}
+/**
+ * List tables with column details from a vega catalog.
+ *
+ * Two-stage fetch:
+ *   1. GET /api/vega-backend/v1/catalogs/{id}/resources?category=table — list summaries
+ *   2. For each resource: GET /api/vega-backend/v1/resources/{rid} — pull source_metadata.columns
+ *
+ * If the catalog has no resources and `autoScan=true`, triggers a discover and
+ * retries the list once. The optional `keyword` filters summaries client-side
+ * before the per-resource detail fetches — useful to keep N+1 down to k+1.
+ *
+ * `id` is a vega catalog id.
+ */
+export declare function listTablesWithColumns(options: ListTablesWithColumnsOptions): Promise<string>;
+export interface ScanMetadataOptions {
+    baseUrl: string;
+    accessToken: string;
+    id: string;
+    /** Retained for signature compatibility; ignored — vega catalog already knows its connector_type. */
+    dsType?: string;
+    businessDomain?: string;
+}
+/**
+ * Trigger a metadata scan for a vega catalog and wait for completion.
+ * `id` is a vega catalog id (e.g. `d7nicrcjto2s73d9g67g`), not a legacy
+ * data-connection datasource UUID.
+ */
+export declare function scanMetadata(options: ScanMetadataOptions): Promise<string>;
+export interface ScanDatasourceMetadataOptions {
+    baseUrl: string;
+    accessToken: string;
+    id: string;
+    businessDomain?: string;
+}
+/**
+ * Trigger a metadata scan and wait for completion. `id` is a vega catalog id.
+ *
+ * @deprecated Use {@link scanMetadata} directly. This wrapper exists only for
+ * backward compatibility with callers that used the old data-connection-based
+ * `scanDatasourceMetadata` signature.
+ */
+export declare function scanDatasourceMetadata(options: ScanDatasourceMetadataOptions): Promise<string>;

package/dist/api/vega.js

@@ -488,3 +488,147 @@ export async function listAllVegaResources(options) {
         businessDomain,
     });
 }
+/**
+ * List tables with column details from a vega catalog.
+ *
+ * Two-stage fetch:
+ *   1. GET /api/vega-backend/v1/catalogs/{id}/resources?category=table — list summaries
+ *   2. For each resource: GET /api/vega-backend/v1/resources/{rid} — pull source_metadata.columns
+ *
+ * If the catalog has no resources and `autoScan=true`, triggers a discover and
+ * retries the list once. The optional `keyword` filters summaries client-side
+ * before the per-resource detail fetches — useful to keep N+1 down to k+1.
+ *
+ * `id` is a vega catalog id.
+ */
+export async function listTablesWithColumns(options) {
+    const { baseUrl, accessToken, id, keyword, limit, offset, businessDomain = "bd_public", autoScan = true, } = options;
+    async function listResourceSummaries() {
+        const body = await listVegaCatalogResources({
+            baseUrl,
+            accessToken,
+            id,
+            category: "table",
+            limit,
+            offset,
+            businessDomain,
+        });
+        const parsed = JSON.parse(body);
+        return Array.isArray(parsed) ? parsed : (parsed.entries ?? parsed.data ?? []);
+    }
+    let summaries = await listResourceSummaries();
+    if (summaries.length === 0 && autoScan) {
+        await scanMetadata({ baseUrl, accessToken, id, businessDomain });
+        summaries = await listResourceSummaries();
+    }
+    // Keyword filter applied after autoScan guard: if the catalog has tables but
+    // keyword matches none, we must NOT trigger a redundant discover.
+    if (keyword) {
+        const k = keyword.toLowerCase();
+        summaries = summaries.filter((it) => it.name.toLowerCase().includes(k));
+    }
+    const details = await Promise.all(summaries.map(async (s) => {
+        let body;
+        try {
+            body = await getVegaResource({
+                baseUrl,
+                accessToken,
+                id: s.id,
+                businessDomain,
+            });
+        }
+        catch (err) {
+            const reason = err instanceof Error ? err.message : String(err);
+            throw new Error(`vega resource ${s.id} fetch failed: ${reason}`);
+        }
+        const parsed = JSON.parse(body);
+        if (Array.isArray(parsed.entries)) {
+            const arr = parsed.entries;
+            if (arr.length === 0) {
+                throw new Error(`vega resource ${s.id} returned empty entries`);
+            }
+            return arr[0];
+        }
+        if (Array.isArray(parsed.data)) {
+            const arr = parsed.data;
+            if (arr.length === 0) {
+                throw new Error(`vega resource ${s.id} returned empty data`);
+            }
+            return arr[0];
+        }
+        return parsed;
+    }));
+    const tables = [];
+    for (const d of details) {
+        const columnsRaw = (d.source_metadata?.columns ?? []);
+        const tablePkArray = extractPrimaryKeys(d);
+        const columns = columnsRaw.map((c) => {
+            const name = String(c.name ?? c.field_name ?? "");
+            const flagged = isColumnPrimaryKey(c) || tablePkArray.includes(name);
+            return {
+                name,
+                type: String(c.type ?? c.field_type ?? "varchar"),
+                comment: typeof c.description === "string"
+                    ? c.description
+                    : (typeof c.comment === "string" ? c.comment : undefined),
+                ...(flagged ? { isPrimaryKey: true } : {}),
+            };
+        });
+        const synthesizedPks = tablePkArray.length > 0
+            ? tablePkArray
+            : columns.filter((c) => c.isPrimaryKey).map((c) => c.name);
+        tables.push({
+            name: d.name,
+            columns,
+            ...(synthesizedPks.length > 0 ? { primaryKeys: synthesizedPks } : {}),
+        });
+    }
+    return JSON.stringify(tables);
+}
+// Two PK metadata shapes are recognized — both confirmed conventions:
+//   - per-column `is_primary_key: true` (data-connection metadata standard)
+//   - per-column `column_key === "PRI"` (MySQL INFORMATION_SCHEMA pass-through)
+//   - table-level `primary_keys: string[]` (composite-PK carrier)
+// Other plausible spellings (camelCase, singular keys, SQLite `pk` integer) are
+// intentionally NOT recognized here — adding them speculatively risks false
+// matches and creates code paths the test suite can't pin down. Extend only when
+// a real backend response demonstrates the need.
+function isColumnPrimaryKey(col) {
+    if (col.is_primary_key === true)
+        return true;
+    if (typeof col.column_key === "string" && col.column_key.toUpperCase() === "PRI")
+        return true;
+    return false;
+}
+function extractPrimaryKeys(table) {
+    const arr = table.primary_keys;
+    if (Array.isArray(arr)) {
+        return arr.filter((x) => typeof x === "string");
+    }
+    return [];
+}
+/**
+ * Trigger a metadata scan for a vega catalog and wait for completion.
+ * `id` is a vega catalog id (e.g. `d7nicrcjto2s73d9g67g`), not a legacy
+ * data-connection datasource UUID.
+ */
+export async function scanMetadata(options) {
+    const { baseUrl, accessToken, id, businessDomain = "bd_public" } = options;
+    return discoverVegaCatalog({
+        baseUrl,
+        accessToken,
+        id,
+        wait: true,
+        businessDomain,
+    });
+}
+/**
+ * Trigger a metadata scan and wait for completion. `id` is a vega catalog id.
+ *
+ * @deprecated Use {@link scanMetadata} directly. This wrapper exists only for
+ * backward compatibility with callers that used the old data-connection-based
+ * `scanDatasourceMetadata` signature.
+ */
+export async function scanDatasourceMetadata(options) {
+    return scanMetadata(options);
+}

package/dist/bundled-model-templates.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Static JSON templates shipped with the CLI under ``src/templates/model`` (copied to ``dist/templates/model``).
+ * Read-only convenience until mf-model-manager exposes template APIs.
+ */
+export interface BundledModelTemplateEntry {
+    id: string;
+    file: string;
+    summary: string;
+}
+export interface BundledModelTemplateManifest {
+    llm: BundledModelTemplateEntry[];
+    small: BundledModelTemplateEntry[];
+}
+/** Resolve ``…/dist/templates/model`` (or ``…/src/templates/model`` when running via tsx from src). */
+export declare function bundledModelTemplatesDir(): string;
+export declare function loadBundledModelTemplateManifest(): Promise<BundledModelTemplateManifest>;
+export declare function readBundledModelTemplateFile(branch: "llm" | "small", templateId: string): Promise<string>;

package/dist/bundled-model-templates.js

@@ -0,0 +1,24 @@
+/**
+ * Static JSON templates shipped with the CLI under ``src/templates/model`` (copied to ``dist/templates/model``).
+ * Read-only convenience until mf-model-manager exposes template APIs.
+ */
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+/** Resolve ``…/dist/templates/model`` (or ``…/src/templates/model`` when running via tsx from src). */
+export function bundledModelTemplatesDir() {
+    return join(dirname(fileURLToPath(import.meta.url)), "templates", "model");
+}
+export async function loadBundledModelTemplateManifest() {
+    const raw = await readFile(join(bundledModelTemplatesDir(), "manifest.json"), "utf-8");
+    return JSON.parse(raw);
+}
+export async function readBundledModelTemplateFile(branch, templateId) {
+    const manifest = await loadBundledModelTemplateManifest();
+    const entries = branch === "llm" ? manifest.llm : manifest.small;
+    const hit = entries.find((e) => e.id === templateId);
+    if (!hit) {
+        throw new Error(`Unknown bundled template "${templateId}". Run: kweaver model ${branch} --template`);
+    }
+    return readFile(join(bundledModelTemplatesDir(), hit.file), "utf-8");
+}

package/dist/cli.js

@@ -10,6 +10,7 @@ import { runDataflowCommand } from "./commands/dataflow.js";
 import { runDsCommand } from "./commands/ds.js";
 import { runExploreCommand } from "./commands/explore.js";
 import { runDataviewCommand } from "./commands/dataview.js";
+import { runModelCommand } from "./commands/model.js";
 import { runSkillCommand } from "./commands/skill.js";
 import { runTokenCommand } from "./commands/token.js";
 import { runToolboxCommand } from "./commands/toolbox.js";
@@ -71,6 +72,10 @@ Usage:
   kweaver dataflow runs <dagId> [--since <date-like>] [-bd value]
   kweaver dataflow logs <dagId> <instanceId> [--detail] [-bd value]
 
+  kweaver model llm   list|get|add|edit|delete|test|chat|--template ...   (mf-model-manager + mf-model-api)
+  kweaver model small list|get|add|edit|delete|test|embeddings|rerank|--template ...
+  kweaver model --help
+
   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]
@@ -91,6 +96,7 @@ Usage:
   kweaver bkn push <directory> [--branch main] [-bd value] [--detect-encoding|--no-detect-encoding] [--source-encoding name]
   kweaver bkn pull <kn-id> [directory] [--branch main] [-bd value]
   kweaver bkn object-type list|get|create|update|delete|query|properties <kn-id> ...
+  kweaver bkn metric list|get|create|search|validate|update|delete|query|dry-run <kn-id> ...
   kweaver bkn relation-type list|get|create|update|delete <kn-id> ...
   kweaver bkn subgraph <kn-id> <body-json>
   kweaver bkn action-type list|query|inputs|execute <kn-id> ... [--wait] [--no-wait] [--timeout N]
@@ -167,6 +173,7 @@ Commands:
   agent          Agent CRUD, chat, sessions, history, publish/unpublish
   ds             Manage datasources (list, get, delete, tables, connect)
   dataflow       Dataflow document workflows (list, run, runs, logs)
+  model          Model factory: LLM/small-model CRUD (manager) and llm chat (OpenAI-compatible API)
   dataview|dv    List, find, get, query (SQL), delete data views (atomic / custom)
   bkn            Knowledge network (CRUD, build, validate, export, stats, push/pull,
                  object-type, relation-type, subgraph, action-type, action-execution, action-log)
@@ -176,6 +183,7 @@ Commands:
   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/HTTP (config, tools, resources, search-schema, tool-call, query-*, etc.)
+  trace          Diagnose a single trace with rule-based analysis
   help           Show this message`);
 }
 export async function run(argv) {
@@ -244,6 +252,9 @@ export async function run(argv) {
     if (command === "dataflow") {
         return runDataflowCommand(rest);
     }
+    if (command === "model") {
+        return runModelCommand(rest);
+    }
     if (command === "dataview" || command === "dv") {
         return runDataviewCommand(rest);
     }
@@ -277,6 +288,10 @@ export async function run(argv) {
     if (command === "context-loader" || command === "context") {
         return runContextLoaderCommand(rest);
     }
+    if (command === "trace") {
+        const { runTraceCommand } = await import("./commands/trace.js");
+        return await runTraceCommand(rest);
+    }
     console.error(`Unknown command: ${command}`);
     printHelp();
     return 1;