@kweaver-ai/kweaver-sdk 0.7.2 → 0.7.4

package/dist/api/model-invocation.d.ts

@@ -0,0 +1,58 @@
+export declare const MF_MODEL_API_PATH_PREFIX = "/api/mf-model-api/v1";
+export interface MfApiBaseOptions {
+    baseUrl: string;
+    accessToken: string;
+    businessDomain?: string;
+    /**
+     * Replace platform origin for mf-model-api (still appends `/api/mf-model-api/v1`).
+     * Overrides `KWEAVER_MF_MODEL_API_URL` when set.
+     */
+    mfApiBaseUrl?: string;
+}
+export interface ChatMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string;
+}
+export interface ModelChatCompletionsOptions extends MfApiBaseOptions {
+    /** Platform LLM config id (snowflake); always sent as `model_id`. */
+    modelId: string;
+    /**
+     * Registry **`model_name`** for the OpenAI-style **`model`** field in the request body.
+     * When omitted, **`model`** defaults to **`modelId`** (historical CLI behaviour).
+     * Some gateways resolve routing via display name and reject numeric-only **`model`**.
+     */
+    modelName?: string;
+    messages: ChatMessage[];
+    stream?: boolean;
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    topK?: number;
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+    cache?: boolean;
+    verbose?: boolean;
+}
+export interface ModelChatResult {
+    text: string;
+    raw?: unknown;
+}
+/**
+ * Consume an OpenAI-style SSE stream (`data: {...}` / `data: [DONE]`).
+ */
+export declare function consumeOpenAiSseText(response: Response, verbose?: boolean): Promise<string>;
+export declare function modelChatCompletions(options: ModelChatCompletionsOptions): Promise<ModelChatResult>;
+export interface ModelEmbeddingOptions extends MfApiBaseOptions {
+    modelId?: string;
+    modelName?: string;
+    input: string[];
+}
+export declare function modelEmbedding(options: ModelEmbeddingOptions): Promise<unknown>;
+export declare function modelEmbeddings(options: ModelEmbeddingOptions): Promise<unknown>;
+export interface ModelRerankOptions extends MfApiBaseOptions {
+    modelId?: string;
+    modelName?: string;
+    query: string;
+    documents: string[];
+}
+export declare function modelRerank(options: ModelRerankOptions): Promise<unknown>;

package/dist/api/model-invocation.js

@@ -0,0 +1,203 @@
+import { buildHeaders } from "./headers.js";
+import { HttpError } from "../utils/http.js";
+export const MF_MODEL_API_PATH_PREFIX = "/api/mf-model-api/v1";
+function resolveApiOrigin(options) {
+    const env = process.env.KWEAVER_MF_MODEL_API_URL;
+    const raw = options.mfApiBaseUrl ?? (env && env.length > 0 ? env : undefined) ?? options.baseUrl;
+    return raw.replace(/\/+$/, "");
+}
+function apiEndpoint(options, relPath) {
+    const origin = resolveApiOrigin(options);
+    const path = relPath.startsWith("/") ? relPath : `/${relPath}`;
+    return `${origin}${MF_MODEL_API_PATH_PREFIX}${path}`;
+}
+function buildChatBody(options) {
+    const { modelId, modelName, messages, stream = false, temperature, maxTokens, topP, topK, presencePenalty, frequencyPenalty, cache, } = options;
+    const trimmedName = typeof modelName === "string" ? modelName.trim() : "";
+    const modelField = trimmedName.length > 0 ? trimmedName : modelId;
+    const body = {
+        model: modelField,
+        model_id: modelId,
+        messages,
+        stream,
+    };
+    if (temperature !== undefined)
+        body.temperature = temperature;
+    if (maxTokens !== undefined)
+        body.max_tokens = maxTokens;
+    if (topP !== undefined)
+        body.top_p = topP;
+    if (topK !== undefined)
+        body.top_k = topK;
+    if (presencePenalty !== undefined)
+        body.presence_penalty = presencePenalty;
+    if (frequencyPenalty !== undefined)
+        body.frequency_penalty = frequencyPenalty;
+    if (cache !== undefined)
+        body.cache = cache;
+    return body;
+}
+function extractOpenAiCompletionText(json) {
+    const choices = json.choices;
+    const msg = choices?.[0]?.message;
+    const content = msg?.content;
+    if (typeof content === "string")
+        return content;
+    return "";
+}
+function extractOpenAiDeltaChunk(chunk) {
+    const choices = chunk.choices;
+    if (!choices?.[0])
+        return "";
+    const delta = choices[0].delta;
+    const c = delta?.content;
+    if (typeof c === "string")
+        return c;
+    return "";
+}
+/**
+ * Consume an OpenAI-style SSE stream (`data: {...}` / `data: [DONE]`).
+ */
+export async function consumeOpenAiSseText(response, verbose) {
+    const reader = response.body?.getReader();
+    if (!reader)
+        throw new Error("No response body for stream");
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let out = "";
+    const processLine = (line) => {
+        const trimmed = line.trimEnd();
+        if (!trimmed.startsWith("data:"))
+            return;
+        const payload = trimmed.slice(5).trim();
+        if (payload === "[DONE]")
+            return;
+        try {
+            const chunk = JSON.parse(payload);
+            out += extractOpenAiDeltaChunk(chunk);
+        }
+        catch (e) {
+            if (verbose) {
+                const msg = e instanceof Error ? e.message : String(e);
+                console.error(`SSE parse skip: ${msg} payload=${payload.slice(0, 120)}`);
+            }
+        }
+    };
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const ln of lines) {
+            processLine(ln);
+        }
+    }
+    if (buffer.trim())
+        processLine(buffer);
+    return out;
+}
+export async function modelChatCompletions(options) {
+    const { accessToken, businessDomain = "bd_public", stream = false, verbose } = options;
+    const url = apiEndpoint(options, "/chat/completions");
+    const body = buildChatBody({ ...options, stream });
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+            accept: stream ? "text/event-stream" : "application/json",
+        },
+        body: JSON.stringify(body),
+    });
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!response.ok) {
+        const text = await response.text();
+        throw new HttpError(response.status, response.statusText, text);
+    }
+    if (stream && contentType.includes("text/event-stream")) {
+        const text = await consumeOpenAiSseText(response, verbose);
+        return { text };
+    }
+    const text = await response.text();
+    const json = JSON.parse(text);
+    return { text: extractOpenAiCompletionText(json), raw: json };
+}
+// ── Small model invocation (mf-model-api) ───────────────────────────────────
+/** OpenAI-style **`model`** for small-model routes: registry name when set, else **`model_id`** (matches chat completions). */
+function resolveSmallInvokeModelField(modelName, modelId) {
+    const trimmedName = typeof modelName === "string" ? modelName.trim() : "";
+    if (trimmedName.length > 0)
+        return trimmedName;
+    const id = typeof modelId === "string" ? modelId.trim() : "";
+    if (id.length > 0)
+        return id;
+    return undefined;
+}
+export async function modelEmbedding(options) {
+    const { accessToken, businessDomain = "bd_public", modelId, modelName, input } = options;
+    const url = apiEndpoint(options, "/small-model/embedding");
+    const body = { input };
+    if (modelId)
+        body.model_id = modelId;
+    const modelField = resolveSmallInvokeModelField(modelName, modelId);
+    if (modelField !== undefined)
+        body.model = modelField;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+        },
+        body: JSON.stringify(body),
+    });
+    const text = await response.text();
+    if (!response.ok)
+        throw new HttpError(response.status, response.statusText, text);
+    return text ? JSON.parse(text) : null;
+}
+export async function modelEmbeddings(options) {
+    const { accessToken, businessDomain = "bd_public", modelId, modelName, input } = options;
+    const url = apiEndpoint(options, "/small-model/embeddings");
+    const body = { input };
+    if (modelId)
+        body.model_id = modelId;
+    const modelField = resolveSmallInvokeModelField(modelName, modelId);
+    if (modelField !== undefined)
+        body.model = modelField;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+        },
+        body: JSON.stringify(body),
+    });
+    const text = await response.text();
+    if (!response.ok)
+        throw new HttpError(response.status, response.statusText, text);
+    return text ? JSON.parse(text) : null;
+}
+export async function modelRerank(options) {
+    const { accessToken, businessDomain = "bd_public", modelId, modelName, query, documents } = options;
+    const url = apiEndpoint(options, "/small-model/reranker");
+    const body = { query, documents };
+    if (modelId)
+        body.model_id = modelId;
+    const modelField = resolveSmallInvokeModelField(modelName, modelId);
+    if (modelField !== undefined)
+        body.model = modelField;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+        },
+        body: JSON.stringify(body),
+    });
+    const text = await response.text();
+    if (!response.ok)
+        throw new HttpError(response.status, response.statusText, text);
+    return text ? JSON.parse(text) : null;
+}

package/dist/api/models.d.ts

@@ -0,0 +1,79 @@
+export declare const MF_MODEL_MANAGER_PATH_PREFIX = "/api/mf-model-manager/v1";
+export interface MfManagerBaseOptions {
+    baseUrl: string;
+    accessToken: string;
+    businessDomain?: string;
+    /**
+     * Replace platform origin for mf-model-manager (still appends `/api/mf-model-manager/v1`).
+     * Overrides `KWEAVER_MF_MODEL_MANAGER_URL` when set.
+     */
+    mfManagerBaseUrl?: string;
+}
+/**
+ * Ensure small-model request bodies do not combine direct `model_config` with adapter mode.
+ */
+export declare function assertSmallModelConfigAdapterExclusive(body: Record<string, unknown>): void;
+/** For edit: validate mutual exclusion only when config or adapter fields are present. */
+export declare function assertSmallModelEditBody(body: Record<string, unknown>): void;
+export interface ListLlmModelsOptions extends MfManagerBaseOptions {
+    page: number;
+    size: number;
+    order?: string;
+    rule?: string;
+    series?: string;
+    name?: string;
+    apiModel?: string;
+    modelType?: string;
+    quota?: boolean;
+}
+export declare function listLlmModels(options: ListLlmModelsOptions): Promise<unknown>;
+export interface GetLlmModelOptions extends MfManagerBaseOptions {
+    modelId: string;
+}
+export declare function getLlmModel(options: GetLlmModelOptions): Promise<unknown>;
+export interface AddLlmModelOptions extends MfManagerBaseOptions {
+    body: Record<string, unknown>;
+}
+export declare function addLlmModel(options: AddLlmModelOptions): Promise<unknown>;
+export interface EditLlmModelOptions extends MfManagerBaseOptions {
+    body: Record<string, unknown>;
+}
+export declare function editLlmModel(options: EditLlmModelOptions): Promise<unknown>;
+export interface DeleteLlmModelsOptions extends MfManagerBaseOptions {
+    modelIds: string[];
+}
+export declare function deleteLlmModels(options: DeleteLlmModelsOptions): Promise<unknown>;
+export interface TestLlmModelOptions extends MfManagerBaseOptions {
+    body: Record<string, unknown>;
+}
+export declare function testLlmModel(options: TestLlmModelOptions): Promise<unknown>;
+export interface ListSmallModelsOptions extends MfManagerBaseOptions {
+    page: number;
+    size: number;
+    order?: string;
+    rule?: string;
+    modelName?: string;
+    modelType?: string;
+    modelSeries?: string;
+}
+export declare function listSmallModels(options: ListSmallModelsOptions): Promise<unknown>;
+export interface GetSmallModelOptions extends MfManagerBaseOptions {
+    modelId: string;
+}
+export declare function getSmallModel(options: GetSmallModelOptions): Promise<unknown>;
+export interface AddSmallModelOptions extends MfManagerBaseOptions {
+    body: Record<string, unknown>;
+}
+export declare function addSmallModel(options: AddSmallModelOptions): Promise<unknown>;
+export interface EditSmallModelOptions extends MfManagerBaseOptions {
+    body: Record<string, unknown>;
+}
+export declare function editSmallModel(options: EditSmallModelOptions): Promise<unknown>;
+export interface DeleteSmallModelsOptions extends MfManagerBaseOptions {
+    modelIds: string[];
+}
+export declare function deleteSmallModels(options: DeleteSmallModelsOptions): Promise<unknown>;
+export interface TestSmallModelOptions extends MfManagerBaseOptions {
+    body: Record<string, unknown>;
+}
+export declare function testSmallModel(options: TestSmallModelOptions): Promise<unknown>;

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

@@ -63,6 +63,8 @@ export interface InvokeToolOptions extends BaseOpts {
     header?: Record<string, unknown>;
     /** Optional query params to forward. */
     query?: Record<string, unknown>;
+    /** Path parameter map for OpenAPI `{param}` placeholders (e.g. `{ id: "<uuid>" }`). */
+    path?: Record<string, unknown>;
     /** JSON body forwarded to the downstream tool. */
     body?: unknown;
     /** Per-call timeout in seconds; backend default applies when omitted. */

package/dist/api/toolboxes.js

@@ -20,7 +20,7 @@ import { buildHeaders } from "./headers.js";
 //   POST   /tool-box/{box}/tool/{tool}/debug       debug tool (envelope JSON)
 //
 // Envelope shape required by /proxy and /debug:
-//   { "timeout": <s>, "header": {...}, "query": {...}, "body": {...} }
+//   { "timeout": <s>, "header": {...}, "query": {...}, "body": {...}, "path": {...} }
 // Flat-shape requests cause the forwarder to drop downstream Authorization
 // headers, which manifests as 401 "token expired" from the underlying tool.
 const PATH = "/api/agent-operator-integration/v1/tool-box";
@@ -145,6 +145,7 @@ function buildEnvelope(opts) {
         envelope.timeout = opts.timeout;
     envelope.header = opts.header ?? {};
     envelope.query = opts.query ?? {};
+    envelope.path = opts.path ?? {};
     envelope.body = opts.body ?? {};
     return JSON.stringify(envelope);
 }

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");
+}