@dbx-tools/model 0.3.43 → 0.4.0

package/lib/index.d.ts

@@ -0,0 +1,13 @@
+export * as classes from "./src/classes.js";
+export * as fallback from "./src/fallback.js";
+export * as invoke from "./src/invoke.js";
+export * as resolve from "./src/resolve.js";
+export * as serving from "./src/serving.js";
+export { CHAT_CLASS_ORDER, MODEL_CLASS_ORDER, isChatClass, parseModelClass, classesAtOrBelow } from "./src/classes.js";
+export { modelsForClass, modelForClass, FALLBACK_MODEL_IDS } from "./src/fallback.js";
+export { INVOCATIONS_SUFFIX, RESPONSES_PATH, OPEN_RESPONSES_PATH, CHAT_COMPLETIONS_PATH, invocationsUrl, responsesUrl, openResponsesUrl, chatCompletionsUrl, isResponsesOnly, responsesUpstreamUrl, authHeaders } from "./src/invoke.js";
+export type { AuthenticatingClientLike } from "./src/invoke.js";
+export { rankModels, rankModelId, rankModelIdLive, searchModels, selectModel, resolveModel } from "./src/resolve.js";
+export type { ResolveModelInput, ResolvedModelSelection, SelectModelInput, SearchModelsInput } from "./src/resolve.js";
+export { DEFAULT_MODEL_CACHE_TTL_MS, DEFAULT_FUZZY_THRESHOLD, listServingEndpoints, listServingEndpointsUncached, clearServingEndpointsCache, searchServingEndpoints, resolveModelId } from "./src/serving.js";
+export type { WorkspaceClientLike, ListServingEndpointsOptions, ResolvedModel, ResolveModelOptions, ScoredEndpoint } from "./src/serving.js";

package/lib/index.js

@@ -0,0 +1,14 @@
+// GENERATED by projen watch - DO NOT EDIT.
+// Regenerated from the exporting modules in ./src.
+// Hand edits are overwritten on the next watch; this file is read-only.
+export * as classes from "./src/classes.js";
+export * as fallback from "./src/fallback.js";
+export * as invoke from "./src/invoke.js";
+export * as resolve from "./src/resolve.js";
+export * as serving from "./src/serving.js";
+export { CHAT_CLASS_ORDER, MODEL_CLASS_ORDER, isChatClass, parseModelClass, classesAtOrBelow } from "./src/classes.js";
+export { modelsForClass, modelForClass, FALLBACK_MODEL_IDS } from "./src/fallback.js";
+export { INVOCATIONS_SUFFIX, RESPONSES_PATH, OPEN_RESPONSES_PATH, CHAT_COMPLETIONS_PATH, invocationsUrl, responsesUrl, openResponsesUrl, chatCompletionsUrl, isResponsesOnly, responsesUpstreamUrl, authHeaders } from "./src/invoke.js";
+export { rankModels, rankModelId, rankModelIdLive, searchModels, selectModel, resolveModel } from "./src/resolve.js";
+export { DEFAULT_MODEL_CACHE_TTL_MS, DEFAULT_FUZZY_THRESHOLD, listServingEndpoints, listServingEndpointsUncached, clearServingEndpointsCache, searchServingEndpoints, resolveModelId } from "./src/serving.js";
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/classes.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Model-class ordering for the model service.
+ *
+ * `@dbx-tools/shared-model` declares the {@link ModelClass} values and their
+ * schema; the *behavior* over those values - the chat capability order, the
+ * "this class and below" ceiling, and coercing loose request input to a class -
+ * lives here in the service so the shared wire-format surface stays purely
+ * declarative.
+ *
+ * @module
+ */
+import { model } from "@dbx-tools/shared-model";
+type ModelClass = model.ModelClass;
+declare const ModelClass: typeof model.ModelClass;
+/**
+ * Chat capability ladder in descending order - most capable
+ * ({@link ModelClass.ChatThinking}) first, least ({@link ModelClass.ChatFast})
+ * last. {@link ModelClass.Embedding} is a separate modality and is deliberately
+ * absent: the ceiling never spans it. This is the order used to filter "this
+ * class and below" and to break ranking ties toward the more capable model.
+ */
+export declare const CHAT_CLASS_ORDER: readonly ModelClass[];
+/**
+ * Every class in display order: the chat ladder followed by
+ * {@link ModelClass.Embedding}. Used when flattening a full classification
+ * (e.g. stamping the class onto each cached endpoint).
+ */
+export declare const MODEL_CLASS_ORDER: readonly ModelClass[];
+/** Whether `cls` is one of the chat capability bands (vs. embedding). */
+export declare function isChatClass(cls: ModelClass): boolean;
+/**
+ * Coerce an arbitrary value (query string, header, body field) to a
+ * {@link ModelClass}, returning `null` when it isn't a known class. Lets a
+ * route accept a class request without throwing on junk input.
+ *
+ * Matches the full slug first (`"chat-fast"`, `"embedding"`), then - for a bare
+ * chat band - retries with a `chat-` prefix, so the shorthand `"thinking"` /
+ * `"balanced"` / `"fast"` resolves to the corresponding `chat-*` class.
+ */
+export declare function parseModelClass(value: unknown): ModelClass | null;
+/**
+ * Classes at or below `cls` in chat capability: the class itself plus every
+ * less-capable chat band, in {@link CHAT_CLASS_ORDER}. Treats a chat `cls` as a
+ * ceiling - requesting {@link ModelClass.ChatBalanced} yields
+ * `[ChatBalanced, ChatFast]`, never {@link ModelClass.ChatThinking} - so a
+ * class ask can degrade downward to a smaller chat model but never escalate to
+ * a larger one.
+ *
+ * {@link ModelClass.Embedding} is its own modality, not a rung on the chat
+ * ladder, so it yields just `[Embedding]`. An unrecognized class yields the
+ * full chat ladder.
+ */
+export declare function classesAtOrBelow(cls: ModelClass): ModelClass[];
+export {};

package/lib/src/classes.js

@@ -0,0 +1,70 @@
+/**
+ * Model-class ordering for the model service.
+ *
+ * `@dbx-tools/shared-model` declares the {@link ModelClass} values and their
+ * schema; the *behavior* over those values - the chat capability order, the
+ * "this class and below" ceiling, and coercing loose request input to a class -
+ * lives here in the service so the shared wire-format surface stays purely
+ * declarative.
+ *
+ * @module
+ */
+import { model } from "@dbx-tools/shared-model";
+const { ModelClass, ModelClassSchema } = model;
+/**
+ * Chat capability ladder in descending order - most capable
+ * ({@link ModelClass.ChatThinking}) first, least ({@link ModelClass.ChatFast})
+ * last. {@link ModelClass.Embedding} is a separate modality and is deliberately
+ * absent: the ceiling never spans it. This is the order used to filter "this
+ * class and below" and to break ranking ties toward the more capable model.
+ */
+export const CHAT_CLASS_ORDER = [
+    ModelClass.ChatThinking,
+    ModelClass.ChatBalanced,
+    ModelClass.ChatFast,
+];
+/**
+ * Every class in display order: the chat ladder followed by
+ * {@link ModelClass.Embedding}. Used when flattening a full classification
+ * (e.g. stamping the class onto each cached endpoint).
+ */
+export const MODEL_CLASS_ORDER = [...CHAT_CLASS_ORDER, ModelClass.Embedding];
+/** Whether `cls` is one of the chat capability bands (vs. embedding). */
+export function isChatClass(cls) {
+    return CHAT_CLASS_ORDER.includes(cls);
+}
+/**
+ * Coerce an arbitrary value (query string, header, body field) to a
+ * {@link ModelClass}, returning `null` when it isn't a known class. Lets a
+ * route accept a class request without throwing on junk input.
+ *
+ * Matches the full slug first (`"chat-fast"`, `"embedding"`), then - for a bare
+ * chat band - retries with a `chat-` prefix, so the shorthand `"thinking"` /
+ * `"balanced"` / `"fast"` resolves to the corresponding `chat-*` class.
+ */
+export function parseModelClass(value) {
+    const exact = ModelClassSchema.safeParse(value);
+    if (exact.success)
+        return exact.data;
+    const prefixed = ModelClassSchema.safeParse(`chat-${value}`);
+    return prefixed.success ? prefixed.data : null;
+}
+/**
+ * Classes at or below `cls` in chat capability: the class itself plus every
+ * less-capable chat band, in {@link CHAT_CLASS_ORDER}. Treats a chat `cls` as a
+ * ceiling - requesting {@link ModelClass.ChatBalanced} yields
+ * `[ChatBalanced, ChatFast]`, never {@link ModelClass.ChatThinking} - so a
+ * class ask can degrade downward to a smaller chat model but never escalate to
+ * a larger one.
+ *
+ * {@link ModelClass.Embedding} is its own modality, not a rung on the chat
+ * ladder, so it yields just `[Embedding]`. An unrecognized class yields the
+ * full chat ladder.
+ */
+export function classesAtOrBelow(cls) {
+    if (cls === ModelClass.Embedding)
+        return [ModelClass.Embedding];
+    const index = CHAT_CLASS_ORDER.indexOf(cls);
+    return index < 0 ? [...CHAT_CLASS_ORDER] : [...CHAT_CLASS_ORDER.slice(index)];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/fallback.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Server-side offline fallback opinion for model selection.
+ *
+ * When the live `/serving-endpoints` catalogue can't be read at all - no user
+ * token, the service principal can't list, or the workspace is unreachable -
+ * the resolver still has to name *some* endpoint. This module holds that floor:
+ * a small, hard-coded set of well-known Foundation Model API endpoint names,
+ * each bucketed into a chat {@link ModelClass} by the shared
+ * {@link classify.classifyByFamily} heuristic (no classes are hard-coded here)
+ * and ordered best-first.
+ *
+ * This is deliberately *server-only*. A browser client never talks to
+ * Databricks directly - it always goes through this server - so it has nothing
+ * to fall back to and must not assume a stale, baked-in model list; it consumes
+ * the live `/models` response instead. The pure classifier
+ * ({@link classify.classifyEndpoints}) is what the client shares.
+ *
+ * @module
+ */
+import { model } from "@dbx-tools/shared-model";
+type ModelClass = model.ModelClass;
+declare const ModelClass: typeof model.ModelClass;
+/**
+ * Static fallback model ids for a chat class, drawn from the small built-in
+ * {@link FALLBACK_MODEL_NAMES} list and ordered best-first by family rank. Sync
+ * and workspace-independent: this is the *fallback opinion* used to seed default
+ * lists or when the live catalogue is unreachable - live resolution prefers
+ * {@link classify.classifyEndpoints}. Returns `[]` for
+ * {@link ModelClass.Embedding} (the floor is chat-only).
+ */
+export declare function modelsForClass(cls: ModelClass): readonly string[];
+/** Top static fallback model id for a chat class. */
+export declare function modelForClass(cls: ModelClass): string;
+/**
+ * Priority-ordered fallback chain (ChatThinking -> ChatBalanced -> ChatFast)
+ * over the small built-in list. The floor walked at resolve time when no agent
+ * / plugin / env / request model is set *and* the live catalogue yields nothing.
+ */
+export declare const FALLBACK_MODEL_IDS: readonly string[];
+export {};

package/lib/src/fallback.js

@@ -0,0 +1,69 @@
+/**
+ * Server-side offline fallback opinion for model selection.
+ *
+ * When the live `/serving-endpoints` catalogue can't be read at all - no user
+ * token, the service principal can't list, or the workspace is unreachable -
+ * the resolver still has to name *some* endpoint. This module holds that floor:
+ * a small, hard-coded set of well-known Foundation Model API endpoint names,
+ * each bucketed into a chat {@link ModelClass} by the shared
+ * {@link classify.classifyByFamily} heuristic (no classes are hard-coded here)
+ * and ordered best-first.
+ *
+ * This is deliberately *server-only*. A browser client never talks to
+ * Databricks directly - it always goes through this server - so it has nothing
+ * to fall back to and must not assume a stale, baked-in model list; it consumes
+ * the live `/models` response instead. The pure classifier
+ * ({@link classify.classifyEndpoints}) is what the client shares.
+ *
+ * @module
+ */
+import { classify, model } from "@dbx-tools/shared-model";
+const { ModelClass } = model;
+/**
+ * Small, last-resort set of well-known Foundation Model API endpoint names,
+ * ordered best-first within each class by {@link classify.classifyByFamily}.
+ * Used only as the floor when the live `/serving-endpoints` catalogue can't be
+ * read at resolve time; the live, score-driven classification supersedes it
+ * whenever the workspace listing is available. Classes are not hard-coded here
+ * - each name is classified by family heuristic.
+ */
+const FALLBACK_MODEL_NAMES = [
+    "databricks-claude-opus-4-8",
+    "databricks-gpt-5-5-pro",
+    "databricks-gemini-3-1-pro",
+    "databricks-claude-sonnet-4-6",
+    "databricks-gpt-5-5",
+    "databricks-meta-llama-3-3-70b-instruct",
+    "databricks-claude-haiku-4-5",
+    "databricks-gpt-5-nano",
+    "databricks-meta-llama-3-1-8b-instruct",
+];
+/**
+ * Static fallback model ids for a chat class, drawn from the small built-in
+ * {@link FALLBACK_MODEL_NAMES} list and ordered best-first by family rank. Sync
+ * and workspace-independent: this is the *fallback opinion* used to seed default
+ * lists or when the live catalogue is unreachable - live resolution prefers
+ * {@link classify.classifyEndpoints}. Returns `[]` for
+ * {@link ModelClass.Embedding} (the floor is chat-only).
+ */
+export function modelsForClass(cls) {
+    return FALLBACK_MODEL_NAMES.map((name) => ({ name, c: classify.classifyByFamily(name) }))
+        .filter((x) => x.c !== null && x.c.class === cls)
+        .sort((a, b) => b.c.rank - a.c.rank)
+        .map((x) => x.name);
+}
+/** Top static fallback model id for a chat class. */
+export function modelForClass(cls) {
+    return modelsForClass(cls)[0];
+}
+/**
+ * Priority-ordered fallback chain (ChatThinking -> ChatBalanced -> ChatFast)
+ * over the small built-in list. The floor walked at resolve time when no agent
+ * / plugin / env / request model is set *and* the live catalogue yields nothing.
+ */
+export const FALLBACK_MODEL_IDS = [
+    ...modelsForClass(ModelClass.ChatThinking),
+    ...modelsForClass(ModelClass.ChatBalanced),
+    ...modelsForClass(ModelClass.ChatFast),
+];
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/invoke.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Calling a Model Serving endpoint directly over HTTP.
+ *
+ * The SDK's `servingEndpoints.query` covers the typed request shapes, but an
+ * OpenAI-compatible caller (a proxy, a passthrough route, a streaming client)
+ * needs to issue its own `fetch` against Databricks' OpenAI-shaped URLs with
+ * an OpenAI body. That needs exactly two things the SDK doesn't hand out
+ * directly: the URL ({@link invocationsUrl} / {@link responsesUrl} /
+ * {@link openResponsesUrl}) and a currently-valid set of auth headers
+ * ({@link authHeaders}).
+ *
+ * Auth is delegated entirely to the Databricks SDK: `config.authenticate`
+ * re-runs the configured credential provider on every call and refreshes the
+ * underlying OAuth / PAT token when it is close to expiry, so a caller never
+ * manages token lifetimes itself - mint headers per request and each one is
+ * signed with a valid bearer token.
+ *
+ * @module
+ */
+/**
+ * Path segment appended to a serving endpoint for OpenAI-compatible chat
+ * requests. Databricks routes `/serving-endpoints/<name>/invocations` to the
+ * endpoint's Chat Completions surface (`messages` in, `choices` out). Some
+ * models (notably Codex) reject this path and require {@link responsesUrl}.
+ */
+export declare const INVOCATIONS_SUFFIX = "invocations";
+/**
+ * Workspace-level OpenAI Responses API path. Body carries `model` (endpoint
+ * id); used by GPT / Codex models that speak Responses natively.
+ */
+export declare const RESPONSES_PATH = "serving-endpoints/responses";
+/**
+ * Workspace-level Open Responses API path - the cross-provider Responses
+ * surface (Claude, Gemini, …) that OpenAI `/responses` does not cover.
+ */
+export declare const OPEN_RESPONSES_PATH = "serving-endpoints/open-responses";
+/**
+ * Workspace-level OpenAI Chat Completions path. Body carries `model` (endpoint
+ * id), unlike {@link invocationsUrl} which names the endpoint in the URL. Use
+ * this when the caller has a model id rather than a per-endpoint route - e.g.
+ * attaching a provider tool spec to whichever endpoint was resolved.
+ */
+export declare const CHAT_COMPLETIONS_PATH = "serving-endpoints/chat/completions";
+/**
+ * The OpenAI-compatible chat-completions invocations URL for an endpoint id.
+ *
+ * @param host - Workspace host, e.g. `https://my-workspace.cloud.databricks.com/`.
+ *   Pass the value resolved from `client.config.getHost()`.
+ * @param endpoint - Endpoint id (already resolved; not fuzzy-matched here).
+ */
+export declare function invocationsUrl(host: string, endpoint: string): string;
+/** Workspace OpenAI Responses API URL (`POST`, model in the body). */
+export declare function responsesUrl(host: string): string;
+/** Workspace Open Responses API URL (`POST`, model in the body). */
+export declare function openResponsesUrl(host: string): string;
+/** Workspace OpenAI Chat Completions URL (`POST`, model in the body). */
+export declare function chatCompletionsUrl(host: string): string;
+/**
+ * True when the endpoint is known to reject Chat Completions `/invocations`
+ * and require the Responses API (Codex models today). Callers should route
+ * those to {@link responsesUrl} instead of {@link invocationsUrl}.
+ */
+export declare function isResponsesOnly(endpoint: string): boolean;
+/**
+ * Pick the Databricks Responses upstream for an endpoint id: OpenAI-family
+ * models use `/serving-endpoints/responses`; everything else uses the
+ * cross-provider `/serving-endpoints/open-responses`.
+ */
+export declare function responsesUpstreamUrl(host: string, endpoint: string): string;
+/**
+ * Minimal structural shape {@link authHeaders} needs. Declared narrowly rather
+ * than as a full `WorkspaceClientLike` so a caller holding its own
+ * `@databricks/sdk-experimental` `WorkspaceClient` satisfies it regardless of
+ * which SDK version resolved in its tree.
+ */
+export interface AuthenticatingClientLike {
+    config: {
+        authenticate(headers: Headers): Promise<void>;
+    };
+}
+/**
+ * Mint auth headers for one upstream request as a plain object, ready to spread
+ * into a `fetch` init. Call it per request: the SDK refreshes the underlying
+ * token when needed, so a long-lived process never has to track expiry itself.
+ */
+export declare function authHeaders(client: AuthenticatingClientLike): Promise<Record<string, string>>;

package/lib/src/invoke.js

@@ -0,0 +1,104 @@
+/**
+ * Calling a Model Serving endpoint directly over HTTP.
+ *
+ * The SDK's `servingEndpoints.query` covers the typed request shapes, but an
+ * OpenAI-compatible caller (a proxy, a passthrough route, a streaming client)
+ * needs to issue its own `fetch` against Databricks' OpenAI-shaped URLs with
+ * an OpenAI body. That needs exactly two things the SDK doesn't hand out
+ * directly: the URL ({@link invocationsUrl} / {@link responsesUrl} /
+ * {@link openResponsesUrl}) and a currently-valid set of auth headers
+ * ({@link authHeaders}).
+ *
+ * Auth is delegated entirely to the Databricks SDK: `config.authenticate`
+ * re-runs the configured credential provider on every call and refreshes the
+ * underlying OAuth / PAT token when it is close to expiry, so a caller never
+ * manages token lifetimes itself - mint headers per request and each one is
+ * signed with a valid bearer token.
+ *
+ * @module
+ */
+/**
+ * Path segment appended to a serving endpoint for OpenAI-compatible chat
+ * requests. Databricks routes `/serving-endpoints/<name>/invocations` to the
+ * endpoint's Chat Completions surface (`messages` in, `choices` out). Some
+ * models (notably Codex) reject this path and require {@link responsesUrl}.
+ */
+export const INVOCATIONS_SUFFIX = "invocations";
+/**
+ * Workspace-level OpenAI Responses API path. Body carries `model` (endpoint
+ * id); used by GPT / Codex models that speak Responses natively.
+ */
+export const RESPONSES_PATH = "serving-endpoints/responses";
+/**
+ * Workspace-level Open Responses API path - the cross-provider Responses
+ * surface (Claude, Gemini, …) that OpenAI `/responses` does not cover.
+ */
+export const OPEN_RESPONSES_PATH = "serving-endpoints/open-responses";
+/**
+ * Workspace-level OpenAI Chat Completions path. Body carries `model` (endpoint
+ * id), unlike {@link invocationsUrl} which names the endpoint in the URL. Use
+ * this when the caller has a model id rather than a per-endpoint route - e.g.
+ * attaching a provider tool spec to whichever endpoint was resolved.
+ */
+export const CHAT_COMPLETIONS_PATH = "serving-endpoints/chat/completions";
+/**
+ * The OpenAI-compatible chat-completions invocations URL for an endpoint id.
+ *
+ * @param host - Workspace host, e.g. `https://my-workspace.cloud.databricks.com/`.
+ *   Pass the value resolved from `client.config.getHost()`.
+ * @param endpoint - Endpoint id (already resolved; not fuzzy-matched here).
+ */
+export function invocationsUrl(host, endpoint) {
+    return new URL(`serving-endpoints/${encodeURIComponent(endpoint)}/${INVOCATIONS_SUFFIX}`, host).toString();
+}
+/** Workspace OpenAI Responses API URL (`POST`, model in the body). */
+export function responsesUrl(host) {
+    return new URL(RESPONSES_PATH, host).toString();
+}
+/** Workspace Open Responses API URL (`POST`, model in the body). */
+export function openResponsesUrl(host) {
+    return new URL(OPEN_RESPONSES_PATH, host).toString();
+}
+/** Workspace OpenAI Chat Completions URL (`POST`, model in the body). */
+export function chatCompletionsUrl(host) {
+    return new URL(CHAT_COMPLETIONS_PATH, host).toString();
+}
+/**
+ * True when the endpoint is known to reject Chat Completions `/invocations`
+ * and require the Responses API (Codex models today). Callers should route
+ * those to {@link responsesUrl} instead of {@link invocationsUrl}.
+ */
+export function isResponsesOnly(endpoint) {
+    return /codex/i.test(endpoint);
+}
+/**
+ * Pick the Databricks Responses upstream for an endpoint id: OpenAI-family
+ * models use `/serving-endpoints/responses`; everything else uses the
+ * cross-provider `/serving-endpoints/open-responses`.
+ */
+export function responsesUpstreamUrl(host, endpoint) {
+    return isOpenAiFamily(endpoint) ? responsesUrl(host) : openResponsesUrl(host);
+}
+/** GPT / Codex / o-series style endpoint names that speak OpenAI Responses. */
+function isOpenAiFamily(endpoint) {
+    const n = endpoint.toLowerCase();
+    return (n.includes("gpt") ||
+        n.includes("codex") ||
+        /(^|[^a-z])o[1-9]([^a-z]|$)/.test(n) ||
+        n.includes("openai"));
+}
+/**
+ * Mint auth headers for one upstream request as a plain object, ready to spread
+ * into a `fetch` init. Call it per request: the SDK refreshes the underlying
+ * token when needed, so a long-lived process never has to track expiry itself.
+ */
+export async function authHeaders(client) {
+    const headers = new Headers();
+    await client.config.authenticate(headers);
+    const out = {};
+    headers.forEach((value, key) => {
+        out[key] = value;
+    });
+    return out;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"invoke.js","sourceRoot":"","sources":["../../src/invoke.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,aAAa,CAAC;AAEhD;;;GAGG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,6BAA6B,CAAC;AAE5D;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,kCAAkC,CAAC;AAEtE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,oCAAoC,CAAC;AAE1E;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAC,IAAY,EAAE,QAAgB;IAC3D,OAAO,IAAI,GAAG,CACZ,qBAAqB,kBAAkB,CAAC,QAAQ,CAAC,IAAI,kBAAkB,EAAE,EACzE,IAAI,CACL,CAAC,QAAQ,EAAE,CAAC;AACf,CAAC;AAED,sEAAsE;AACtE,MAAM,UAAU,YAAY,CAAC,IAAY;IACvC,OAAO,IAAI,GAAG,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC;AAClD,CAAC;AAED,oEAAoE;AACpE,MAAM,UAAU,gBAAgB,CAAC,IAAY;IAC3C,OAAO,IAAI,GAAG,CAAC,mBAAmB,EAAE,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC;AACvD,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,kBAAkB,CAAC,IAAY;IAC7C,OAAO,IAAI,GAAG,CAAC,qBAAqB,EAAE,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC;AACzD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,QAAgB;IAC9C,OAAO,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;AACjC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAAC,IAAY,EAAE,QAAgB;IACjE,OAAO,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;AAChF,CAAC;AAED,+EAA+E;AAC/E,SAAS,cAAc,CAAC,QAAgB;IACtC,MAAM,CAAC,GAAG,QAAQ,CAAC,WAAW,EAAE,CAAC;IACjC,OAAO,CACL,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;QACjB,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC;QACnB,4BAA4B,CAAC,IAAI,CAAC,CAAC,CAAC;QACpC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CACrB,CAAC;AACJ,CAAC;AAcD;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,MAAgC;IAEhC,MAAM,OAAO,GAAG,IAAI,OAAO,EAAE,CAAC;IAC9B,MAAM,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;IAC1C,MAAM,GAAG,GAA2B,EAAE,CAAC;IACvC,OAAO,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;QAC7B,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;IACnB,CAAC,CAAC,CAAC;IACH,OAAO,GAAG,CAAC;AACb,CAAC","sourcesContent":["/**\n * Calling a Model Serving endpoint directly over HTTP.\n *\n * The SDK's `servingEndpoints.query` covers the typed request shapes, but an\n * OpenAI-compatible caller (a proxy, a passthrough route, a streaming client)\n * needs to issue its own `fetch` against Databricks' OpenAI-shaped URLs with\n * an OpenAI body. That needs exactly two things the SDK doesn't hand out\n * directly: the URL ({@link invocationsUrl} / {@link responsesUrl} /\n * {@link openResponsesUrl}) and a currently-valid set of auth headers\n * ({@link authHeaders}).\n *\n * Auth is delegated entirely to the Databricks SDK: `config.authenticate`\n * re-runs the configured credential provider on every call and refreshes the\n * underlying OAuth / PAT token when it is close to expiry, so a caller never\n * manages token lifetimes itself - mint headers per request and each one is\n * signed with a valid bearer token.\n *\n * @module\n */\n\n/**\n * Path segment appended to a serving endpoint for OpenAI-compatible chat\n * requests. Databricks routes `/serving-endpoints/<name>/invocations` to the\n * endpoint's Chat Completions surface (`messages` in, `choices` out). Some\n * models (notably Codex) reject this path and require {@link responsesUrl}.\n */\nexport const INVOCATIONS_SUFFIX = \"invocations\";\n\n/**\n * Workspace-level OpenAI Responses API path. Body carries `model` (endpoint\n * id); used by GPT / Codex models that speak Responses natively.\n */\nexport const RESPONSES_PATH = \"serving-endpoints/responses\";\n\n/**\n * Workspace-level Open Responses API path - the cross-provider Responses\n * surface (Claude, Gemini, …) that OpenAI `/responses` does not cover.\n */\nexport const OPEN_RESPONSES_PATH = \"serving-endpoints/open-responses\";\n\n/**\n * Workspace-level OpenAI Chat Completions path. Body carries `model` (endpoint\n * id), unlike {@link invocationsUrl} which names the endpoint in the URL. Use\n * this when the caller has a model id rather than a per-endpoint route - e.g.\n * attaching a provider tool spec to whichever endpoint was resolved.\n */\nexport const CHAT_COMPLETIONS_PATH = \"serving-endpoints/chat/completions\";\n\n/**\n * The OpenAI-compatible chat-completions invocations URL for an endpoint id.\n *\n * @param host - Workspace host, e.g. `https://my-workspace.cloud.databricks.com/`.\n *   Pass the value resolved from `client.config.getHost()`.\n * @param endpoint - Endpoint id (already resolved; not fuzzy-matched here).\n */\nexport function invocationsUrl(host: string, endpoint: string): string {\n  return new URL(\n    `serving-endpoints/${encodeURIComponent(endpoint)}/${INVOCATIONS_SUFFIX}`,\n    host,\n  ).toString();\n}\n\n/** Workspace OpenAI Responses API URL (`POST`, model in the body). */\nexport function responsesUrl(host: string): string {\n  return new URL(RESPONSES_PATH, host).toString();\n}\n\n/** Workspace Open Responses API URL (`POST`, model in the body). */\nexport function openResponsesUrl(host: string): string {\n  return new URL(OPEN_RESPONSES_PATH, host).toString();\n}\n\n/** Workspace OpenAI Chat Completions URL (`POST`, model in the body). */\nexport function chatCompletionsUrl(host: string): string {\n  return new URL(CHAT_COMPLETIONS_PATH, host).toString();\n}\n\n/**\n * True when the endpoint is known to reject Chat Completions `/invocations`\n * and require the Responses API (Codex models today). Callers should route\n * those to {@link responsesUrl} instead of {@link invocationsUrl}.\n */\nexport function isResponsesOnly(endpoint: string): boolean {\n  return /codex/i.test(endpoint);\n}\n\n/**\n * Pick the Databricks Responses upstream for an endpoint id: OpenAI-family\n * models use `/serving-endpoints/responses`; everything else uses the\n * cross-provider `/serving-endpoints/open-responses`.\n */\nexport function responsesUpstreamUrl(host: string, endpoint: string): string {\n  return isOpenAiFamily(endpoint) ? responsesUrl(host) : openResponsesUrl(host);\n}\n\n/** GPT / Codex / o-series style endpoint names that speak OpenAI Responses. */\nfunction isOpenAiFamily(endpoint: string): boolean {\n  const n = endpoint.toLowerCase();\n  return (\n    n.includes(\"gpt\") ||\n    n.includes(\"codex\") ||\n    /(^|[^a-z])o[1-9]([^a-z]|$)/.test(n) ||\n    n.includes(\"openai\")\n  );\n}\n\n/**\n * Minimal structural shape {@link authHeaders} needs. Declared narrowly rather\n * than as a full `WorkspaceClientLike` so a caller holding its own\n * `@databricks/sdk-experimental` `WorkspaceClient` satisfies it regardless of\n * which SDK version resolved in its tree.\n */\nexport interface AuthenticatingClientLike {\n  config: {\n    authenticate(headers: Headers): Promise<void>;\n  };\n}\n\n/**\n * Mint auth headers for one upstream request as a plain object, ready to spread\n * into a `fetch` init. Call it per request: the SDK refreshes the underlying\n * token when needed, so a long-lived process never has to track expiry itself.\n */\nexport async function authHeaders(\n  client: AuthenticatingClientLike,\n): Promise<Record<string, string>> {\n  const headers = new Headers();\n  await client.config.authenticate(headers);\n  const out: Record<string, string> = {};\n  headers.forEach((value, key) => {\n    out[key] = value;\n  });\n  return out;\n}\n"]}