@dbx-tools/model 0.9.32 → 0.9.37

package/lib/src/serving-wire.js

@@ -0,0 +1,211 @@
+/**
+ * Framework-neutral repairs for OpenAI Chat traffic sent through Databricks
+ * Model Serving.
+ *
+ * @module
+ */
+import { json, stringUtils } from "@dbx-tools/shared-core";
+import { openaiChat } from "@dbx-tools/shared-model";
+import { chatToolReasoningEffort } from "./policy.js";
+const REASONING_PART_TYPES = new Set([
+    "reasoning",
+    "thinking",
+    "redacted_thinking",
+]);
+/** Sanitize a serialized Chat Completions request when provider quirks require it. */
+export function rewriteServingBody(body) {
+    const parsed = json.parseRecord(body);
+    if (!parsed)
+        return body;
+    let changed = openaiChat.stripUnsupportedChatFields(parsed).length > 0 ||
+        applyToolReasoningCompatibility(parsed);
+    if (Array.isArray(parsed.messages)) {
+        const messages = parsed.messages;
+        const stripped = stripReasoningFromServingMessages(messages);
+        const repaired = repairAssistantPrefill(messages);
+        changed = changed || stripped || repaired;
+    }
+    return changed ? JSON.stringify(parsed) : body;
+}
+/** Read and sanitize a Chat Completions request without retaining stale byte headers. */
+export async function rewriteServingRequest(input, init) {
+    const request = new Request(input, init);
+    const body = await request.clone().text();
+    const rewritten = rewriteServingBody(body);
+    if (rewritten === body)
+        return { input, init, body };
+    const headers = new Headers(request.headers);
+    headers.delete("content-length");
+    headers.delete("content-encoding");
+    return {
+        input: new Request(request, { body: rewritten, headers }),
+        init: undefined,
+        body: rewritten,
+    };
+}
+/** Normalize Chat Completions reasoning for GPT tool calls. */
+export function applyToolReasoningCompatibility(body) {
+    if (!Array.isArray(body.tools) || body.tools.length === 0)
+        return false;
+    const model = stringUtils.trimToNull(body.model);
+    if (!model || chatToolReasoningEffort(model) !== "none")
+        return false;
+    if (body.reasoning_effort === "none")
+        return false;
+    body.reasoning_effort = "none";
+    return true;
+}
+/** Remove provider reasoning blocks that cannot be replayed safely. */
+export function stripReasoningFromServingMessages(messages) {
+    let changed = false;
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const message = messages[index];
+        if (!message)
+            continue;
+        if (message.role === "reasoning") {
+            messages.splice(index, 1);
+            changed = true;
+            continue;
+        }
+        if (message.reasoning !== undefined) {
+            delete message.reasoning;
+            changed = true;
+        }
+        if (message.reasoning_content !== undefined) {
+            delete message.reasoning_content;
+            changed = true;
+        }
+        const parts = openaiChat.chatContentParts(message.content);
+        if (!parts)
+            continue;
+        const filtered = parts.filter((part) => {
+            const type = part?.type;
+            if (typeof type !== "string" || !REASONING_PART_TYPES.has(type))
+                return true;
+            changed = true;
+            return false;
+        });
+        if (filtered.length !== parts.length)
+            message.content = filtered;
+        const hasToolCalls = Array.isArray(message.tool_calls) && message.tool_calls.length > 0;
+        if (message.role === "assistant" && !hasToolCalls && isEmptyServingContent(message.content)) {
+            messages.splice(index, 1);
+            changed = true;
+        }
+    }
+    return changed;
+}
+/** Fold a trailing assistant prefill back into its preceding tool-call turn. */
+export function repairAssistantPrefill(messages) {
+    if (messages.length < 2)
+        return false;
+    const last = messages[messages.length - 1];
+    if (!last || last.role !== "assistant" || (last.tool_calls && last.tool_calls.length > 0)) {
+        return false;
+    }
+    let index = messages.length - 2;
+    while (index >= 0 && messages[index]?.role === "tool")
+        index--;
+    const opener = messages[index];
+    if (!opener ||
+        opener.role !== "assistant" ||
+        !opener.tool_calls ||
+        opener.tool_calls.length === 0) {
+        return false;
+    }
+    opener.content = [
+        stringUtils.trimToNull(textFromServingContent(opener.content)),
+        stringUtils.trimToNull(textFromServingContent(last.content)),
+    ]
+        .filter((value) => value !== null)
+        .join("\n\n");
+    messages.pop();
+    return true;
+}
+/** Normalize array-valued content in a non-streaming Chat Completions response. */
+export function rewriteServingResponseBody(body) {
+    const parsed = json.parseRecord(body);
+    if (!parsed)
+        return body;
+    return flattenChoiceMessageContent(parsed) ? JSON.stringify(parsed) : body;
+}
+/** Normalize array-valued content in an SSE stream without buffering the stream. */
+export function rewriteServingResponseStream(body) {
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    let buffer = "";
+    return body.pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            buffer += decoder.decode(chunk, { stream: true });
+            let newline = buffer.indexOf("\n");
+            while (newline >= 0) {
+                const line = buffer.slice(0, newline + 1);
+                buffer = buffer.slice(newline + 1);
+                controller.enqueue(encoder.encode(rewriteServingResponseStreamLine(line)));
+                newline = buffer.indexOf("\n");
+            }
+        },
+        flush(controller) {
+            buffer += decoder.decode();
+            if (buffer)
+                controller.enqueue(encoder.encode(rewriteServingResponseStreamLine(buffer)));
+        },
+    }));
+}
+/** Flatten Chat Completions `choices[].message.content` arrays to strings. */
+export function flattenChoiceMessageContent(payload) {
+    return flattenChoiceContent(payload, "message");
+}
+/** Flatten Chat Completions `choices[].delta.content` arrays to strings. */
+export function flattenChoiceDeltaContent(payload) {
+    return flattenChoiceContent(payload, "delta");
+}
+function rewriteServingResponseStreamLine(line) {
+    const lineEnding = line.endsWith("\r\n") ? "\r\n" : line.endsWith("\n") ? "\n" : "";
+    const content = lineEnding ? line.slice(0, -lineEnding.length) : line;
+    const match = /^(data:\s*)(.*)$/.exec(content);
+    if (!match || match[2] === "[DONE]")
+        return line;
+    const parsed = json.parseRecord(match[2]);
+    if (!parsed || !flattenChoiceDeltaContent(parsed))
+        return line;
+    return `${match[1]}${JSON.stringify(parsed)}${lineEnding}`;
+}
+function flattenChoiceContent(payload, field) {
+    if (!Array.isArray(payload.choices))
+        return false;
+    let changed = false;
+    for (const choice of payload.choices) {
+        if (!choice || typeof choice !== "object")
+            continue;
+        const container = choice[field];
+        if (!container || typeof container !== "object")
+            continue;
+        const target = container;
+        const parts = openaiChat.chatContentParts(target.content);
+        if (!parts)
+            continue;
+        target.content = openaiChat.chatContentToText(parts, { types: ["text"] });
+        changed = true;
+    }
+    return changed;
+}
+function textFromServingContent(content) {
+    return openaiChat.chatContentToText(content, { separator: "\n\n", types: ["text"] });
+}
+function isEmptyServingContent(content) {
+    if (content === undefined)
+        return true;
+    if (typeof content === "string")
+        return content.trim().length === 0;
+    const parts = openaiChat.chatContentParts(content);
+    if (!parts)
+        return true;
+    return parts.every((part) => {
+        if (part?.type === "text") {
+            return typeof part.text !== "string" || part.text.trim().length === 0;
+        }
+        return false;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serving-wire.js","sourceRoot":"","sources":["../../src/serving-wire.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAmC,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAEtF,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAgBtD,MAAM,oBAAoB,GAAwB,IAAI,GAAG,CAAC;IACxD,WAAW;IACX,UAAU;IACV,mBAAmB;CACpB,CAAC,CAAC;AAEH,sFAAsF;AACtF,MAAM,UAAU,kBAAkB,CAAC,IAAY;IAC7C,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IACtC,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IACzB,IAAI,OAAO,GACT,UAAU,CAAC,0BAA0B,CAAC,MAAM,CAAC,CAAC,MAAM,GAAG,CAAC;QACxD,+BAA+B,CAAC,MAAM,CAAC,CAAC;IAC1C,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;QACnC,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAgC,CAAC;QACzD,MAAM,QAAQ,GAAG,iCAAiC,CAAC,QAAQ,CAAC,CAAC;QAC7D,MAAM,QAAQ,GAAG,sBAAsB,CAAC,QAAQ,CAAC,CAAC;QAClD,OAAO,GAAG,OAAO,IAAI,QAAQ,IAAI,QAAQ,CAAC;IAC5C,CAAC;IACD,OAAO,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AACjD,CAAC;AAED,yFAAyF;AACzF,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,KAAkC,EAClC,IAAkC;IAElC,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IACzC,MAAM,IAAI,GAAG,MAAM,OAAO,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC;IAC1C,MAAM,SAAS,GAAG,kBAAkB,CAAC,IAAI,CAAC,CAAC;IAC3C,IAAI,SAAS,KAAK,IAAI;QAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IACrD,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7C,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;IACjC,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC;IACnC,OAAO;QACL,KAAK,EAAE,IAAI,OAAO,CAAC,OAAO,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC;QACzD,IAAI,EAAE,SAAS;QACf,IAAI,EAAE,SAAS;KAChB,CAAC;AACJ,CAAC;AAED,+DAA+D;AAC/D,MAAM,UAAU,+BAA+B,CAAC,IAA6B;IAC3E,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACxE,MAAM,KAAK,GAAG,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACjD,IAAI,CAAC,KAAK,IAAI,uBAAuB,CAAC,KAAK,CAAC,KAAK,MAAM;QAAE,OAAO,KAAK,CAAC;IACtE,IAAI,IAAI,CAAC,gBAAgB,KAAK,MAAM;QAAE,OAAO,KAAK,CAAC;IACnD,IAAI,CAAC,gBAAgB,GAAG,MAAM,CAAC;IAC/B,OAAO,IAAI,CAAC;AACd,CAAC;AAED,uEAAuE;AACvE,MAAM,UAAU,iCAAiC,CAAC,QAA8B;IAC9E,IAAI,OAAO,GAAG,KAAK,CAAC;IACpB,KAAK,IAAI,KAAK,GAAG,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC;QAC1D,MAAM,OAAO,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;QAChC,IAAI,CAAC,OAAO;YAAE,SAAS;QACvB,IAAI,OAAO,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;YACjC,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YAC1B,OAAO,GAAG,IAAI,CAAC;YACf,SAAS;QACX,CAAC;QACD,IAAI,OAAO,CAAC,SAAS,KAAK,SAAS,EAAE,CAAC;YACpC,OAAO,OAAO,CAAC,SAAS,CAAC;YACzB,OAAO,GAAG,IAAI,CAAC;QACjB,CAAC;QACD,IAAI,OAAO,CAAC,iBAAiB,KAAK,SAAS,EAAE,CAAC;YAC5C,OAAO,OAAO,CAAC,iBAAiB,CAAC;YACjC,OAAO,GAAG,IAAI,CAAC;QACjB,CAAC;QACD,MAAM,KAAK,GAAG,UAAU,CAAC,gBAAgB,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QAC3D,IAAI,CAAC,KAAK;YAAE,SAAS;QACrB,MAAM,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE;YACrC,MAAM,IAAI,GAAG,IAAI,EAAE,IAAI,CAAC;YACxB,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,IAAI,CAAC;gBAAE,OAAO,IAAI,CAAC;YAC7E,OAAO,GAAG,IAAI,CAAC;YACf,OAAO,KAAK,CAAC;QACf,CAAC,CAAC,CAAC;QACH,IAAI,QAAQ,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM;YAAE,OAAO,CAAC,OAAO,GAAG,QAAQ,CAAC;QACjE,MAAM,YAAY,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,OAAO,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC;QACxF,IAAI,OAAO,CAAC,IAAI,KAAK,WAAW,IAAI,CAAC,YAAY,IAAI,qBAAqB,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YAC5F,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YAC1B,OAAO,GAAG,IAAI,CAAC;QACjB,CAAC;IACH,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,gFAAgF;AAChF,MAAM,UAAU,sBAAsB,CAAC,QAA8B;IACnE,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,KAAK,CAAC;IACtC,MAAM,IAAI,GAAG,QAAQ,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAC3C,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,KAAK,WAAW,IAAI,CAAC,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC;QAC1F,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,KAAK,GAAG,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC;IAChC,OAAO,KAAK,IAAI,CAAC,IAAI,QAAQ,CAAC,KAAK,CAAC,EAAE,IAAI,KAAK,MAAM;QAAE,KAAK,EAAE,CAAC;IAC/D,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC/B,IACE,CAAC,MAAM;QACP,MAAM,CAAC,IAAI,KAAK,WAAW;QAC3B,CAAC,MAAM,CAAC,UAAU;QAClB,MAAM,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,EAC9B,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,CAAC,OAAO,GAAG;QACf,WAAW,CAAC,UAAU,CAAC,sBAAsB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAC9D,WAAW,CAAC,UAAU,CAAC,sBAAsB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;KAC7D;SACE,MAAM,CAAC,CAAC,KAAK,EAAmB,EAAE,CAAC,KAAK,KAAK,IAAI,CAAC;SAClD,IAAI,CAAC,MAAM,CAAC,CAAC;IAChB,QAAQ,CAAC,GAAG,EAAE,CAAC;IACf,OAAO,IAAI,CAAC;AACd,CAAC;AAED,mFAAmF;AACnF,MAAM,UAAU,0BAA0B,CAAC,IAAY;IACrD,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IACtC,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IACzB,OAAO,2BAA2B,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AAC7E,CAAC;AAED,oFAAoF;AACpF,MAAM,UAAU,4BAA4B,CAC1C,IAAgC;IAEhC,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC;IAClC,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC;IAClC,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,OAAO,IAAI,CAAC,WAAW,CACrB,IAAI,eAAe,CAAyB;QAC1C,SAAS,CAAC,KAAK,EAAE,UAAU;YACzB,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;YAClD,IAAI,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YACnC,OAAO,OAAO,IAAI,CAAC,EAAE,CAAC;gBACpB,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC,CAAC;gBAC1C,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC;gBACnC,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,gCAAgC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBAC3E,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YACjC,CAAC;QACH,CAAC;QACD,KAAK,CAAC,UAAU;YACd,MAAM,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;YAC3B,IAAI,MAAM;gBAAE,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,gCAAgC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QAC3F,CAAC;KACF,CAAC,CACH,CAAC;AACJ,CAAC;AAED,8EAA8E;AAC9E,MAAM,UAAU,2BAA2B,CAAC,OAAgC;IAC1E,OAAO,oBAAoB,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;AAClD,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,yBAAyB,CAAC,OAAgC;IACxE,OAAO,oBAAoB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;AAChD,CAAC;AAED,SAAS,gCAAgC,CAAC,IAAY;IACpD,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;IACpF,MAAM,OAAO,GAAG,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IACtE,MAAM,KAAK,GAAG,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC/C,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IACjD,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1C,IAAI,CAAC,MAAM,IAAI,CAAC,yBAAyB,CAAC,MAAM,CAAC;QAAE,OAAO,IAAI,CAAC;IAC/D,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,UAAU,EAAE,CAAC;AAC7D,CAAC;AAED,SAAS,oBAAoB,CAC3B,OAAgC,EAChC,KAA0B;IAE1B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC;QAAE,OAAO,KAAK,CAAC;IAClD,IAAI,OAAO,GAAG,KAAK,CAAC;IACpB,KAAK,MAAM,MAAM,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;QACrC,IAAI,CAAC,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ;YAAE,SAAS;QACpD,MAAM,SAAS,GAAI,MAAkC,CAAC,KAAK,CAAC,CAAC;QAC7D,IAAI,CAAC,SAAS,IAAI,OAAO,SAAS,KAAK,QAAQ;YAAE,SAAS;QAC1D,MAAM,MAAM,GAAG,SAAkC,CAAC;QAClD,MAAM,KAAK,GAAG,UAAU,CAAC,gBAAgB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAC1D,IAAI,CAAC,KAAK;YAAE,SAAS;QACrB,MAAM,CAAC,OAAO,GAAG,UAAU,CAAC,iBAAiB,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QAC1E,OAAO,GAAG,IAAI,CAAC;IACjB,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,SAAS,sBAAsB,CAAC,OAAsC;IACpE,OAAO,UAAU,CAAC,iBAAiB,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AACvF,CAAC;AAED,SAAS,qBAAqB,CAAC,OAAsC;IACnE,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IACvC,IAAI,OAAO,OAAO,KAAK,QAAQ;QAAE,OAAO,OAAO,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,CAAC;IACpE,MAAM,KAAK,GAAG,UAAU,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;IACnD,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAC;IACxB,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE;QAC1B,IAAI,IAAI,EAAE,IAAI,KAAK,MAAM,EAAE,CAAC;YAC1B,OAAO,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,CAAC;QACxE,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["/**\n * Framework-neutral repairs for OpenAI Chat traffic sent through Databricks\n * Model Serving.\n *\n * @module\n */\n\nimport { json, stringUtils } from \"@dbx-tools/shared-core\";\nimport { type ChatMessage, type ChatRole, openaiChat } from \"@dbx-tools/shared-model\";\n\nimport { chatToolReasoningEffort } from \"./policy.ts\";\n\n/** Chat message plus provider reasoning fields emitted by Databricks models. */\nexport interface ServingChatMessage extends ChatMessage {\n  role: ChatRole | \"reasoning\";\n  reasoning?: unknown;\n  reasoning_content?: unknown;\n}\n\n/** Prepared fetch arguments and the sanitized request body. */\nexport interface RewrittenServingRequest {\n  input: Parameters<typeof fetch>[0];\n  init: Parameters<typeof fetch>[1];\n  body: string;\n}\n\nconst REASONING_PART_TYPES: ReadonlySet<string> = new Set([\n  \"reasoning\",\n  \"thinking\",\n  \"redacted_thinking\",\n]);\n\n/** Sanitize a serialized Chat Completions request when provider quirks require it. */\nexport function rewriteServingBody(body: string): string {\n  const parsed = json.parseRecord(body);\n  if (!parsed) return body;\n  let changed =\n    openaiChat.stripUnsupportedChatFields(parsed).length > 0 ||\n    applyToolReasoningCompatibility(parsed);\n  if (Array.isArray(parsed.messages)) {\n    const messages = parsed.messages as ServingChatMessage[];\n    const stripped = stripReasoningFromServingMessages(messages);\n    const repaired = repairAssistantPrefill(messages);\n    changed = changed || stripped || repaired;\n  }\n  return changed ? JSON.stringify(parsed) : body;\n}\n\n/** Read and sanitize a Chat Completions request without retaining stale byte headers. */\nexport async function rewriteServingRequest(\n  input: Parameters<typeof fetch>[0],\n  init?: Parameters<typeof fetch>[1],\n): Promise<RewrittenServingRequest> {\n  const request = new Request(input, init);\n  const body = await request.clone().text();\n  const rewritten = rewriteServingBody(body);\n  if (rewritten === body) return { input, init, body };\n  const headers = new Headers(request.headers);\n  headers.delete(\"content-length\");\n  headers.delete(\"content-encoding\");\n  return {\n    input: new Request(request, { body: rewritten, headers }),\n    init: undefined,\n    body: rewritten,\n  };\n}\n\n/** Normalize Chat Completions reasoning for GPT tool calls. */\nexport function applyToolReasoningCompatibility(body: Record<string, unknown>): boolean {\n  if (!Array.isArray(body.tools) || body.tools.length === 0) return false;\n  const model = stringUtils.trimToNull(body.model);\n  if (!model || chatToolReasoningEffort(model) !== \"none\") return false;\n  if (body.reasoning_effort === \"none\") return false;\n  body.reasoning_effort = \"none\";\n  return true;\n}\n\n/** Remove provider reasoning blocks that cannot be replayed safely. */\nexport function stripReasoningFromServingMessages(messages: ServingChatMessage[]): boolean {\n  let changed = false;\n  for (let index = messages.length - 1; index >= 0; index--) {\n    const message = messages[index];\n    if (!message) continue;\n    if (message.role === \"reasoning\") {\n      messages.splice(index, 1);\n      changed = true;\n      continue;\n    }\n    if (message.reasoning !== undefined) {\n      delete message.reasoning;\n      changed = true;\n    }\n    if (message.reasoning_content !== undefined) {\n      delete message.reasoning_content;\n      changed = true;\n    }\n    const parts = openaiChat.chatContentParts(message.content);\n    if (!parts) continue;\n    const filtered = parts.filter((part) => {\n      const type = part?.type;\n      if (typeof type !== \"string\" || !REASONING_PART_TYPES.has(type)) return true;\n      changed = true;\n      return false;\n    });\n    if (filtered.length !== parts.length) message.content = filtered;\n    const hasToolCalls = Array.isArray(message.tool_calls) && message.tool_calls.length > 0;\n    if (message.role === \"assistant\" && !hasToolCalls && isEmptyServingContent(message.content)) {\n      messages.splice(index, 1);\n      changed = true;\n    }\n  }\n  return changed;\n}\n\n/** Fold a trailing assistant prefill back into its preceding tool-call turn. */\nexport function repairAssistantPrefill(messages: ServingChatMessage[]): boolean {\n  if (messages.length < 2) return false;\n  const last = messages[messages.length - 1];\n  if (!last || last.role !== \"assistant\" || (last.tool_calls && last.tool_calls.length > 0)) {\n    return false;\n  }\n  let index = messages.length - 2;\n  while (index >= 0 && messages[index]?.role === \"tool\") index--;\n  const opener = messages[index];\n  if (\n    !opener ||\n    opener.role !== \"assistant\" ||\n    !opener.tool_calls ||\n    opener.tool_calls.length === 0\n  ) {\n    return false;\n  }\n  opener.content = [\n    stringUtils.trimToNull(textFromServingContent(opener.content)),\n    stringUtils.trimToNull(textFromServingContent(last.content)),\n  ]\n    .filter((value): value is string => value !== null)\n    .join(\"\\n\\n\");\n  messages.pop();\n  return true;\n}\n\n/** Normalize array-valued content in a non-streaming Chat Completions response. */\nexport function rewriteServingResponseBody(body: string): string {\n  const parsed = json.parseRecord(body);\n  if (!parsed) return body;\n  return flattenChoiceMessageContent(parsed) ? JSON.stringify(parsed) : body;\n}\n\n/** Normalize array-valued content in an SSE stream without buffering the stream. */\nexport function rewriteServingResponseStream(\n  body: ReadableStream<Uint8Array>,\n): ReadableStream<Uint8Array> {\n  const decoder = new TextDecoder();\n  const encoder = new TextEncoder();\n  let buffer = \"\";\n  return body.pipeThrough(\n    new TransformStream<Uint8Array, Uint8Array>({\n      transform(chunk, controller) {\n        buffer += decoder.decode(chunk, { stream: true });\n        let newline = buffer.indexOf(\"\\n\");\n        while (newline >= 0) {\n          const line = buffer.slice(0, newline + 1);\n          buffer = buffer.slice(newline + 1);\n          controller.enqueue(encoder.encode(rewriteServingResponseStreamLine(line)));\n          newline = buffer.indexOf(\"\\n\");\n        }\n      },\n      flush(controller) {\n        buffer += decoder.decode();\n        if (buffer) controller.enqueue(encoder.encode(rewriteServingResponseStreamLine(buffer)));\n      },\n    }),\n  );\n}\n\n/** Flatten Chat Completions `choices[].message.content` arrays to strings. */\nexport function flattenChoiceMessageContent(payload: Record<string, unknown>): boolean {\n  return flattenChoiceContent(payload, \"message\");\n}\n\n/** Flatten Chat Completions `choices[].delta.content` arrays to strings. */\nexport function flattenChoiceDeltaContent(payload: Record<string, unknown>): boolean {\n  return flattenChoiceContent(payload, \"delta\");\n}\n\nfunction rewriteServingResponseStreamLine(line: string): string {\n  const lineEnding = line.endsWith(\"\\r\\n\") ? \"\\r\\n\" : line.endsWith(\"\\n\") ? \"\\n\" : \"\";\n  const content = lineEnding ? line.slice(0, -lineEnding.length) : line;\n  const match = /^(data:\\s*)(.*)$/.exec(content);\n  if (!match || match[2] === \"[DONE]\") return line;\n  const parsed = json.parseRecord(match[2]);\n  if (!parsed || !flattenChoiceDeltaContent(parsed)) return line;\n  return `${match[1]}${JSON.stringify(parsed)}${lineEnding}`;\n}\n\nfunction flattenChoiceContent(\n  payload: Record<string, unknown>,\n  field: \"message\" | \"delta\",\n): boolean {\n  if (!Array.isArray(payload.choices)) return false;\n  let changed = false;\n  for (const choice of payload.choices) {\n    if (!choice || typeof choice !== \"object\") continue;\n    const container = (choice as Record<string, unknown>)[field];\n    if (!container || typeof container !== \"object\") continue;\n    const target = container as { content?: unknown };\n    const parts = openaiChat.chatContentParts(target.content);\n    if (!parts) continue;\n    target.content = openaiChat.chatContentToText(parts, { types: [\"text\"] });\n    changed = true;\n  }\n  return changed;\n}\n\nfunction textFromServingContent(content: ServingChatMessage[\"content\"]): string {\n  return openaiChat.chatContentToText(content, { separator: \"\\n\\n\", types: [\"text\"] });\n}\n\nfunction isEmptyServingContent(content: ServingChatMessage[\"content\"]): boolean {\n  if (content === undefined) return true;\n  if (typeof content === \"string\") return content.trim().length === 0;\n  const parts = openaiChat.chatContentParts(content);\n  if (!parts) return true;\n  return parts.every((part) => {\n    if (part?.type === \"text\") {\n      return typeof part.text !== \"string\" || part.text.trim().length === 0;\n    }\n    return false;\n  });\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/_metadata-contract.ts","../src/_metadata-generator.ts","../src/_ranking.ts","../src/_selection.ts","../src/classes.ts","../src/classify.ts","../src/fallback.ts","../src/invoke.ts","../src/metadata.ts","../src/model-catalog.ts","../src/model-client.ts","../src/policy.ts","../src/python.ts","../src/resolve.ts","../index.ts"],"version":"5.9.3"}
+{"root":["../src/_metadata-contract.ts","../src/_metadata-generator.ts","../src/_ranking.ts","../src/_selection.ts","../src/classes.ts","../src/classify.ts","../src/fallback.ts","../src/invoke.ts","../src/metadata-cache.ts","../src/metadata.ts","../src/model-catalog.ts","../src/model-client.ts","../src/policy.ts","../src/reasoning-translation.ts","../src/resolve.ts","../src/serving-wire.ts","../scripts/generate-metadata.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -10,6 +10,7 @@
     "build": "projen build",
     "compile": "projen compile",
     "default": "projen default",
+    "metadata": "projen metadata",
     "package": "projen package",
     "post-compile": "projen post-compile",
     "pre-compile": "projen pre-compile",
@@ -19,17 +20,20 @@
     "projen": "projen"
   },
   "devDependencies": {
-    "@types/bun": "1.3.14",
+    "@types/cacache": "^20.0.1",
     "@types/node": "^24.6.0",
     "cheerio": "^1.2.0",
     "typescript": "^5.9.3"
   },
   "dependencies": {
     "@databricks/appkit": "0.81.0",
-    "@dbx-tools/appkit": "^0.9.32",
-    "@dbx-tools/auth": "^0.9.32",
-    "@dbx-tools/shared-core": "^0.9.32",
-    "@dbx-tools/shared-model": "^0.9.32",
+    "@dbx-tools/appkit": "^0.9.37",
+    "@dbx-tools/auth": "^0.9.37",
+    "@dbx-tools/shared-auth": "^0.9.37",
+    "@dbx-tools/shared-core": "^0.9.37",
+    "@dbx-tools/shared-model": "^0.9.37",
+    "cacache": "^21.0.1",
+    "env-paths": "^4.0.0",
     "fuse.js": "^7.4.2"
   },
   "main": "./lib/index.js",
@@ -43,36 +47,125 @@
         "types": "./lib/index.d.ts",
         "default": "./lib/index.js"
       },
-      "./python": {
-        "types": "./lib/src/python.d.ts",
-        "default": "./lib/src/python.js"
+      "./classes": {
+        "types": "./lib/src/classes.d.ts",
+        "default": "./lib/src/classes.js"
+      },
+      "./classify": {
+        "types": "./lib/src/classify.d.ts",
+        "default": "./lib/src/classify.js"
+      },
+      "./fallback": {
+        "types": "./lib/src/fallback.d.ts",
+        "default": "./lib/src/fallback.js"
+      },
+      "./invoke": {
+        "types": "./lib/src/invoke.d.ts",
+        "default": "./lib/src/invoke.js"
+      },
+      "./metadata-cache": {
+        "types": "./lib/src/metadata-cache.d.ts",
+        "default": "./lib/src/metadata-cache.js"
+      },
+      "./metadata": {
+        "types": "./lib/src/metadata.d.ts",
+        "default": "./lib/src/metadata.js"
+      },
+      "./model-catalog": {
+        "types": "./lib/src/model-catalog.d.ts",
+        "default": "./lib/src/model-catalog.js"
+      },
+      "./model-client": {
+        "types": "./lib/src/model-client.d.ts",
+        "default": "./lib/src/model-client.js"
+      },
+      "./policy": {
+        "types": "./lib/src/policy.d.ts",
+        "default": "./lib/src/policy.js"
+      },
+      "./reasoning-translation": {
+        "types": "./lib/src/reasoning-translation.d.ts",
+        "default": "./lib/src/reasoning-translation.js"
+      },
+      "./resolve": {
+        "types": "./lib/src/resolve.d.ts",
+        "default": "./lib/src/resolve.js"
+      },
+      "./serving-wire": {
+        "types": "./lib/src/serving-wire.d.ts",
+        "default": "./lib/src/serving-wire.js"
       },
       "./package.json": "./package.json"
     }
   },
-  "version": "0.9.32",
+  "version": "0.9.37",
   "types": "./lib/index.d.ts",
+  "dbxToolsConfig": {
+    "tags": [
+      "node"
+    ]
+  },
   "type": "module",
   "exports": {
     ".": {
       "types": "./lib/index.d.ts",
       "default": "./lib/index.js"
     },
-    "./python": {
-      "types": "./lib/src/python.d.ts",
-      "default": "./lib/src/python.js"
+    "./classes": {
+      "types": "./lib/src/classes.d.ts",
+      "default": "./lib/src/classes.js"
+    },
+    "./classify": {
+      "types": "./lib/src/classify.d.ts",
+      "default": "./lib/src/classify.js"
+    },
+    "./fallback": {
+      "types": "./lib/src/fallback.d.ts",
+      "default": "./lib/src/fallback.js"
+    },
+    "./invoke": {
+      "types": "./lib/src/invoke.d.ts",
+      "default": "./lib/src/invoke.js"
+    },
+    "./metadata-cache": {
+      "types": "./lib/src/metadata-cache.d.ts",
+      "default": "./lib/src/metadata-cache.js"
+    },
+    "./metadata": {
+      "types": "./lib/src/metadata.d.ts",
+      "default": "./lib/src/metadata.js"
+    },
+    "./model-catalog": {
+      "types": "./lib/src/model-catalog.d.ts",
+      "default": "./lib/src/model-catalog.js"
+    },
+    "./model-client": {
+      "types": "./lib/src/model-client.d.ts",
+      "default": "./lib/src/model-client.js"
+    },
+    "./policy": {
+      "types": "./lib/src/policy.d.ts",
+      "default": "./lib/src/policy.js"
+    },
+    "./reasoning-translation": {
+      "types": "./lib/src/reasoning-translation.d.ts",
+      "default": "./lib/src/reasoning-translation.js"
+    },
+    "./resolve": {
+      "types": "./lib/src/resolve.d.ts",
+      "default": "./lib/src/resolve.js"
+    },
+    "./serving-wire": {
+      "types": "./lib/src/serving-wire.d.ts",
+      "default": "./lib/src/serving-wire.js"
     },
     "./package.json": "./package.json"
   },
   "files": [
     "index.ts",
     "src",
+    "exports.ts",
     "lib"
   ],
-  "dbxToolsConfig": {
-    "tags": [
-      "node"
-    ]
-  },
   "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"bunx projen\"."
 }

package/src/_metadata-contract.ts

@@ -1,3 +1,5 @@
+import type { ModelRateLimits } from "@dbx-tools/shared-model/contracts";
+
 /** One day, matching the refresh cadence of Databricks model documentation. */
 export const MODEL_METADATA_TTL_MS = 24 * 60 * 60 * 1000;
 
@@ -17,6 +19,10 @@ export const WEB_SEARCH_MODELS_URL =
 export const MODEL_RATE_LIMITS_URL =
   "https://docs.databricks.com/aws/en/machine-learning/foundation-model-apis/limits";
 
+/** Databricks documentation URL for reasoning-effort model policy. */
+export const QUERY_REASON_MODELS_URL =
+  "https://docs.databricks.com/aws/en/machine-learning/model-serving/query-reason-models";
+
 /** Build-generated retired-model snapshot. */
 export interface RetiredModelsSnapshot {
   readonly generatedAt: number;
@@ -37,13 +43,6 @@ export interface ModelCapabilitiesSnapshot {
   readonly capabilities: ModelCapabilityCatalogue;
 }
 
-/** Published pay-per-token limits for one model. */
-export interface ModelRateLimits {
-  readonly inputTokensPerMinute: number | null;
-  readonly outputTokensPerMinute: number | null;
-  readonly queriesPerHour: number | null;
-}
-
 /** Model limits keyed by normalized Databricks model identity. */
 export interface ModelRateLimitCatalogue {
   readonly models: Readonly<Record<string, ModelRateLimits>>;
@@ -54,3 +53,14 @@ export interface ModelRateLimitsSnapshot {
   readonly generatedAt: number;
   readonly catalogue: ModelRateLimitCatalogue;
 }
+
+/** Documented generic reasoning levels keyed by normalized model identity. */
+export interface ReasoningModelCatalogue {
+  readonly models: Readonly<Record<string, readonly string[]>>;
+}
+
+/** Build-generated reasoning-effort documentation snapshot. */
+export interface ReasoningModelsSnapshot {
+  readonly generatedAt: number;
+  readonly catalogue: ReasoningModelCatalogue;
+}

package/src/_metadata-generator.ts

@@ -4,12 +4,42 @@ import type {
   ModelCapabilitiesSnapshot,
   ModelRateLimitCatalogue,
   ModelRateLimitsSnapshot,
+  ReasoningModelsSnapshot,
   RetiredModelsSnapshot,
 } from "./_metadata-contract.ts";
 import { modelSearchQuery } from "./policy.ts";
+import {
+  parseReasoning,
+  REASONING_LEVELS,
+  type ReasoningLevel,
+  uniqueReasoningLevels,
+} from "./reasoning-translation.ts";
 
 type Selection = ReturnType<CheerioAPI>;
 
+const ACCEPTED_VALUES_PATTERN =
+  /(?:accepted values(?:\s+are|\s+vary)?|accepts(?:\s+values?(?:\s+of)?)?)\s*:?\s*([^.]+)/gi;
+const FOR_MODEL_PATTERN =
+  /For\s+([^,]+?),\s+(?:this parameter accepts(?:\s+values?\s+of)?|the (?:`?reasoning_effort`?|effort) parameter accepts(?:\s+values?\s+of)?)\s*([^.]+)/gi;
+const TOKEN_PATTERN = /'([^']+)'|"([^"]+)"|`([^`]+)`|\b([a-z][a-z0-9_-]*)\b/gi;
+const MODEL_CODE_PATTERN = /\bdatabricks-[a-z0-9][a-z0-9._-]*/gi;
+/** Wire tokens advertised in Databricks docs; excludes prose words like `default`. */
+const DOCUMENTATION_EFFORT_TOKENS = new Set([
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "extra-high",
+  "extrahigh",
+  "ultra",
+  "ultra-high",
+  "max",
+  "maximum",
+  "disabled",
+]);
+
 /** Parse retired model names from Databricks retirement-policy HTML. */
 export function parseRetiredModels(html: string, generatedAt: number): RetiredModelsSnapshot {
   const $ = load(html);
@@ -101,6 +131,136 @@ export function parseModelRateLimits(html: string, generatedAt: number): ModelRa
   return { generatedAt, catalogue: { models: sortRecord(models) } };
 }
 
+/** Parse reasoning-effort ladders from the Query reasoning models HTML table. */
+export function parseReasoningModels(
+  html: string,
+  generatedAt: number,
+): ReasoningModelsSnapshot {
+  const $ = load(html);
+  const models: Record<string, ReasoningLevel[]> = {};
+  $("table").each((_, table) => {
+    const rows = $(table).find("tr");
+    const headers = $(rows.get(0))
+      .find("th, td")
+      .toArray()
+      .map((cell) => collapseText($(cell)).toLowerCase());
+    if (!headers.some((header) => header.includes("model"))) return;
+    if (!headers.some((header) => header.includes("parameter"))) return;
+    rows.slice(1).each((__, row) => {
+      const cells = $(row).find("th, td").toArray().map((cell) => $(cell));
+      if (cells.length < 2) return;
+      const modelNames = reasoningModelNamesFromCell(cells[0]!, $);
+      if (modelNames.length === 0) return;
+      const parametersText = collapseText(cells[cells.length - 1]!);
+      const perModel = reasoningLevelsByModelSection(parametersText, modelNames);
+      if (Object.keys(perModel).length > 0) {
+        for (const [key, levels] of Object.entries(perModel)) {
+          if (levels.length > 0) models[key] = sortReasoningLevels(levels);
+        }
+        return;
+      }
+      const shared = sortReasoningLevels(extractAcceptedReasoningLevels(parametersText));
+      if (shared.length === 0) return;
+      for (const name of modelNames) {
+        const key = modelKey(name);
+        if (key) models[key] = shared;
+      }
+    });
+  });
+  if (Object.keys(models).length === 0) {
+    throw new Error("Databricks reasoning documentation contained no model effort ladders");
+  }
+  return { generatedAt, catalogue: { models: sortRecord(models) } };
+}
+
+function reasoningModelNamesFromCell(cell: Selection, $: CheerioAPI): string[] {
+  const names = new Set<string>();
+  cell.find("code").each((_, code) => {
+    const text = collapseText($(code));
+    if (text.startsWith("databricks-")) names.add(text);
+  });
+  if (names.size === 0) {
+    for (const match of collapseText(cell).matchAll(MODEL_CODE_PATTERN)) {
+      names.add(match[0]!);
+    }
+  }
+  return [...names];
+}
+
+function extractAcceptedReasoningLevels(text: string): ReasoningLevel[] {
+  const levels: ReasoningLevel[] = [];
+  for (const match of text.matchAll(ACCEPTED_VALUES_PATTERN)) {
+    const fragment = match[1];
+    if (!fragment || /vary by model/i.test(fragment)) continue;
+    levels.push(...documentationEffortLevels(fragment));
+  }
+  return levels;
+}
+
+function reasoningLevelsByModelSection(
+  parametersText: string,
+  rowModels: readonly string[],
+): Record<string, ReasoningLevel[]> {
+  const result: Record<string, ReasoningLevel[]> = {};
+  for (const match of parametersText.matchAll(FOR_MODEL_PATTERN)) {
+    const label = match[1]?.trim();
+    const fragment = match[2];
+    if (!label || !fragment) continue;
+    const levels = uniqueReasoningLevels(documentationEffortLevels(fragment));
+    if (levels.length === 0) continue;
+    const matched = rowModels.filter((model) => reasoningModelLabelMatches(label, model));
+    // Only attach explicit "For <model>" clauses to models listed in the row.
+    if (matched.length === 0) continue;
+    for (const target of matched) {
+      const key = modelKey(target);
+      if (key) result[key] = sortReasoningLevels(levels);
+    }
+  }
+  return result;
+}
+
+function documentationEffortLevels(fragment: string): ReasoningLevel[] {
+  return reasoningTokensFromFragment(fragment).flatMap((token) => {
+    const normalized = token.toLowerCase().replace(/[_\s]+/g, "-");
+    if (
+      !DOCUMENTATION_EFFORT_TOKENS.has(normalized) &&
+      !DOCUMENTATION_EFFORT_TOKENS.has(token.toLowerCase())
+    ) {
+      return [];
+    }
+    const level = parseReasoning(token);
+    return level ? [level] : [];
+  });
+}
+
+function sortReasoningLevels(levels: readonly ReasoningLevel[]): ReasoningLevel[] {
+  return uniqueReasoningLevels(levels).sort(
+    (left, right) => REASONING_LEVELS.indexOf(left) - REASONING_LEVELS.indexOf(right),
+  );
+}
+
+function reasoningModelLabelMatches(label: string, model: string): boolean {
+  const left = label
+    .toLowerCase()
+    .replace(/^databricks-/, "")
+    .replace(/[^a-z0-9]+/g, "");
+  const right = model
+    .toLowerCase()
+    .replace(/^databricks-/, "")
+    .replace(/[^a-z0-9]+/g, "");
+  return left === right || right.includes(left) || left.includes(right);
+}
+
+function reasoningTokensFromFragment(fragment: string): string[] {
+  const tokens: string[] = [];
+  for (const part of fragment.matchAll(TOKEN_PATTERN)) {
+    const token = part[1] ?? part[2] ?? part[3] ?? part[4];
+    if (!token || token === "and" || token === "or" || token === "of") continue;
+    tokens.push(token.replace(/^["'`]+|["'`]+$/g, ""));
+  }
+  return tokens;
+}
+
 function modelsAfterHeading($: CheerioAPI, headingId: string): string[] {
   return [
     ...new Set(codeValuesAfterHeading($, headingId).flatMap((value) => modelKey(value) ?? [])),