@dbx-tools/model 0.9.21 → 0.9.29

package/lib/src/policy.js

@@ -1,26 +1,185 @@
-/**
- * Browser-safe model metadata projected from the Rust policy bindings.
- *
- * @module
- */
-import { modelFamily as modelFamilyWithRust, reasoningEffortNamesByFamily, supportsToolsByFamily as supportsToolsByFamilyWithRust, } from "@dbx-tools/model-rs";
-import { model, ReasoningEffortSchema, } from "@dbx-tools/shared-model";
-/** Return the normalized family parsed by the Rust model-name policy. */
+/** TypeScript-owned model-family and serving capability policy. */
+import { ModelClass, } from "@dbx-tools/shared-model/contracts";
+import { supportsToolsByFamily } from "./classify.js";
+const FAMILIES = [
+    "bge",
+    "claude",
+    "deepseek",
+    "gemini",
+    "gemma",
+    "glm",
+    "gpt",
+    "grok",
+    "gte",
+    "inkling",
+    "kimi",
+    "llama",
+    "qwen",
+];
+const STANDARD = ["low", "medium", "high"];
+const GPT_5_6 = ["none", "low", "medium", "high", "xhigh", "max"];
+const GPT_5_5_PRO = ["medium", "high", "xhigh"];
+const CLAUDE = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
+const GEMINI = ["minimal", "low", "medium", "high"];
+/** Return the normalized family parsed from a model identity. */
 export function modelFamily(name) {
-    return modelFamilyWithRust(name);
+    return parseModelName(name)?.family;
+}
+/** Normalize a recognized model identity into family, version, and variant tokens. */
+export function modelSearchQuery(name) {
+    const parsed = parseModelName(name);
+    if (!parsed)
+        return undefined;
+    return [parsed.family, ...parsed.version.map(String), ...parsed.model].join(" ");
 }
 /** Return the reasoning efforts accepted by a model family. */
 export function modelReasoningEfforts(name) {
-    return ReasoningEffortSchema.array().parse(reasoningEffortNamesByFamily(name));
+    const normalized = name.toLowerCase();
+    const parsed = parseModelName(name);
+    let efforts = [];
+    if (parsed?.family === "gpt" && parsed.version.length > 0) {
+        const [major = 0, minor = 0] = parsed.version;
+        if (major >= 5) {
+            efforts =
+                major === 5 && minor === 5 && parsed.model.includes("pro")
+                    ? GPT_5_5_PRO
+                    : major === 5 && minor === 6
+                        ? GPT_5_6
+                        : STANDARD;
+        }
+    }
+    if (parsed?.family === "gpt" && parsed.model.includes("oss"))
+        efforts = STANDARD;
+    if (parsed?.family === "claude") {
+        const [major = 0, minor = 0] = parsed.version;
+        if (major > 3 || (major === 3 && minor >= 7))
+            efforts = CLAUDE;
+    }
+    if (parsed?.family === "gemini")
+        efforts = GEMINI;
+    if (normalized.includes("codex") || /(?:^|[-_./])o(?:1|3|4)(?:[-_./]|$)/i.test(name)) {
+        efforts = STANDARD;
+    }
+    return efforts;
 }
-/** Return whether Rust policy verifies a complete tool-calling round trip. */
+/** Return whether policy verifies a complete tool-calling round trip. */
 export function modelSupportsTools(name) {
-    return supportsToolsByFamilyWithRust(name);
+    return supportsToolsByFamily(name);
 }
 /** Return whether a discovered endpoint can be used for a tool-calling chat. */
 export function endpointSupportsTools(endpoint) {
-    const embedding = endpoint.task === "llm/v1/embeddings" || endpoint.class === model.ModelClass.Embedding;
+    const embedding = endpoint.task === "llm/v1/embeddings" || endpoint.class === ModelClass.Embedding;
     const chat = !embedding && (endpoint.task === "llm/v1/chat" || endpoint.class !== undefined);
     return chat && (endpoint.supportsTools ?? modelSupportsTools(endpoint.name));
 }
-//# sourceMappingURL=data:application/json;base64,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
+/** Return whether a model requires Databricks' native Responses endpoint. */
+export function isResponsesOnly(name) {
+    if (name.toLowerCase().includes("codex"))
+        return true;
+    const parsed = parseModelName(name);
+    if (!parsed || parsed.family !== "gpt" || parsed.model.includes("oss"))
+        return false;
+    const [major = 0, minor = 0] = parsed.version;
+    return major > 5 || (major === 5 && minor >= 4);
+}
+/** Return the Databricks inference protocol required by a model. */
+export function modelServingApi(name) {
+    return isResponsesOnly(name) ? "responses" : "chat";
+}
+/** Return the Chat Completions effort required when function tools are present. */
+export function chatToolReasoningEffort(name) {
+    const parsed = parseModelName(name);
+    if (!parsed || parsed.family !== "gpt")
+        return undefined;
+    const [major = 0, minor = 0] = parsed.version;
+    return major === 5 && minor === 6 ? "none" : undefined;
+}
+/** Derive provider-specific model names from a Databricks model identity. */
+export function modelServiceNames(name) {
+    const parsed = parseModelName(name);
+    if (!parsed)
+        return {};
+    const version = parsed.version.join(".");
+    const suffix = parsed.model.length ? `-${parsed.model.join("-")}` : "";
+    switch (parsed.family) {
+        case "gpt":
+            return parsed.model.includes("oss") ? {} : { openai: `gpt-${version}${suffix}` };
+        case "claude": {
+            const [variant, ...rest] = parsed.model;
+            return variant
+                ? { anthropic: `claude-${variant}-${version}${rest.length ? `-${rest.join("-")}` : ""}` }
+                : {};
+        }
+        case "gemini":
+        case "gemma":
+            return { google: `${parsed.family}-${version}${suffix}` };
+        case "glm":
+            return { zhipu: `glm-${version}${suffix}` };
+        case "grok":
+            return { xai: `grok-${version}${suffix}` };
+        case "llama":
+            return { meta: `llama-${version}${suffix}` };
+        case "qwen":
+            return { alibaba: `qwen${version}${suffix}` };
+        case "deepseek":
+            return { deepseek: `deepseek-v${parsed.version[0] ?? ""}${suffix}` };
+        case "kimi":
+            return { moonshot: `kimi-k${parsed.version[0] ?? ""}${suffix}` };
+        default:
+            return {};
+    }
+}
+function parseModelName(name) {
+    const tokens = name.toLowerCase().match(/[a-z0-9]+/g) ?? [];
+    let familyIndex = -1;
+    let family;
+    for (let index = 0; index < tokens.length; index += 1) {
+        const token = tokens[index];
+        const compactQwen = /^qwen(\d+)$/.exec(token);
+        if (compactQwen) {
+            familyIndex = index;
+            family = "qwen";
+            break;
+        }
+        if (FAMILIES.includes(token)) {
+            familyIndex = index;
+            family = token;
+            break;
+        }
+    }
+    if (!family || familyIndex < 0)
+        return undefined;
+    const remainder = tokens.slice(familyIndex + 1);
+    const numeric = (value) => /^\d+$/.test(value);
+    let versionStart = remainder.findIndex(numeric);
+    if (family === "qwen" && /^qwen\d+$/.test(tokens[familyIndex])) {
+        versionStart = 0;
+        remainder.unshift(tokens[familyIndex].slice(4));
+    }
+    if (family === "deepseek") {
+        const prefixed = remainder.findIndex((value) => /^v\d+$/.test(value));
+        if (prefixed >= 0)
+            remainder[prefixed] = remainder[prefixed].slice(1);
+        versionStart = remainder.findIndex(numeric);
+    }
+    if (family === "kimi") {
+        const prefixed = remainder.findIndex((value) => /^k\d+$/.test(value));
+        if (prefixed >= 0)
+            remainder[prefixed] = remainder[prefixed].slice(1);
+        versionStart = remainder.findIndex(numeric);
+    }
+    if (versionStart < 0)
+        return { family, version: [], model: remainder };
+    const version = [];
+    let cursor = versionStart;
+    while (cursor < remainder.length && version.length < 2 && numeric(remainder[cursor])) {
+        version.push(Number(remainder[cursor]));
+        cursor += 1;
+    }
+    return {
+        family,
+        version,
+        model: [...remainder.slice(0, versionStart), ...remainder.slice(cursor)],
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"policy.js","sourceRoot":"","sources":["../../src/policy.ts"],"names":[],"mappings":"AAAA,mEAAmE;AAEnE,OAAO,EACL,UAAU,GAGX,MAAM,mCAAmC,CAAC;AAE3C,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAEtD,MAAM,QAAQ,GAAG;IACf,KAAK;IACL,QAAQ;IACR,UAAU;IACV,QAAQ;IACR,OAAO;IACP,KAAK;IACL,KAAK;IACL,MAAM;IACN,KAAK;IACL,SAAS;IACT,MAAM;IACN,OAAO;IACP,MAAM;CACE,CAAC;AAEX,MAAM,QAAQ,GAAsB,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;AAC9D,MAAM,OAAO,GAAsB,CAAC,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;AACrF,MAAM,WAAW,GAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;AACnE,MAAM,MAAM,GAAsB,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;AAC/F,MAAM,MAAM,GAAsB,CAAC,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;AAQvE,iEAAiE;AACjE,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,OAAO,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;AACtC,CAAC;AAED,sFAAsF;AACtF,MAAM,UAAU,gBAAgB,CAAC,IAAY;IAC3C,MAAM,MAAM,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;IACpC,IAAI,CAAC,MAAM;QAAE,OAAO,SAAS,CAAC;IAC9B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACnF,CAAC;AAED,+DAA+D;AAC/D,MAAM,UAAU,qBAAqB,CAAC,IAAY;IAChD,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;IACtC,MAAM,MAAM,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;IACpC,IAAI,OAAO,GAAsB,EAAE,CAAC;IACpC,IAAI,MAAM,EAAE,MAAM,KAAK,KAAK,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC1D,MAAM,CAAC,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC;QAC9C,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;YACf,OAAO;gBACL,KAAK,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC;oBACxD,CAAC,CAAC,WAAW;oBACb,CAAC,CAAC,KAAK,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC;wBAC1B,CAAC,CAAC,OAAO;wBACT,CAAC,CAAC,QAAQ,CAAC;QACnB,CAAC;IACH,CAAC;IACD,IAAI,MAAM,EAAE,MAAM,KAAK,KAAK,IAAI,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,GAAG,QAAQ,CAAC;IACjF,IAAI,MAAM,EAAE,MAAM,KAAK,QAAQ,EAAE,CAAC;QAChC,MAAM,CAAC,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC;QAC9C,IAAI,KAAK,GAAG,CAAC,IAAI,CAAC,KAAK,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;YAAE,OAAO,GAAG,MAAM,CAAC;IACjE,CAAC;IACD,IAAI,MAAM,EAAE,MAAM,KAAK,QAAQ;QAAE,OAAO,GAAG,MAAM,CAAC;IAClD,IAAI,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,qCAAqC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QACrF,OAAO,GAAG,QAAQ,CAAC;IACrB,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,kBAAkB,CAAC,IAAY;IAC7C,OAAO,qBAAqB,CAAC,IAAI,CAAC,CAAC;AACrC,CAAC;AAED,gFAAgF;AAChF,MAAM,UAAU,qBAAqB,CAAC,QAAgC;IACpE,MAAM,SAAS,GACb,QAAQ,CAAC,IAAI,KAAK,mBAAmB,IAAI,QAAQ,CAAC,KAAK,KAAK,UAAU,CAAC,SAAS,CAAC;IACnF,MAAM,IAAI,GAAG,CAAC,SAAS,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,aAAa,IAAI,QAAQ,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC;IAC7F,OAAO,IAAI,IAAI,CAAC,QAAQ,CAAC,aAAa,IAAI,kBAAkB,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;AAC/E,CAAC;AAED,6EAA6E;AAC7E,MAAM,UAAU,eAAe,CAAC,IAAY;IAC1C,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC;QAAE,OAAO,IAAI,CAAC;IACtD,MAAM,MAAM,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;IACpC,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,KAAK,IAAI,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACrF,MAAM,CAAC,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC;IAC9C,OAAO,KAAK,GAAG,CAAC,IAAI,CAAC,KAAK,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC;AAClD,CAAC;AAED,oEAAoE;AACpE,MAAM,UAAU,eAAe,CAAC,IAAY;IAC1C,OAAO,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC;AACtD,CAAC;AAED,mFAAmF;AACnF,MAAM,UAAU,uBAAuB,CAAC,IAAY;IAClD,MAAM,MAAM,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;IACpC,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,KAAK;QAAE,OAAO,SAAS,CAAC;IACzD,MAAM,CAAC,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC;IAC9C,OAAO,KAAK,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;AACzD,CAAC;AAED,6EAA6E;AAC7E,MAAM,UAAU,iBAAiB,CAAC,IAAY;IAC5C,MAAM,MAAM,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;IACpC,IAAI,CAAC,MAAM;QAAE,OAAO,EAAE,CAAC;IACvB,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACzC,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IACvE,QAAQ,MAAM,CAAC,MAAM,EAAE,CAAC;QACtB,KAAK,KAAK;YACR,OAAO,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,OAAO,GAAG,MAAM,EAAE,EAAE,CAAC;QACnF,KAAK,QAAQ,CAAC,CAAC,CAAC;YACd,MAAM,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;YACxC,OAAO,OAAO;gBACZ,CAAC,CAAC,EAAE,SAAS,EAAE,UAAU,OAAO,IAAI,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE;gBACzF,CAAC,CAAC,EAAE,CAAC;QACT,CAAC;QACD,KAAK,QAAQ,CAAC;QACd,KAAK,OAAO;YACV,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,IAAI,OAAO,GAAG,MAAM,EAAE,EAAE,CAAC;QAC5D,KAAK,KAAK;YACR,OAAO,EAAE,KAAK,EAAE,OAAO,OAAO,GAAG,MAAM,EAAE,EAAE,CAAC;QAC9C,KAAK,MAAM;YACT,OAAO,EAAE,GAAG,EAAE,QAAQ,OAAO,GAAG,MAAM,EAAE,EAAE,CAAC;QAC7C,KAAK,OAAO;YACV,OAAO,EAAE,IAAI,EAAE,SAAS,OAAO,GAAG,MAAM,EAAE,EAAE,CAAC;QAC/C,KAAK,MAAM;YACT,OAAO,EAAE,OAAO,EAAE,OAAO,OAAO,GAAG,MAAM,EAAE,EAAE,CAAC;QAChD,KAAK,UAAU;YACb,OAAO,EAAE,QAAQ,EAAE,aAAa,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,EAAE,GAAG,MAAM,EAAE,EAAE,CAAC;QACvE,KAAK,MAAM;YACT,OAAO,EAAE,QAAQ,EAAE,SAAS,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,EAAE,GAAG,MAAM,EAAE,EAAE,CAAC;QACnE;YACE,OAAO,EAAE,CAAC;IACd,CAAC;AACH,CAAC;AAED,SAAS,cAAc,CAAC,IAAY;IAClC,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;IAC5D,IAAI,WAAW,GAAG,CAAC,CAAC,CAAC;IACrB,IAAI,MAA6C,CAAC;IAClD,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;QACtD,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAE,CAAC;QAC7B,MAAM,WAAW,GAAG,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC9C,IAAI,WAAW,EAAE,CAAC;YAChB,WAAW,GAAG,KAAK,CAAC;YACpB,MAAM,GAAG,MAAM,CAAC;YAChB,MAAM;QACR,CAAC;QACD,IAAI,QAAQ,CAAC,QAAQ,CAAC,KAAkC,CAAC,EAAE,CAAC;YAC1D,WAAW,GAAG,KAAK,CAAC;YACpB,MAAM,GAAG,KAAkC,CAAC;YAC5C,MAAM;QACR,CAAC;IACH,CAAC;IACD,IAAI,CAAC,MAAM,IAAI,WAAW,GAAG,CAAC;QAAE,OAAO,SAAS,CAAC;IACjD,MAAM,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC,WAAW,GAAG,CAAC,CAAC,CAAC;IAChD,MAAM,OAAO,GAAG,CAAC,KAAa,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACvD,IAAI,YAAY,GAAG,SAAS,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IAChD,IAAI,MAAM,KAAK,MAAM,IAAI,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAE,CAAC,EAAE,CAAC;QAChE,YAAY,GAAG,CAAC,CAAC;QACjB,SAAS,CAAC,OAAO,CAAC,MAAM,CAAC,WAAW,CAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACnD,CAAC;IACD,IAAI,MAAM,KAAK,UAAU,EAAE,CAAC;QAC1B,MAAM,QAAQ,GAAG,SAAS,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QACtE,IAAI,QAAQ,IAAI,CAAC;YAAE,SAAS,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC,QAAQ,CAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACvE,YAAY,GAAG,SAAS,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IAC9C,CAAC;IACD,IAAI,MAAM,KAAK,MAAM,EAAE,CAAC;QACtB,MAAM,QAAQ,GAAG,SAAS,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QACtE,IAAI,QAAQ,IAAI,CAAC;YAAE,SAAS,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC,QAAQ,CAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACvE,YAAY,GAAG,SAAS,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IAC9C,CAAC;IACD,IAAI,YAAY,GAAG,CAAC;QAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;IACvE,MAAM,OAAO,GAAa,EAAE,CAAC;IAC7B,IAAI,MAAM,GAAG,YAAY,CAAC;IAC1B,OAAO,MAAM,GAAG,SAAS,CAAC,MAAM,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,OAAO,CAAC,SAAS,CAAC,MAAM,CAAE,CAAC,EAAE,CAAC;QACtF,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QACxC,MAAM,IAAI,CAAC,CAAC;IACd,CAAC;IACD,OAAO;QACL,MAAM;QACN,OAAO;QACP,KAAK,EAAE,CAAC,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,YAAY,CAAC,EAAE,GAAG,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;KACzE,CAAC;AACJ,CAAC","sourcesContent":["/** TypeScript-owned model-family and serving capability policy. */\n\nimport {\n  ModelClass,\n  type ReasoningEffort,\n  type ServingEndpointSummary,\n} from \"@dbx-tools/shared-model/contracts\";\n\nimport { supportsToolsByFamily } from \"./classify.ts\";\n\nconst FAMILIES = [\n  \"bge\",\n  \"claude\",\n  \"deepseek\",\n  \"gemini\",\n  \"gemma\",\n  \"glm\",\n  \"gpt\",\n  \"grok\",\n  \"gte\",\n  \"inkling\",\n  \"kimi\",\n  \"llama\",\n  \"qwen\",\n] as const;\n\nconst STANDARD: ReasoningEffort[] = [\"low\", \"medium\", \"high\"];\nconst GPT_5_6: ReasoningEffort[] = [\"none\", \"low\", \"medium\", \"high\", \"xhigh\", \"max\"];\nconst GPT_5_5_PRO: ReasoningEffort[] = [\"medium\", \"high\", \"xhigh\"];\nconst CLAUDE: ReasoningEffort[] = [\"none\", \"minimal\", \"low\", \"medium\", \"high\", \"xhigh\", \"max\"];\nconst GEMINI: ReasoningEffort[] = [\"minimal\", \"low\", \"medium\", \"high\"];\n\ninterface ParsedModelName {\n  family: (typeof FAMILIES)[number];\n  version: number[];\n  model: string[];\n}\n\n/** Return the normalized family parsed from a model identity. */\nexport function modelFamily(name: string): string | undefined {\n  return parseModelName(name)?.family;\n}\n\n/** Normalize a recognized model identity into family, version, and variant tokens. */\nexport function modelSearchQuery(name: string): string | undefined {\n  const parsed = parseModelName(name);\n  if (!parsed) return undefined;\n  return [parsed.family, ...parsed.version.map(String), ...parsed.model].join(\" \");\n}\n\n/** Return the reasoning efforts accepted by a model family. */\nexport function modelReasoningEfforts(name: string): ReasoningEffort[] {\n  const normalized = name.toLowerCase();\n  const parsed = parseModelName(name);\n  let efforts: ReasoningEffort[] = [];\n  if (parsed?.family === \"gpt\" && parsed.version.length > 0) {\n    const [major = 0, minor = 0] = parsed.version;\n    if (major >= 5) {\n      efforts =\n        major === 5 && minor === 5 && parsed.model.includes(\"pro\")\n          ? GPT_5_5_PRO\n          : major === 5 && minor === 6\n            ? GPT_5_6\n            : STANDARD;\n    }\n  }\n  if (parsed?.family === \"gpt\" && parsed.model.includes(\"oss\")) efforts = STANDARD;\n  if (parsed?.family === \"claude\") {\n    const [major = 0, minor = 0] = parsed.version;\n    if (major > 3 || (major === 3 && minor >= 7)) efforts = CLAUDE;\n  }\n  if (parsed?.family === \"gemini\") efforts = GEMINI;\n  if (normalized.includes(\"codex\") || /(?:^|[-_./])o(?:1|3|4)(?:[-_./]|$)/i.test(name)) {\n    efforts = STANDARD;\n  }\n  return efforts;\n}\n\n/** Return whether policy verifies a complete tool-calling round trip. */\nexport function modelSupportsTools(name: string): boolean {\n  return supportsToolsByFamily(name);\n}\n\n/** Return whether a discovered endpoint can be used for a tool-calling chat. */\nexport function endpointSupportsTools(endpoint: ServingEndpointSummary): boolean {\n  const embedding =\n    endpoint.task === \"llm/v1/embeddings\" || endpoint.class === ModelClass.Embedding;\n  const chat = !embedding && (endpoint.task === \"llm/v1/chat\" || endpoint.class !== undefined);\n  return chat && (endpoint.supportsTools ?? modelSupportsTools(endpoint.name));\n}\n\n/** Return whether a model requires Databricks' native Responses endpoint. */\nexport function isResponsesOnly(name: string): boolean {\n  if (name.toLowerCase().includes(\"codex\")) return true;\n  const parsed = parseModelName(name);\n  if (!parsed || parsed.family !== \"gpt\" || parsed.model.includes(\"oss\")) return false;\n  const [major = 0, minor = 0] = parsed.version;\n  return major > 5 || (major === 5 && minor >= 4);\n}\n\n/** Return the Databricks inference protocol required by a model. */\nexport function modelServingApi(name: string): \"chat\" | \"responses\" {\n  return isResponsesOnly(name) ? \"responses\" : \"chat\";\n}\n\n/** Return the Chat Completions effort required when function tools are present. */\nexport function chatToolReasoningEffort(name: string): ReasoningEffort | undefined {\n  const parsed = parseModelName(name);\n  if (!parsed || parsed.family !== \"gpt\") return undefined;\n  const [major = 0, minor = 0] = parsed.version;\n  return major === 5 && minor === 6 ? \"none\" : undefined;\n}\n\n/** Derive provider-specific model names from a Databricks model identity. */\nexport function modelServiceNames(name: string): Record<string, string> {\n  const parsed = parseModelName(name);\n  if (!parsed) return {};\n  const version = parsed.version.join(\".\");\n  const suffix = parsed.model.length ? `-${parsed.model.join(\"-\")}` : \"\";\n  switch (parsed.family) {\n    case \"gpt\":\n      return parsed.model.includes(\"oss\") ? {} : { openai: `gpt-${version}${suffix}` };\n    case \"claude\": {\n      const [variant, ...rest] = parsed.model;\n      return variant\n        ? { anthropic: `claude-${variant}-${version}${rest.length ? `-${rest.join(\"-\")}` : \"\"}` }\n        : {};\n    }\n    case \"gemini\":\n    case \"gemma\":\n      return { google: `${parsed.family}-${version}${suffix}` };\n    case \"glm\":\n      return { zhipu: `glm-${version}${suffix}` };\n    case \"grok\":\n      return { xai: `grok-${version}${suffix}` };\n    case \"llama\":\n      return { meta: `llama-${version}${suffix}` };\n    case \"qwen\":\n      return { alibaba: `qwen${version}${suffix}` };\n    case \"deepseek\":\n      return { deepseek: `deepseek-v${parsed.version[0] ?? \"\"}${suffix}` };\n    case \"kimi\":\n      return { moonshot: `kimi-k${parsed.version[0] ?? \"\"}${suffix}` };\n    default:\n      return {};\n  }\n}\n\nfunction parseModelName(name: string): ParsedModelName | undefined {\n  const tokens = name.toLowerCase().match(/[a-z0-9]+/g) ?? [];\n  let familyIndex = -1;\n  let family: ParsedModelName[\"family\"] | undefined;\n  for (let index = 0; index < tokens.length; index += 1) {\n    const token = tokens[index]!;\n    const compactQwen = /^qwen(\\d+)$/.exec(token);\n    if (compactQwen) {\n      familyIndex = index;\n      family = \"qwen\";\n      break;\n    }\n    if (FAMILIES.includes(token as ParsedModelName[\"family\"])) {\n      familyIndex = index;\n      family = token as ParsedModelName[\"family\"];\n      break;\n    }\n  }\n  if (!family || familyIndex < 0) return undefined;\n  const remainder = tokens.slice(familyIndex + 1);\n  const numeric = (value: string) => /^\\d+$/.test(value);\n  let versionStart = remainder.findIndex(numeric);\n  if (family === \"qwen\" && /^qwen\\d+$/.test(tokens[familyIndex]!)) {\n    versionStart = 0;\n    remainder.unshift(tokens[familyIndex]!.slice(4));\n  }\n  if (family === \"deepseek\") {\n    const prefixed = remainder.findIndex((value) => /^v\\d+$/.test(value));\n    if (prefixed >= 0) remainder[prefixed] = remainder[prefixed]!.slice(1);\n    versionStart = remainder.findIndex(numeric);\n  }\n  if (family === \"kimi\") {\n    const prefixed = remainder.findIndex((value) => /^k\\d+$/.test(value));\n    if (prefixed >= 0) remainder[prefixed] = remainder[prefixed]!.slice(1);\n    versionStart = remainder.findIndex(numeric);\n  }\n  if (versionStart < 0) return { family, version: [], model: remainder };\n  const version: number[] = [];\n  let cursor = versionStart;\n  while (cursor < remainder.length && version.length < 2 && numeric(remainder[cursor]!)) {\n    version.push(Number(remainder[cursor]));\n    cursor += 1;\n  }\n  return {\n    family,\n    version,\n    model: [...remainder.slice(0, versionStart), ...remainder.slice(cursor)],\n  };\n}\n"]}

package/lib/src/python.d.ts

@@ -0,0 +1,2 @@
+/** Portable entry point used by generated Python bindings. */
+export { createModelClient } from "./model-client.ts";

package/lib/src/python.js

@@ -0,0 +1,3 @@
+/** Portable entry point used by generated Python bindings. */
+export { createModelClient } from "./model-client.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHl0aG9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3B5dGhvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSw4REFBOEQ7QUFDOUQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sbUJBQW1CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiogUG9ydGFibGUgZW50cnkgcG9pbnQgdXNlZCBieSBnZW5lcmF0ZWQgUHl0aG9uIGJpbmRpbmdzLiAqL1xuZXhwb3J0IHsgY3JlYXRlTW9kZWxDbGllbnQgfSBmcm9tIFwiLi9tb2RlbC1jbGllbnQudHNcIjtcbiJdfQ==

package/lib/src/resolve.d.ts

@@ -1,159 +1,26 @@
 /**
- * Workspace-aware model selection.
- *
- * Given a caller's intent - a search string, a capability {@link ModelClass}
- * ceiling, both, or nothing - the toolkit returns matching endpoints ranked by
- * match quality then class, or collapses to the single best id the workspace
- * actually has, degrading from "best in range" down to the static fallback
- * floor. Selection is chat-only: embedding endpoints surface only when
- * `modelClass` is explicitly {@link ModelClass.Embedding}.
- *
- * Two shapes of selection, each in a pure form (over an endpoint list the
- * caller already holds) and an I/O wrapper (that lists `/serving-endpoints`
- * first): ranking, which returns a match- then class-ordered list, and
- * single-selection, which collapses to one id plus how it was reached and
- * layers the operator-pinned fallback / static-floor safety net on top. A chat
- * `modelClass` acts as a ceiling: that band and the less-capable chat bands
- * below it are eligible (see {@link classesAtOrBelow}), so a `chat-balanced`
- * ask can fall to `chat-fast` but never escalate to `chat-thinking`.
+ * Workspace-aware model selection wrappers.
  *
  * @module
  */
-import { model, type ModelQuery, type RankedModel, type ServingEndpointSummary } from "@dbx-tools/shared-model";
+import type { ModelQuery, RankedModel, ServingEndpointSummary } from "@dbx-tools/shared-model";
+import { type ResolveModelInput, type ResolvedModelSelection } from "./_selection.ts";
 import { type ResolvedModel, type ResolveModelOptions, type WorkspaceClientLike } from "./model-catalog.ts";
-type ModelClass = model.ModelClass;
-/** Caller intent passed to {@link resolveModel}. */
-export interface ResolveModelInput {
-    /**
-     * Explicit model id / loose name (per-request override, agent / plugin
-     * default, or env var). When set it wins over `modelClass` and `fallbacks`.
-     */
-    explicit?: string;
-    /**
-     * Fuzzy-match an `explicit` name against the live catalogue so loose names
-     * like `"claude sonnet"` resolve. Default `true`. When `false` the explicit
-     * input is returned verbatim (Databricks surfaces the canonical 404 if it
-     * doesn't exist).
-     */
-    fuzzy?: boolean;
-    /** Rust fuzzy-distance threshold forwarded to the search match. */
-    threshold?: number;
-    /** Require a model that supports a complete function-tool round-trip. */
-    requiresTools?: boolean;
-    /**
-     * Chat capability class to resolve when no `explicit` id is given. The live
-     * catalogue is classified by its Foundation Model API scores and the top
-     * available model in the class (and the chat bands below it) wins, falling
-     * back to the class's small static list.
-     */
-    modelClass?: ModelClass;
-    /**
-     * Operator-supplied fallback ids tried *first* in the no-explicit, no-class
-     * path (e.g. a regulated workspace pinned to an approved subset), ahead of
-     * the auto-classified catalogue.
-     */
-    fallbacks?: readonly string[];
-    /**
-     * Refuse the static offline floor when the live catalogue has no match.
-     * Use for unpinned defaults that must always name a currently available
-     * endpoint.
-     */
-    liveOnly?: boolean;
-}
-/** Outcome of {@link resolveModel}: the chosen id plus how it was reached. */
-export interface ResolvedModelSelection {
-    modelId: string;
-    source: "explicit" | "fuzzy-match" | "class" | "fallback";
-}
-/** Intent + catalogue knobs passed to {@link selectModel}. */
+export { lookupModels, rankModelId, resolveModel } from "./_selection.ts";
+export type { ResolveModelInput, ResolvedModelSelection } from "./_selection.ts";
+/** Intent plus catalogue cache controls passed to {@link selectModel}. */
 export interface SelectModelInput extends ResolveModelInput {
-    /** TTL override for the cached `/serving-endpoints` listing, in ms. */
     ttlMs?: number;
-    /** Trusted opaque identity of the credential used by the workspace client. */
     cacheIdentity?: string;
 }
-/** TTL override merged into a {@link ModelQuery} for {@link searchModels}. */
+/** Query plus catalogue cache controls passed to {@link searchModels}. */
 export interface SearchModelsInput extends ModelQuery {
-    /** TTL override for the cached `/serving-endpoints` listing, in ms. */
     ttlMs?: number;
-    /** Trusted opaque identity of the credential used by the workspace client. */
     cacheIdentity?: string;
 }
-/**
- * Rank the live catalogue against a {@link ModelQuery}, best-first.
- *
- * Rust owns classification, fuzzy scoring, family-version ordering, preferred
- * variants, class ceilings, tool filtering, and result limiting. Node retains
- * the caller's endpoint objects so fields outside the ranking contract remain
- * available unchanged.
- */
-export declare function lookupModels(endpoints: readonly ServingEndpointSummary[], query?: ModelQuery): RankedModel[];
-/**
- * Collapse {@link lookupModels} to a single id: the closest endpoint to `search`
- * in a catalogue snapshot, or the input verbatim when nothing scores within the
- * threshold.
- *
- * The ranked counterpart to {@link resolveModelId}: equal
- * match scores are broken by class and then within-class version, so a loose
- * `"opus"` prefers `opus-5` over `opus-4-7` instead of picking whichever
- * sibling appeared first. Returning the input unmatched (rather
- * than a near neighbour) is deliberate - a deliberate endpoint id is never
- * silently rewritten, and Databricks surfaces a clean 404.
- */
-export declare function rankModelId(endpoints: readonly ServingEndpointSummary[], search: string, options?: ResolveModelOptions): ResolvedModel;
-/**
- * {@link rankModelId} against a catalogue the caller may be holding stale:
- * match the loaded snapshot, and on a miss reload once with `force` and match
- * again. That way a model deployed after the catalogue was cached still
- * resolves on first use, without a restart and without giving up caching.
- *
- * The catalogue arrives as a loader rather than a client so the caller keeps
- * ownership of *how* it is cached - {@link listServingEndpoints} and its
- * `CacheManager`, a plain process-lifetime field in a CLI, or a test double.
- * Only one reload is attempted: a genuinely unknown name should fail fast
- * rather than re-list on every request.
- *
- * @param load - Returns the catalogue; `force` asks it to bypass its cache.
- */
+/** Resolve against a potentially stale catalogue, refreshing once on a miss. */
 export declare function rankModelIdLive(load: (force: boolean) => Promise<readonly ServingEndpointSummary[]>, search: string, options?: ResolveModelOptions): Promise<ResolvedModel>;
-/**
- * Rank a workspace's catalogue in one call: list its `/serving-endpoints`
- * (cached) and run {@link lookupModels} over the result. The list counterpart to
- * {@link selectModel}, for a consumer that wants the full ranked set (a model
- * picker, a CLI) rather than a single id. Catalogue fetches fail loud: network
- * / auth errors propagate so the caller sees the real SDK message.
- *
- * @param host - Workspace host used as the cache key. Pass the value resolved
- *   from `client.config.getHost()`.
- */
+/** List and rank a workspace model catalogue. */
 export declare function searchModels(client: WorkspaceClientLike, host: string, input?: SearchModelsInput): Promise<RankedModel[]>;
-/**
- * Resolve a model id for a workspace in one call: list its `/serving-endpoints`
- * (cached) and run {@link resolveModel} over the result. This is the entry
- * point for any consumer that holds a `WorkspaceClient` and just wants a usable
- * model name - a Lakeflow job, a one-off script, or the Mastra plugin alike.
- *
- * Cheap exit: when an `explicit` name is given, `fuzzy` is off, and tool
- * capability is not required, the catalogue is never fetched. Catalogue
- * fetches otherwise fail loud: network / auth errors propagate so the caller
- * sees the real SDK message instead of a silent fallback.
- *
- * @param host - Workspace host used as the cache key. Pass the value resolved
- *   from `client.config.getHost()`.
- */
+/** List a workspace catalogue and resolve one model. */
 export declare function selectModel(client: WorkspaceClientLike, host: string, input?: SelectModelInput): Promise<ResolvedModelSelection>;
-/**
- * Resolve a single model id from the live catalogue and caller intent,
- * delegating the live selection to {@link lookupModels} with `limit: 1`.
- *
- * 1. **Explicit ask**: with `fuzzy` off, returned verbatim; otherwise
- *    fuzzy-ranked within the (optional) class ceiling and the best taken,
- *    falling back to the input verbatim when nothing matches.
- * 2. **No explicit ask**: an operator-pinned `fallback` that exists in the live
- *    catalogue wins first. A class request ranks within that ceiling. A
- *    general request prefers the highest-ranked live GPT, then any ranked live
- *    chat model. The static {@link FALLBACK_MODEL_IDS} floor is used only when
- *    the catalogue yields nothing in range.
- */
-export declare function resolveModel(endpoints: readonly ServingEndpointSummary[], input?: ResolveModelInput): ResolvedModelSelection;
-export {};