@dbx-tools/cli-model-proxy 0.3.21

package/README.md

@@ -0,0 +1,143 @@
+# dbx-tools-model-proxy
+
+Local OpenAI-compatible proxy for Databricks Model Serving.
+
+Import this package or run its CLI when a tool expects the OpenAI API shape but
+you want Databricks Model Serving auth, endpoint discovery, and fuzzy model
+names. The proxy does not translate the OpenAI wire format; it resolves the
+requested model, mints/refreshes Databricks auth through the SDK, and streams the
+upstream response back to the caller.
+
+Key features:
+
+- OpenAI-compatible `/v1/*` forwarding for local tools that already know how to
+  call chat/completions endpoints.
+- Databricks SDK auth, including profile selection, token refresh, and workspace
+  host resolution.
+- Fuzzy model names and model-class requests powered by
+  [`@dbx-tools/model`](../../node/model).
+- Optional local API-key enforcement for loopback safety.
+- One-shot terminal chat mode that injects `OPENAI_BASE_URL`, `OPENAI_API_KEY`,
+  and `OPENAI_MODEL` into a child process.
+- Programmatic Express app/server creation for tests and custom developer tools.
+
+## Why Not Just AppKit Serving?
+
+Use native AppKit Serving routes inside a Databricks App. They preserve AppKit's
+plugin lifecycle, OBO request context, generated types, and React hooks.
+
+Use this proxy for local tools that already speak the OpenAI API shape and know
+nothing about AppKit:
+
+- terminal chat clients and IDE integrations that only accept `OPENAI_BASE_URL`;
+- local experiments where Databricks SDK auth should mint the upstream token;
+- loose model names resolved through `@dbx-tools/model`;
+- test harnesses that need an Express server with Databricks-backed `/v1/*`
+  routes.
+
+## Run The Proxy
+
+```sh
+dbx-tools-model-proxy --profile my-workspace --port 4000
+```
+
+The package installs two equivalent commands: `dbx-tools-model-proxy` and the
+shorter `dbxt-model-proxy`. Neither matches the package name, so a one-off run
+has to name the command explicitly:
+
+```sh
+npx --package @dbx-tools/cli-model-proxy dbx-tools-model-proxy
+```
+
+Then point any OpenAI-compatible client at `http://127.0.0.1:4000/v1`:
+
+```sh
+curl http://127.0.0.1:4000/v1/chat/completions \
+  -H 'content-type: application/json' \
+  -d '{"model":"claude sonnet","messages":[{"role":"user","content":"hi"}]}'
+```
+
+The response includes `x-resolved-model`, showing which Databricks serving
+endpoint the loose request snapped to.
+
+The proxy is intentionally local-first. Bind it to `127.0.0.1` unless you are
+putting another trusted access-control layer in front of it.
+
+## Use A Terminal Chat Client
+
+```sh
+dbx-tools-model-proxy chat --profile my-workspace --model "claude sonnet"
+dbx-tools-model-proxy chat --client "aichat" --model "chat fast"
+```
+
+`chat` starts the proxy, sets `OPENAI_BASE_URL`, `OPENAI_API_KEY`, and
+`OPENAI_MODEL` for the child process, then shuts the proxy down when the child
+exits. Use it to try Databricks-hosted models in any OpenAI-compatible terminal
+client without editing that client's config.
+
+## Inspect Model Resolution
+
+```sh
+dbx-tools-model-proxy models --profile my-workspace
+dbx-tools-model-proxy resolve claude sonnet --profile my-workspace
+```
+
+These commands are useful when a client request resolves unexpectedly. They use
+the same backend and resolver as the proxy server (`@dbx-tools/model`
+`rankModels`: Fuse match, then class, then within-class version - so `opus`
+prefers `opus-5` over `opus-4-7`).
+
+## Require A Client API Key
+
+```sh
+dbx-tools-model-proxy --api-key "$LOCAL_PROXY_KEY"
+```
+
+With `--api-key` or `PROXY_API_KEY`, callers must send
+`Authorization: Bearer <key>`. This protects the loopback proxy when another
+local process may be able to reach it.
+
+## Start Programmatically
+
+```ts
+import { backend, server } from "@dbx-tools/cli-model-proxy";
+
+const db = await backend.DatabricksBackend.create({
+  profile: "my-workspace",
+  fuzzyThreshold: 0.35,
+});
+
+const running = await server.startProxyServer(db, {
+  host: "127.0.0.1",
+  port: 4000,
+  apiKey: process.env.LOCAL_PROXY_KEY,
+});
+
+console.log(running.url);
+```
+
+Use this when tests or local developer tools need a managed proxy lifecycle.
+`server.createProxyServer()` returns the Express app without binding a port.
+
+## How Requests Flow
+
+1. `backend.DatabricksBackend` reads the OpenAI request body and resolves
+   `body.model` through [`@dbx-tools/model`](../../node/model).
+2. The Databricks SDK supplies a fresh authorization header for the workspace.
+3. The proxy forwards the body to the resolved serving endpoint's
+   `/invocations` route.
+4. JSON or SSE response bodies are piped back unchanged.
+
+This keeps the package small: Databricks already speaks the OpenAI schema, so
+the useful work is auth and endpoint resolution.
+
+## Modules
+
+- `cli` - Commander program and `runCli()`.
+- `backend` - `DatabricksBackend`, auth, model resolution, and upstream request
+  forwarding.
+- `server` - Express proxy app and `startProxyServer()`.
+- `defaults` - bind host, port, and invocation path constants.
+
+Endpoint ranking and fuzzy matching come from
+[`@dbx-tools/model`](../../node/model).

package/bin/dbx-tools-model-proxy.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+// GENERATED by projen synth (cli tag) - DO NOT EDIT.
+// Regenerated from ./dbx-tools-model-proxy.ts.
+// Hand edits are overwritten on the next watch; this file is read-only.
+
+// Resolved as a bare specifier so Node looks in THIS file's package rather than the
+// caller's cwd - the only way a globally installed CLI finds its own tsx.
+import { register } from "tsx/esm/api";
+
+register();
+await import(new URL("./dbx-tools-model-proxy.ts", import.meta.url).href);

package/bin/dbx-tools-model-proxy.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env -S npx tsx
+/**
+ * `dbx-tools-model-proxy` entry: a local OpenAI-compatible proxy in front of Databricks
+ * Model Serving. Delegates to the commander program in `../src/cli`.
+ */
+import { CommanderError, runCli } from "../src/cli";
+
+runCli(process.argv).catch((err: unknown) => {
+  if (err instanceof CommanderError) process.exit(err.exitCode);
+  process.stderr.write(`${err instanceof Error ? (err.stack ?? err.message) : String(err)}\n`);
+  process.exit(1);
+});

package/index.ts

@@ -0,0 +1,11 @@
+// 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 backend from "./src/backend";
+export * as cli from "./src/cli";
+export * as defaults from "./src/defaults";
+export * as responses from "./src/responses";
+export * as server from "./src/server";
+export type { BackendOptions } from "./src/backend";
+export type { ProxyServerOptions, StartProxyOptions } from "./src/server";

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@dbx-tools/cli-model-proxy",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/reggie-db/dbx-tools.git",
+    "directory": "workspaces/cli/model-proxy"
+  },
+  "bin": {
+    "dbx-tools-model-proxy": "./bin/dbx-tools-model-proxy.mjs",
+    "dbxt-model-proxy": "./bin/dbx-tools-model-proxy.mjs"
+  },
+  "devDependencies": {
+    "@types/node": "^24.6.0",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.7.0",
+    "@databricks/sdk-experimental": "^0.17.0",
+    "commander": "^15.0.0",
+    "tsx": "^4.23.0",
+    "@dbx-tools/model": "0.3.21",
+    "@dbx-tools/shared-core": "0.3.21",
+    "@dbx-tools/shared-model": "0.3.21"
+  },
+  "main": "index.ts",
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.3.21",
+  "types": "index.ts",
+  "type": "module",
+  "exports": {
+    ".": "./index.ts",
+    "./backend": "./src/backend.ts",
+    "./cli": "./src/cli.ts",
+    "./defaults": "./src/defaults.ts",
+    "./responses": "./src/responses.ts",
+    "./server": "./src/server.ts",
+    "./package.json": "./package.json"
+  },
+  "dbxToolsConfig": {
+    "tags": [
+      "cli"
+    ]
+  },
+  "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"pnpm exec projen\".",
+  "scripts": {
+    "build": "projen build",
+    "compile": "projen compile",
+    "default": "projen default",
+    "package": "projen package",
+    "post-compile": "projen post-compile",
+    "pre-compile": "projen pre-compile",
+    "test": "projen test",
+    "watch": "projen watch",
+    "projen": "projen"
+  }
+}

package/src/backend.ts

@@ -0,0 +1,146 @@
+/**
+ * Databricks backend for the local model proxy.
+ *
+ * Wraps a single default-auth {@link WorkspaceClient} and exposes the three
+ * things the proxy server needs: the workspace serving-endpoint list, fuzzy
+ * name resolution (reusing `@dbx-tools/model`'s {@link resolve.rankModels} so a
+ * loose `"opus"` / `"claude sonnet"` snaps to the best live endpoint id -
+ * match score, then class, then within-class version), and a fresh set of auth
+ * headers per upstream request.
+ *
+ * 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 the proxy never
+ * manages token lifetimes itself - each request is signed with a
+ * currently-valid bearer token.
+ *
+ * The endpoint catalogue is listed once and reused for the process, and
+ * re-listed on a resolve miss so a model deployed after start-up still resolves
+ * on first use - no cache layer, just one lazy load.
+ *
+ * @module
+ */
+
+import { log } from "@dbx-tools/shared-core";
+import { type ServingEndpointSummary } from "@dbx-tools/shared-model";
+import { resolve, serving, type ResolvedModel } from "@dbx-tools/model";
+import { WorkspaceClient } from "@databricks/sdk-experimental";
+
+import { INVOCATIONS_SUFFIX } from "./defaults";
+
+const logger = log.logger("model-proxy/backend");
+
+/** Options for {@link DatabricksBackend.create}. */
+export interface BackendOptions {
+  /** Databricks config profile (`~/.databrickscfg`). Defaults to SDK auth resolution. */
+  profile?: string;
+  /** Override the workspace host; otherwise resolved from SDK auth (env / profile). */
+  host?: string;
+  /** Fuse.js fuzzy threshold (0 = exact, 1 = anything). Defaults to the model package default. */
+  threshold?: number;
+}
+
+export class DatabricksBackend {
+  private readonly client: WorkspaceClient;
+  /** Resolved workspace host, e.g. `https://my-workspace.cloud.databricks.com/`. */
+  readonly host: string;
+  private readonly threshold: number | undefined;
+  /** Lazily loaded endpoint catalogue, reused for the process lifetime. */
+  private endpoints: ServingEndpointSummary[] | undefined;
+
+  private constructor(client: WorkspaceClient, host: string, threshold: number | undefined) {
+    this.client = client;
+    this.host = host;
+    this.threshold = threshold;
+  }
+
+  /**
+   * Build a backend: construct a default-auth workspace client (optionally
+   * pinned to a profile / host) and resolve the workspace host once, so a bad
+   * profile fails at start-up rather than on the first proxied request.
+   */
+  static async create(options: BackendOptions = {}): Promise<DatabricksBackend> {
+    const client = new WorkspaceClient({
+      ...(options.host ? { host: options.host } : {}),
+      ...(options.profile ? { profile: options.profile } : {}),
+    });
+    const host = (await client.config.getHost()).toString();
+    logger.info("connected", { host });
+    return new DatabricksBackend(client, host, options.threshold);
+  }
+
+  /**
+   * The workspace's serving-endpoint catalogue, as the minimal
+   * {@link ServingEndpointSummary} the resolver needs. Loaded lazily and
+   * reused; pass `force` to re-list (used by `/v1/models` and the
+   * resolve-on-miss path).
+   */
+  async models(force = false): Promise<ServingEndpointSummary[]> {
+    if (this.endpoints && !force) return this.endpoints;
+    const out = await serving.listServingEndpointsUncached(this.client);
+    this.endpoints = out;
+    logger.debug("listed endpoints", { count: out.length });
+    return out;
+  }
+
+  /**
+   * Snap a (possibly loose) OpenAI-style model name to the best real serving
+   * endpoint via {@link resolve.rankModels} (the same ranking
+   * {@link resolve.resolveModel} uses): Fuse match (bucketed so version
+   * siblings tie), then class, then within-class version - so `"opus"` prefers
+   * `opus-5` over `opus-4-7`. On a miss the catalogue is re-listed once and
+   * retried, so a freshly deployed model resolves without a restart. Returns
+   * the input unchanged with `matched: false` when nothing scores within the
+   * threshold, so a deliberate endpoint id is never silently rewritten and
+   * Databricks surfaces a clean 404.
+   */
+  async resolve(model: string): Promise<ResolvedModel> {
+    let resolved = this.resolveAgainst(model, await this.models());
+    if (!resolved.matched) {
+      resolved = this.resolveAgainst(model, await this.models(true));
+    }
+    return resolved;
+  }
+
+  /**
+   * Rank `model` against a catalogue snapshot and collapse to a single
+   * {@link ResolvedModel}. Uses {@link resolve.rankModels} with `limit: 1`
+   * rather than Fuse-only {@link serving.resolveModelId}, so equal-score
+   * siblings are broken by class / version.
+   */
+  private resolveAgainst(
+    model: string,
+    endpoints: readonly ServingEndpointSummary[],
+  ): ResolvedModel {
+    const [top] = resolve.rankModels(endpoints, {
+      search: model,
+      limit: 1,
+      ...(this.threshold !== undefined ? { threshold: this.threshold } : {}),
+    });
+    if (!top) return { modelId: model, matched: false };
+    return { modelId: top.endpoint.name, matched: true, score: top.score };
+  }
+
+  /**
+   * Mint auth headers for one upstream request. The SDK refreshes the
+   * underlying token when needed, so every call gets a valid `Authorization`
+   * header without the proxy tracking expiry.
+   */
+  async authHeaders(): Promise<Record<string, string>> {
+    const headers = new Headers();
+    await this.client.config.authenticate(headers);
+    const out: Record<string, string> = {};
+    headers.forEach((value, key) => {
+      out[key] = value;
+    });
+    return out;
+  }
+
+  /** OpenAI-compatible invocations URL for a resolved endpoint id. */
+  invocationsUrl(endpoint: string): string {
+    return new URL(
+      `serving-endpoints/${encodeURIComponent(endpoint)}/${INVOCATIONS_SUFFIX}`,
+      this.host,
+    ).toString();
+  }
+}

package/src/cli.ts

@@ -0,0 +1,200 @@
+/**
+ * `dbx-tools-model-proxy` CLI.
+ *
+ * Run bare, it serves: a loopback OpenAI-compatible endpoint that fronts
+ * Databricks Model Serving with fuzzy model names and per-request auth. `chat`
+ * starts that same proxy and hands off to an off-the-shelf terminal client
+ * wired to it. `models` lists the resolvable endpoints; `resolve` shows what a
+ * fuzzy name snaps to. Auth comes from the standard Databricks SDK resolution
+ * (env vars, `--profile`, or `databricks auth login`).
+ *
+ * @module
+ */
+
+import { spawn } from "node:child_process";
+import type { Server } from "node:http";
+import { Command, CommanderError } from "commander";
+
+import { type ServingEndpointSummary } from "@dbx-tools/shared-model";
+
+import { DatabricksBackend, type BackendOptions } from "./backend";
+import { DEFAULT_BIND_HOST, DEFAULT_PORT } from "./defaults";
+import { startProxyServer } from "./server";
+
+/** Capability flags an endpoint advertises, derived from its task/class. */
+interface EndpointCapabilities {
+  /** OpenAI chat/completions + Responses (what a chat agent like Codex needs). */
+  chat: boolean;
+  /** Embedding (vector) endpoint. */
+  embedding: boolean;
+  /** Function / tool calling. Chat endpoints here support it. */
+  tools: boolean;
+}
+
+/**
+ * Derive an endpoint's capabilities from its Databricks task hint and the
+ * classifier's model class. `llm/v1/chat` (and chat-classed endpoints) are
+ * chat- and tool-capable; `llm/v1/embeddings` (and embedding-classed) are
+ * embedding-only. Keeps capability logic in one place so consumers don't
+ * re-derive it from raw strings.
+ */
+function capabilitiesFor(endpoint: ServingEndpointSummary): EndpointCapabilities {
+  const task = endpoint.task;
+  const cls = endpoint.class;
+  const embedding = task === "llm/v1/embeddings" || cls === "embedding";
+  const chat =
+    !embedding && (task === "llm/v1/chat" || (typeof cls === "string" && cls.startsWith("chat")));
+  return { chat, embedding, tools: chat };
+}
+
+/**
+ * Default terminal client for `chat`, launched via `bunx`. OpenHarness is an
+ * OpenAI-compatible TUI that reads the endpoint straight from the env we inject
+ * (`LLM_PROVIDER=openai-compat` + `OPENAI_BASE_URL`), so no config step is
+ * needed. Override with `--client` / `PROXY_CHAT_CLIENT`.
+ */
+const DEFAULT_CHAT_CLIENT = "bunx @alhazmiai/openharness";
+
+/** Shared `--profile` / `--workspace-host` / `--threshold` flags. */
+interface CommonOpts {
+  profile?: string;
+  workspaceHost?: string;
+  threshold?: string;
+}
+
+/** Shared listen + auth flags for the proxy-starting commands. */
+interface ServeOpts extends CommonOpts {
+  port: string;
+  host: string;
+  apiKey?: string;
+}
+
+/** Map shared CLI flags onto {@link BackendOptions}. */
+function backendOptions(opts: CommonOpts): BackendOptions {
+  return {
+    ...(opts.profile ? { profile: opts.profile } : {}),
+    ...(opts.workspaceHost ? { host: opts.workspaceHost } : {}),
+    ...(opts.threshold !== undefined ? { threshold: Number(opts.threshold) } : {}),
+  };
+}
+
+/** Create the backend and start the proxy from the shared listen flags. */
+async function startProxy(
+  opts: ServeOpts,
+): Promise<{ backend: DatabricksBackend; server: Server; url: string }> {
+  const backend = await DatabricksBackend.create(backendOptions(opts));
+  const apiKey = opts.apiKey ?? process.env.PROXY_API_KEY;
+  const { server, url } = await startProxyServer(backend, {
+    host: opts.host,
+    port: Number(opts.port),
+    ...(apiKey ? { apiKey } : {}),
+  });
+  return { backend, server, url };
+}
+
+/** Build the `dbx-tools-model-proxy` commander program (no side effects until parsed). */
+export function buildProgram(): Command {
+  // Serving is the root action, not a subcommand: the bare command runs the
+  // proxy, and `chat`/`models`/`resolve` are the named detours off it.
+  const program = new Command()
+    .name("dbx-tools-model-proxy")
+    .description("Local OpenAI-compatible proxy to Databricks Model Serving.")
+    .option("-p, --port <port>", "port to listen on", String(DEFAULT_PORT))
+    .option("-H, --host <host>", "address to bind", DEFAULT_BIND_HOST)
+    .option("--profile <profile>", "Databricks config profile")
+    .option("--workspace-host <url>", "override the Databricks workspace host")
+    .option("-t, --threshold <n>", "fuzzy match threshold (0..1)")
+    .option("-k, --api-key <key>", "require this bearer token from local clients")
+    .action(async (opts: ServeOpts) => {
+      const { backend, url } = await startProxy(opts);
+      process.stderr.write(`model-proxy -> ${backend.host}\n`);
+      process.stderr.write(`  OpenAI base URL: ${url}/v1\n`);
+    });
+
+  program
+    .command("chat")
+    .description("Start the proxy and launch a terminal chat client wired to it.")
+    .option("-p, --port <port>", "proxy port", String(DEFAULT_PORT))
+    .option("-H, --host <host>", "proxy bind host", DEFAULT_BIND_HOST)
+    .option("--profile <profile>", "Databricks config profile")
+    .option("--workspace-host <url>", "override the Databricks workspace host")
+    .option("-t, --threshold <n>", "fuzzy match threshold (0..1)")
+    .option("-m, --model <name>", "default model (fuzzy name ok)")
+    .option(
+      "--client <cmd>",
+      "terminal chat CLI to launch (run via your shell)",
+      process.env.PROXY_CHAT_CLIENT ?? DEFAULT_CHAT_CLIENT,
+    )
+    .action(async (opts: ServeOpts & { model?: string; client: string }) => {
+      const { backend, server, url } = await startProxy(opts);
+      const baseUrl = `${url}/v1`;
+      process.stderr.write(
+        `model-proxy -> ${backend.host}\n  OpenAI base URL: ${baseUrl}\n  launching: ${opts.client}\n`,
+      );
+      // Hand off to an off-the-shelf OpenAI-compatible client, pointing it at
+      // the proxy via the standard env vars (plus the provider switches a
+      // couple of popular CLIs read). `shell: true` lets `--client` carry its
+      // own args, e.g. `--client "bunx merlion"`.
+      const child = spawn(opts.client, {
+        stdio: "inherit",
+        shell: true,
+        env: {
+          ...process.env,
+          OPENAI_BASE_URL: baseUrl,
+          OPENAI_API_KEY: process.env.OPENAI_API_KEY ?? "model-proxy",
+          ...(opts.model ? { OPENAI_MODEL: opts.model } : {}),
+          LLM_PROVIDER: "openai-compat",
+          CLAUDE_CODE_USE_OPENAI: "1",
+        },
+      });
+      child.on("exit", (code) => {
+        server.close();
+        process.exit(code ?? 0);
+      });
+      process.on("SIGINT", () => child.kill("SIGINT"));
+    });
+
+  program
+    .command("models")
+    .description("List resolvable Databricks serving endpoints (as JSON).")
+    .option("--profile <profile>", "Databricks config profile")
+    .option("--workspace-host <url>", "override the Databricks workspace host")
+    .option("--chat", "only list chat-capable endpoints")
+    .action(async (opts: CommonOpts & { chat?: boolean }) => {
+      const backend = await DatabricksBackend.create(backendOptions(opts));
+      const endpoints = await backend.models();
+      // Enrich each endpoint with a derived `capabilities` object so consumers
+      // filter on capability rather than re-deriving it from raw `task`/`class`
+      // strings. `chat` = OpenAI chat/completions + Responses (what an agent
+      // like Codex needs); `embedding` = vector endpoints; `tools` = whether the
+      // endpoint supports function/tool calls (all chat endpoints here do).
+      const enriched = endpoints.map((endpoint) => {
+        const caps = capabilitiesFor(endpoint);
+        return { ...endpoint, capabilities: caps };
+      });
+      const out = opts.chat ? enriched.filter((e) => e.capabilities.chat) : enriched;
+      process.stdout.write(`${JSON.stringify(out, null, 2)}\n`);
+    });
+
+  program
+    .command("resolve")
+    .description("Show what a fuzzy model name resolves to (as JSON).")
+    .argument("<query...>", "model name / fuzzy search terms")
+    .option("--profile <profile>", "Databricks config profile")
+    .option("--workspace-host <url>", "override the Databricks workspace host")
+    .option("-t, --threshold <n>", "fuzzy match threshold (0..1)")
+    .action(async (query: string[], opts: CommonOpts) => {
+      const backend = await DatabricksBackend.create(backendOptions(opts));
+      const resolved = await backend.resolve(query.join(" "));
+      process.stdout.write(`${JSON.stringify(resolved, null, 2)}\n`);
+    });
+
+  return program;
+}
+
+/** Parse `argv` and run the matching command. Throws {@link CommanderError} on flag errors. */
+export async function runCli(argv: string[]): Promise<void> {
+  await buildProgram().parseAsync(argv);
+}
+
+export { CommanderError };

package/src/defaults.ts

@@ -0,0 +1,18 @@
+// Default values for the local Databricks model proxy.
+
+/**
+ * Loopback address the proxy binds to by default. Keeps the OpenAI-compatible
+ * endpoint private to the machine unless the operator explicitly opts into a
+ * wider bind (e.g. `0.0.0.0`).
+ */
+export const DEFAULT_BIND_HOST = "127.0.0.1";
+
+/** Default TCP port for the local proxy. */
+export const DEFAULT_PORT = 4000;
+
+/**
+ * Path segment Databricks Model Serving exposes for OpenAI-compatible requests.
+ * Every serving endpoint answers chat / completion / embedding payloads under
+ * `serving-endpoints/<name>/invocations`.
+ */
+export const INVOCATIONS_SUFFIX = "invocations";