@dbx-tools/cli-model-proxy 0.3.44 → 0.4.0

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

@@ -0,0 +1,2 @@
+#!/usr/bin/env -S npx tsx
+export {};

package/lib/bin/dbx-tools-model-proxy.js

@@ -0,0 +1,13 @@
+#!/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.js";
+runCli(process.argv).catch((err) => {
+    if (err instanceof CommanderError)
+        process.exit(err.exitCode);
+    process.stderr.write(`${err instanceof Error ? (err.stack ?? err.message) : String(err)}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGJ4LXRvb2xzLW1vZGVsLXByb3h5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vYmluL2RieC10b29scy1tb2RlbC1wcm94eS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQ0E7OztHQUdHO0FBQ0gsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFFcEQsTUFBTSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxHQUFZLEVBQUUsRUFBRTtJQUMxQyxJQUFJLEdBQUcsWUFBWSxjQUFjO1FBQUUsT0FBTyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDOUQsT0FBTyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsR0FBRyxHQUFHLFlBQVksS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxLQUFLLElBQUksR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQzdGLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFDbEIsQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIjIS91c3IvYmluL2VudiAtUyBucHggdHN4XG4vKipcbiAqIGBkYngtdG9vbHMtbW9kZWwtcHJveHlgIGVudHJ5OiBhIGxvY2FsIE9wZW5BSS1jb21wYXRpYmxlIHByb3h5IGluIGZyb250IG9mIERhdGFicmlja3NcbiAqIE1vZGVsIFNlcnZpbmcuIERlbGVnYXRlcyB0byB0aGUgY29tbWFuZGVyIHByb2dyYW0gaW4gYC4uL3NyYy9jbGlgLlxuICovXG5pbXBvcnQgeyBDb21tYW5kZXJFcnJvciwgcnVuQ2xpIH0gZnJvbSBcIi4uL3NyYy9jbGlcIjtcblxucnVuQ2xpKHByb2Nlc3MuYXJndikuY2F0Y2goKGVycjogdW5rbm93bikgPT4ge1xuICBpZiAoZXJyIGluc3RhbmNlb2YgQ29tbWFuZGVyRXJyb3IpIHByb2Nlc3MuZXhpdChlcnIuZXhpdENvZGUpO1xuICBwcm9jZXNzLnN0ZGVyci53cml0ZShgJHtlcnIgaW5zdGFuY2VvZiBFcnJvciA/IChlcnIuc3RhY2sgPz8gZXJyLm1lc3NhZ2UpIDogU3RyaW5nKGVycil9XFxuYCk7XG4gIHByb2Nlc3MuZXhpdCgxKTtcbn0pO1xuIl19

package/lib/index.d.ts

@@ -0,0 +1,11 @@
+export * as backend from "./src/backend.js";
+export * as cli from "./src/cli.js";
+export * as defaults from "./src/defaults.js";
+export * as server from "./src/server.js";
+export { DatabricksBackend } from "./src/backend.js";
+export type { BackendOptions } from "./src/backend.js";
+export { buildProgram, runCli, CommanderError } from "./src/cli.js";
+export { DEFAULT_BIND_HOST, DEFAULT_PORT, DEFAULT_RETRY, resolveRetryConfig } from "./src/defaults.js";
+export type { RetryConfig } from "./src/defaults.js";
+export { createProxyServer, parseRetryAfterMs, backoffDelayMs, startProxyServer } from "./src/server.js";
+export type { ProxyServerOptions, StartProxyOptions } from "./src/server.js";

package/lib/index.js

@@ -0,0 +1,12 @@
+// 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.js";
+export * as cli from "./src/cli.js";
+export * as defaults from "./src/defaults.js";
+export * as server from "./src/server.js";
+export { DatabricksBackend } from "./src/backend.js";
+export { buildProgram, runCli, CommanderError } from "./src/cli.js";
+export { DEFAULT_BIND_HOST, DEFAULT_PORT, DEFAULT_RETRY, resolveRetryConfig } from "./src/defaults.js";
+export { createProxyServer, parseRetryAfterMs, backoffDelayMs, startProxyServer } from "./src/server.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxPQUFPLEtBQUssT0FBTyxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEtBQUssR0FBRyxNQUFNLFdBQVcsQ0FBQztBQUNqQyxPQUFPLEtBQUssUUFBUSxNQUFNLGdCQUFnQixDQUFDO0FBQzNDLE9BQU8sS0FBSyxNQUFNLE1BQU0sY0FBYyxDQUFDO0FBQ3ZDLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUVsRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sRUFBRSxjQUFjLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFDakUsT0FBTyxFQUFFLGlCQUFpQixFQUFFLFlBQVksRUFBRSxhQUFhLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUVwRyxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsaUJBQWlCLEVBQUUsY0FBYyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gR0VORVJBVEVEIGJ5IHByb2plbiB3YXRjaCAtIERPIE5PVCBFRElULlxuLy8gUmVnZW5lcmF0ZWQgZnJvbSB0aGUgZXhwb3J0aW5nIG1vZHVsZXMgaW4gLi9zcmMuXG4vLyBIYW5kIGVkaXRzIGFyZSBvdmVyd3JpdHRlbiBvbiB0aGUgbmV4dCB3YXRjaDsgdGhpcyBmaWxlIGlzIHJlYWQtb25seS5cblxuZXhwb3J0ICogYXMgYmFja2VuZCBmcm9tIFwiLi9zcmMvYmFja2VuZFwiO1xuZXhwb3J0ICogYXMgY2xpIGZyb20gXCIuL3NyYy9jbGlcIjtcbmV4cG9ydCAqIGFzIGRlZmF1bHRzIGZyb20gXCIuL3NyYy9kZWZhdWx0c1wiO1xuZXhwb3J0ICogYXMgc2VydmVyIGZyb20gXCIuL3NyYy9zZXJ2ZXJcIjtcbmV4cG9ydCB7IERhdGFicmlja3NCYWNrZW5kIH0gZnJvbSBcIi4vc3JjL2JhY2tlbmRcIjtcbmV4cG9ydCB0eXBlIHsgQmFja2VuZE9wdGlvbnMgfSBmcm9tIFwiLi9zcmMvYmFja2VuZFwiO1xuZXhwb3J0IHsgYnVpbGRQcm9ncmFtLCBydW5DbGksIENvbW1hbmRlckVycm9yIH0gZnJvbSBcIi4vc3JjL2NsaVwiO1xuZXhwb3J0IHsgREVGQVVMVF9CSU5EX0hPU1QsIERFRkFVTFRfUE9SVCwgREVGQVVMVF9SRVRSWSwgcmVzb2x2ZVJldHJ5Q29uZmlnIH0gZnJvbSBcIi4vc3JjL2RlZmF1bHRzXCI7XG5leHBvcnQgdHlwZSB7IFJldHJ5Q29uZmlnIH0gZnJvbSBcIi4vc3JjL2RlZmF1bHRzXCI7XG5leHBvcnQgeyBjcmVhdGVQcm94eVNlcnZlciwgcGFyc2VSZXRyeUFmdGVyTXMsIGJhY2tvZmZEZWxheU1zLCBzdGFydFByb3h5U2VydmVyIH0gZnJvbSBcIi4vc3JjL3NlcnZlclwiO1xuZXhwb3J0IHR5cGUgeyBQcm94eVNlcnZlck9wdGlvbnMsIFN0YXJ0UHJveHlPcHRpb25zIH0gZnJvbSBcIi4vc3JjL3NlcnZlclwiO1xuIl19

package/lib/src/backend.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Databricks backend for the local model proxy.
+ *
+ * Wraps a single default-auth {@link WorkspaceClient} and exposes the three
+ * things the proxy server needs, each delegating to `@dbx-tools/model`: the
+ * workspace serving-endpoint list, fuzzy name resolution ({@link
+ * resolve.rankModelIdLive}, 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 ({@link
+ * invoke.authHeaders}).
+ *
+ * What is left here is only the proxy's own policy: which client to construct,
+ * and holding the endpoint catalogue for the process lifetime. The catalogue is
+ * listed once 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 { type ResolvedModel } from "@dbx-tools/model";
+import { type ServingEndpointSummary } from "@dbx-tools/shared-model";
+/** 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 declare class DatabricksBackend {
+    private readonly client;
+    /** Resolved workspace host, e.g. `https://my-workspace.cloud.databricks.com/`. */
+    readonly host: string;
+    private readonly threshold;
+    /** Lazily loaded endpoint catalogue, reused for the process lifetime. */
+    private endpoints;
+    private constructor();
+    /**
+     * 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 create(options?: BackendOptions): Promise<DatabricksBackend>;
+    /**
+     * 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).
+     *
+     * Deliberately the uncached listing: the cached one runs through AppKit's
+     * `CacheManager`, which a plain CLI has no app to initialize.
+     */
+    models(force?: boolean): Promise<ServingEndpointSummary[]>;
+    /**
+     * Snap a (possibly loose) OpenAI-style model name to the best real serving
+     * endpoint. {@link resolve.rankModelIdLive} owns the policy: rank against the
+     * loaded catalogue, and on a miss re-list once and retry so a freshly
+     * deployed model resolves without a restart. An unmatched name comes back
+     * unchanged so a deliberate endpoint id is never silently rewritten.
+     */
+    resolve(model: string): Promise<ResolvedModel>;
+    /**
+     * 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.
+     */
+    authHeaders(): Promise<Record<string, string>>;
+    /** OpenAI-compatible chat-completions invocations URL for a resolved endpoint id. */
+    invocationsUrl(endpoint: string): string;
+    /**
+     * Databricks Responses upstream for a resolved endpoint id
+     * (`/serving-endpoints/responses` for OpenAI-family, `/open-responses` else).
+     */
+    responsesUrl(endpoint: string): string;
+    /** True when the endpoint rejects Chat Completions and needs Responses. */
+    isResponsesOnly(endpoint: string): boolean;
+}

package/lib/src/backend.js

@@ -0,0 +1,100 @@
+/**
+ * Databricks backend for the local model proxy.
+ *
+ * Wraps a single default-auth {@link WorkspaceClient} and exposes the three
+ * things the proxy server needs, each delegating to `@dbx-tools/model`: the
+ * workspace serving-endpoint list, fuzzy name resolution ({@link
+ * resolve.rankModelIdLive}, 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 ({@link
+ * invoke.authHeaders}).
+ *
+ * What is left here is only the proxy's own policy: which client to construct,
+ * and holding the endpoint catalogue for the process lifetime. The catalogue is
+ * listed once 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 { WorkspaceClient } from "@databricks/sdk-experimental";
+import { invoke, resolve, serving } from "@dbx-tools/model";
+import { log } from "@dbx-tools/shared-core";
+const logger = log.logger("model-proxy/backend");
+export class DatabricksBackend {
+    client;
+    /** Resolved workspace host, e.g. `https://my-workspace.cloud.databricks.com/`. */
+    host;
+    threshold;
+    /** Lazily loaded endpoint catalogue, reused for the process lifetime. */
+    endpoints;
+    constructor(client, host, threshold) {
+        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 = {}) {
+        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).
+     *
+     * Deliberately the uncached listing: the cached one runs through AppKit's
+     * `CacheManager`, which a plain CLI has no app to initialize.
+     */
+    async models(force = false) {
+        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. {@link resolve.rankModelIdLive} owns the policy: rank against the
+     * loaded catalogue, and on a miss re-list once and retry so a freshly
+     * deployed model resolves without a restart. An unmatched name comes back
+     * unchanged so a deliberate endpoint id is never silently rewritten.
+     */
+    async resolve(model) {
+        return resolve.rankModelIdLive((force) => this.models(force), model, this.threshold !== undefined ? { threshold: this.threshold } : {});
+    }
+    /**
+     * 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() {
+        return invoke.authHeaders(this.client);
+    }
+    /** OpenAI-compatible chat-completions invocations URL for a resolved endpoint id. */
+    invocationsUrl(endpoint) {
+        return invoke.invocationsUrl(this.host, endpoint);
+    }
+    /**
+     * Databricks Responses upstream for a resolved endpoint id
+     * (`/serving-endpoints/responses` for OpenAI-family, `/open-responses` else).
+     */
+    responsesUrl(endpoint) {
+        return invoke.responsesUpstreamUrl(this.host, endpoint);
+    }
+    /** True when the endpoint rejects Chat Completions and needs Responses. */
+    isResponsesOnly(endpoint) {
+        return invoke.isResponsesOnly(endpoint);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"backend.js","sourceRoot":"","sources":["../../src/backend.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Databricks backend for the local model proxy.\n *\n * Wraps a single default-auth {@link WorkspaceClient} and exposes the three\n * things the proxy server needs, each delegating to `@dbx-tools/model`: the\n * workspace serving-endpoint list, fuzzy name resolution ({@link\n * resolve.rankModelIdLive}, so a loose `\"opus\"` / `\"claude sonnet\"` snaps to\n * the best live endpoint id - match score, then class, then within-class\n * version), and a fresh set of auth headers per upstream request ({@link\n * invoke.authHeaders}).\n *\n * What is left here is only the proxy's own policy: which client to construct,\n * and holding the endpoint catalogue for the process lifetime. The catalogue is\n * listed once and re-listed on a resolve miss, so a model deployed after\n * start-up still resolves on first use - no cache layer, just one lazy load.\n *\n * @module\n */\n\nimport { WorkspaceClient } from \"@databricks/sdk-experimental\";\nimport { invoke, resolve, serving, type ResolvedModel } from \"@dbx-tools/model\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport { type ServingEndpointSummary } from \"@dbx-tools/shared-model\";\n\nconst logger = log.logger(\"model-proxy/backend\");\n\n/** Options for {@link DatabricksBackend.create}. */\nexport interface BackendOptions {\n  /** Databricks config profile (`~/.databrickscfg`). Defaults to SDK auth resolution. */\n  profile?: string;\n  /** Override the workspace host; otherwise resolved from SDK auth (env / profile). */\n  host?: string;\n  /** Fuse.js fuzzy threshold (0 = exact, 1 = anything). Defaults to the model package default. */\n  threshold?: number;\n}\n\nexport class DatabricksBackend {\n  private readonly client: WorkspaceClient;\n  /** Resolved workspace host, e.g. `https://my-workspace.cloud.databricks.com/`. */\n  readonly host: string;\n  private readonly threshold: number | undefined;\n  /** Lazily loaded endpoint catalogue, reused for the process lifetime. */\n  private endpoints: ServingEndpointSummary[] | undefined;\n\n  private constructor(client: WorkspaceClient, host: string, threshold: number | undefined) {\n    this.client = client;\n    this.host = host;\n    this.threshold = threshold;\n  }\n\n  /**\n   * Build a backend: construct a default-auth workspace client (optionally\n   * pinned to a profile / host) and resolve the workspace host once, so a bad\n   * profile fails at start-up rather than on the first proxied request.\n   */\n  static async create(options: BackendOptions = {}): Promise<DatabricksBackend> {\n    const client = new WorkspaceClient({\n      ...(options.host ? { host: options.host } : {}),\n      ...(options.profile ? { profile: options.profile } : {}),\n    });\n    const host = (await client.config.getHost()).toString();\n    logger.info(\"connected\", { host });\n    return new DatabricksBackend(client, host, options.threshold);\n  }\n\n  /**\n   * The workspace's serving-endpoint catalogue, as the minimal\n   * {@link ServingEndpointSummary} the resolver needs. Loaded lazily and\n   * reused; pass `force` to re-list (used by `/v1/models` and the\n   * resolve-on-miss path).\n   *\n   * Deliberately the uncached listing: the cached one runs through AppKit's\n   * `CacheManager`, which a plain CLI has no app to initialize.\n   */\n  async models(force = false): Promise<ServingEndpointSummary[]> {\n    if (this.endpoints && !force) return this.endpoints;\n    const out = await serving.listServingEndpointsUncached(this.client);\n    this.endpoints = out;\n    logger.debug(\"listed endpoints\", { count: out.length });\n    return out;\n  }\n\n  /**\n   * Snap a (possibly loose) OpenAI-style model name to the best real serving\n   * endpoint. {@link resolve.rankModelIdLive} owns the policy: rank against the\n   * loaded catalogue, and on a miss re-list once and retry so a freshly\n   * deployed model resolves without a restart. An unmatched name comes back\n   * unchanged so a deliberate endpoint id is never silently rewritten.\n   */\n  async resolve(model: string): Promise<ResolvedModel> {\n    return resolve.rankModelIdLive(\n      (force) => this.models(force),\n      model,\n      this.threshold !== undefined ? { threshold: this.threshold } : {},\n    );\n  }\n\n  /**\n   * Mint auth headers for one upstream request. The SDK refreshes the\n   * underlying token when needed, so every call gets a valid `Authorization`\n   * header without the proxy tracking expiry.\n   */\n  async authHeaders(): Promise<Record<string, string>> {\n    return invoke.authHeaders(this.client);\n  }\n\n  /** OpenAI-compatible chat-completions invocations URL for a resolved endpoint id. */\n  invocationsUrl(endpoint: string): string {\n    return invoke.invocationsUrl(this.host, endpoint);\n  }\n\n  /**\n   * Databricks Responses upstream for a resolved endpoint id\n   * (`/serving-endpoints/responses` for OpenAI-family, `/open-responses` else).\n   */\n  responsesUrl(endpoint: string): string {\n    return invoke.responsesUpstreamUrl(this.host, endpoint);\n  }\n\n  /** True when the endpoint rejects Chat Completions and needs Responses. */\n  isResponsesOnly(endpoint: string): boolean {\n    return invoke.isResponsesOnly(endpoint);\n  }\n}\n"]}

package/lib/src/cli.d.ts

@@ -0,0 +1,25 @@
+/**
+ * `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`).
+ *
+ * Shared flags (`--profile`, `--workspace-host`, `--threshold`, …) are declared
+ * on the root *and* redeclared on subcommands for help discoverability. Commander
+ * parks the values on the parent when both declare the same flag, so every
+ * subcommand action must read {@link Command.optsWithGlobals} - local `opts`
+ * alone misses `--profile` (env `DATABRICKS_CONFIG_PROFILE` still worked because
+ * the SDK reads that without the CLI flag).
+ *
+ * @module
+ */
+import { Command, CommanderError } from "commander";
+/** Build the `dbx-tools-model-proxy` commander program (no side effects until parsed). */
+export declare function buildProgram(): Command;
+/** Parse `argv` and run the matching command. Throws {@link CommanderError} on flag errors. */
+export declare function runCli(argv: string[]): Promise<void>;
+export { CommanderError };

package/lib/src/cli.js

@@ -0,0 +1,164 @@
+/**
+ * `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`).
+ *
+ * Shared flags (`--profile`, `--workspace-host`, `--threshold`, …) are declared
+ * on the root *and* redeclared on subcommands for help discoverability. Commander
+ * parks the values on the parent when both declare the same flag, so every
+ * subcommand action must read {@link Command.optsWithGlobals} - local `opts`
+ * alone misses `--profile` (env `DATABRICKS_CONFIG_PROFILE` still worked because
+ * the SDK reads that without the CLI flag).
+ *
+ * @module
+ */
+import { spawn } from "node:child_process";
+import { classify } from "@dbx-tools/shared-model";
+import { Command, CommanderError } from "commander";
+import { DatabricksBackend } from "./backend.js";
+import { DEFAULT_BIND_HOST, DEFAULT_PORT, resolveRetryConfig } from "./defaults.js";
+import { startProxyServer } from "./server.js";
+/**
+ * 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";
+/** Map shared CLI flags onto {@link BackendOptions}. */
+function backendOptions(opts) {
+    return {
+        ...(opts.profile ? { profile: opts.profile } : {}),
+        ...(opts.workspaceHost ? { host: opts.workspaceHost } : {}),
+        ...(opts.threshold !== undefined ? { threshold: Number(opts.threshold) } : {}),
+    };
+}
+/**
+ * Subcommand options merged with parent (root) options. Required for shared
+ * flags that are declared on both - Commander stores them on the parent, so
+ * the action's local `opts` alone omits `--profile` / `--workspace-host`.
+ */
+function globalOpts(command) {
+    return command.optsWithGlobals();
+}
+/** Create the backend and start the proxy from the shared listen flags. */
+async function startProxy(opts) {
+    const backend = await DatabricksBackend.create(backendOptions(opts));
+    const apiKey = opts.apiKey ?? process.env.PROXY_API_KEY;
+    // `--no-retry-429` (opts.retry429 === false) is the only explicit override;
+    // otherwise resolveRetryConfig layers PROXY_RETRY_* env then the on-default.
+    const retry = resolveRetryConfig(opts.retry429 === false ? { enabled: false } : {});
+    const { server, url } = await startProxyServer(backend, {
+        host: opts.host,
+        port: Number(opts.port),
+        retry,
+        ...(apiKey ? { apiKey } : {}),
+    });
+    return { backend, server, url };
+}
+/** Shared auth / fuzzy-match flags added to the root and every subcommand. */
+function addAuthOptions(command) {
+    return command
+        .option("--profile <profile>", "Databricks config profile")
+        .option("--workspace-host <url>", "override the Databricks workspace host")
+        .option("-t, --threshold <n>", "fuzzy match threshold (0..1)");
+}
+/** Build the `dbx-tools-model-proxy` commander program (no side effects until parsed). */
+export function buildProgram() {
+    // 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 = addAuthOptions(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("-k, --api-key <key>", "require this bearer token from local clients")
+        .option("--no-retry-429", "relay upstream 429s instead of retrying with backoff (default: retry)")).action(async (opts) => {
+        const { backend, url } = await startProxy(opts);
+        process.stderr.write(`model-proxy -> ${backend.host}\n`);
+        process.stderr.write(`  OpenAI base URL: ${url}/v1\n`);
+    });
+    addAuthOptions(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("-m, --model <name>", "default model (fuzzy name ok)")
+        .option("--no-retry-429", "relay upstream 429s instead of retrying with backoff (default: retry)")
+        .option("--client <cmd>", "terminal chat CLI to launch (run via your shell)", process.env.PROXY_CHAT_CLIENT ?? DEFAULT_CHAT_CLIENT)).action(async (_local, command) => {
+        const opts = globalOpts(command);
+        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"));
+    });
+    addAuthOptions(program
+        .command("models")
+        .description("List resolvable Databricks serving endpoints (as JSON).")
+        .option("--chat", "only list chat-capable endpoints")).action(async (_local, command) => {
+        const opts = globalOpts(command);
+        const backend = await DatabricksBackend.create(backendOptions(opts));
+        const endpoints = await backend.models();
+        const enriched = endpoints.map(enrichEndpoint);
+        const out = opts.chat ? enriched.filter((e) => e.capabilities.chat) : enriched;
+        process.stdout.write(`${JSON.stringify(out, null, 2)}\n`);
+    });
+    addAuthOptions(program
+        .command("resolve")
+        .description("Show what a fuzzy model name resolves to (as JSON).")
+        .argument("<query...>", "model name / fuzzy search terms")).action(async (query, _local, command) => {
+        const opts = globalOpts(command);
+        const backend = await DatabricksBackend.create(backendOptions(opts));
+        const search = query.join(" ");
+        const resolved = await backend.resolve(search);
+        // Same shape as one `models` entry when matched; null when nothing in the
+        // catalogue scores within the threshold (caller can fall back to the query).
+        if (!resolved.matched) {
+            process.stdout.write("null\n");
+            return;
+        }
+        const endpoint = (await backend.models()).find((e) => e.name === resolved.modelId);
+        process.stdout.write(`${JSON.stringify(endpoint ? enrichEndpoint(endpoint) : null, null, 2)}\n`);
+    });
+    return program;
+}
+/** One `models` / `resolve` list entry: endpoint summary + derived capabilities. */
+function enrichEndpoint(endpoint) {
+    return {
+        ...endpoint,
+        // `chat` = OpenAI chat/completions + Responses; `embedding` = vectors;
+        // `tools` = function/tool calls (every chat endpoint here).
+        capabilities: classify.endpointCapabilities(endpoint),
+    };
+}
+/** Parse `argv` and run the matching command. Throws {@link CommanderError} on flag errors. */
+export async function runCli(argv) {
+    await buildProgram().parseAsync(argv);
+}
+export { CommanderError };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `dbx-tools-model-proxy` CLI.\n *\n * Run bare, it serves: a loopback OpenAI-compatible endpoint that fronts\n * Databricks Model Serving with fuzzy model names and per-request auth. `chat`\n * starts that same proxy and hands off to an off-the-shelf terminal client\n * wired to it. `models` lists the resolvable endpoints; `resolve` shows what a\n * fuzzy name snaps to. Auth comes from the standard Databricks SDK resolution\n * (env vars, `--profile`, or `databricks auth login`).\n *\n * Shared flags (`--profile`, `--workspace-host`, `--threshold`, …) are declared\n * on the root *and* redeclared on subcommands for help discoverability. Commander\n * parks the values on the parent when both declare the same flag, so every\n * subcommand action must read {@link Command.optsWithGlobals} - local `opts`\n * alone misses `--profile` (env `DATABRICKS_CONFIG_PROFILE` still worked because\n * the SDK reads that without the CLI flag).\n *\n * @module\n */\n\nimport { spawn } from \"node:child_process\";\nimport type { Server } from \"node:http\";\nimport { classify, type ServingEndpointSummary } from \"@dbx-tools/shared-model\";\nimport { Command, CommanderError } from \"commander\";\n\nimport { DatabricksBackend, type BackendOptions } from \"./backend\";\nimport { DEFAULT_BIND_HOST, DEFAULT_PORT, resolveRetryConfig } from \"./defaults\";\nimport { startProxyServer } from \"./server\";\n\n/**\n * Default terminal client for `chat`, launched via `bunx`. OpenHarness is an\n * OpenAI-compatible TUI that reads the endpoint straight from the env we inject\n * (`LLM_PROVIDER=openai-compat` + `OPENAI_BASE_URL`), so no config step is\n * needed. Override with `--client` / `PROXY_CHAT_CLIENT`.\n */\nconst DEFAULT_CHAT_CLIENT = \"bunx @alhazmiai/openharness\";\n\n/** Shared `--profile` / `--workspace-host` / `--threshold` flags. */\ninterface CommonOpts {\n  profile?: string;\n  workspaceHost?: string;\n  threshold?: string;\n}\n\n/** Shared listen + auth flags for the proxy-starting commands. */\ninterface ServeOpts extends CommonOpts {\n  port: string;\n  host: string;\n  apiKey?: string;\n  /**\n   * Commander's negatable-flag value for `--no-retry-429`: `true` by default,\n   * `false` once the flag is passed. Off means relay upstream 429s unchanged.\n   */\n  retry429: boolean;\n}\n\n/** Map shared CLI flags onto {@link BackendOptions}. */\nfunction backendOptions(opts: CommonOpts): BackendOptions {\n  return {\n    ...(opts.profile ? { profile: opts.profile } : {}),\n    ...(opts.workspaceHost ? { host: opts.workspaceHost } : {}),\n    ...(opts.threshold !== undefined ? { threshold: Number(opts.threshold) } : {}),\n  };\n}\n\n/**\n * Subcommand options merged with parent (root) options. Required for shared\n * flags that are declared on both - Commander stores them on the parent, so\n * the action's local `opts` alone omits `--profile` / `--workspace-host`.\n */\nfunction globalOpts<T>(command: Command): T {\n  return command.optsWithGlobals() as T;\n}\n\n/** Create the backend and start the proxy from the shared listen flags. */\nasync function startProxy(\n  opts: ServeOpts,\n): Promise<{ backend: DatabricksBackend; server: Server; url: string }> {\n  const backend = await DatabricksBackend.create(backendOptions(opts));\n  const apiKey = opts.apiKey ?? process.env.PROXY_API_KEY;\n  // `--no-retry-429` (opts.retry429 === false) is the only explicit override;\n  // otherwise resolveRetryConfig layers PROXY_RETRY_* env then the on-default.\n  const retry = resolveRetryConfig(opts.retry429 === false ? { enabled: false } : {});\n  const { server, url } = await startProxyServer(backend, {\n    host: opts.host,\n    port: Number(opts.port),\n    retry,\n    ...(apiKey ? { apiKey } : {}),\n  });\n  return { backend, server, url };\n}\n\n/** Shared auth / fuzzy-match flags added to the root and every subcommand. */\nfunction addAuthOptions(command: Command): Command {\n  return command\n    .option(\"--profile <profile>\", \"Databricks config profile\")\n    .option(\"--workspace-host <url>\", \"override the Databricks workspace host\")\n    .option(\"-t, --threshold <n>\", \"fuzzy match threshold (0..1)\");\n}\n\n/** Build the `dbx-tools-model-proxy` commander program (no side effects until parsed). */\nexport function buildProgram(): Command {\n  // Serving is the root action, not a subcommand: the bare command runs the\n  // proxy, and `chat`/`models`/`resolve` are the named detours off it.\n  const program = addAuthOptions(\n    new Command()\n      .name(\"dbx-tools-model-proxy\")\n      .description(\"Local OpenAI-compatible proxy to Databricks Model Serving.\")\n      .option(\"-p, --port <port>\", \"port to listen on\", String(DEFAULT_PORT))\n      .option(\"-H, --host <host>\", \"address to bind\", DEFAULT_BIND_HOST)\n      .option(\"-k, --api-key <key>\", \"require this bearer token from local clients\")\n      .option(\n        \"--no-retry-429\",\n        \"relay upstream 429s instead of retrying with backoff (default: retry)\",\n      ),\n  ).action(async (opts: ServeOpts) => {\n    const { backend, url } = await startProxy(opts);\n    process.stderr.write(`model-proxy -> ${backend.host}\\n`);\n    process.stderr.write(`  OpenAI base URL: ${url}/v1\\n`);\n  });\n\n  addAuthOptions(\n    program\n      .command(\"chat\")\n      .description(\"Start the proxy and launch a terminal chat client wired to it.\")\n      .option(\"-p, --port <port>\", \"proxy port\", String(DEFAULT_PORT))\n      .option(\"-H, --host <host>\", \"proxy bind host\", DEFAULT_BIND_HOST)\n      .option(\"-m, --model <name>\", \"default model (fuzzy name ok)\")\n      .option(\n        \"--no-retry-429\",\n        \"relay upstream 429s instead of retrying with backoff (default: retry)\",\n      )\n      .option(\n        \"--client <cmd>\",\n        \"terminal chat CLI to launch (run via your shell)\",\n        process.env.PROXY_CHAT_CLIENT ?? DEFAULT_CHAT_CLIENT,\n      ),\n  ).action(async (_local: ServeOpts & { model?: string; client: string }, command: Command) => {\n    const opts = globalOpts<ServeOpts & { model?: string; client: string }>(command);\n    const { backend, server, url } = await startProxy(opts);\n    const baseUrl = `${url}/v1`;\n    process.stderr.write(\n      `model-proxy -> ${backend.host}\\n  OpenAI base URL: ${baseUrl}\\n  launching: ${opts.client}\\n`,\n    );\n    // Hand off to an off-the-shelf OpenAI-compatible client, pointing it at\n    // the proxy via the standard env vars (plus the provider switches a\n    // couple of popular CLIs read). `shell: true` lets `--client` carry its\n    // own args, e.g. `--client \"bunx merlion\"`.\n    const child = spawn(opts.client, {\n      stdio: \"inherit\",\n      shell: true,\n      env: {\n        ...process.env,\n        OPENAI_BASE_URL: baseUrl,\n        OPENAI_API_KEY: process.env.OPENAI_API_KEY ?? \"model-proxy\",\n        ...(opts.model ? { OPENAI_MODEL: opts.model } : {}),\n        LLM_PROVIDER: \"openai-compat\",\n        CLAUDE_CODE_USE_OPENAI: \"1\",\n      },\n    });\n    child.on(\"exit\", (code) => {\n      server.close();\n      process.exit(code ?? 0);\n    });\n    process.on(\"SIGINT\", () => child.kill(\"SIGINT\"));\n  });\n\n  addAuthOptions(\n    program\n      .command(\"models\")\n      .description(\"List resolvable Databricks serving endpoints (as JSON).\")\n      .option(\"--chat\", \"only list chat-capable endpoints\"),\n  ).action(async (_local: CommonOpts & { chat?: boolean }, command: Command) => {\n    const opts = globalOpts<CommonOpts & { chat?: boolean }>(command);\n    const backend = await DatabricksBackend.create(backendOptions(opts));\n    const endpoints = await backend.models();\n    const enriched = endpoints.map(enrichEndpoint);\n    const out = opts.chat ? enriched.filter((e) => e.capabilities.chat) : enriched;\n    process.stdout.write(`${JSON.stringify(out, null, 2)}\\n`);\n  });\n\n  addAuthOptions(\n    program\n      .command(\"resolve\")\n      .description(\"Show what a fuzzy model name resolves to (as JSON).\")\n      .argument(\"<query...>\", \"model name / fuzzy search terms\"),\n  ).action(async (query: string[], _local: CommonOpts, command: Command) => {\n    const opts = globalOpts<CommonOpts>(command);\n    const backend = await DatabricksBackend.create(backendOptions(opts));\n    const search = query.join(\" \");\n    const resolved = await backend.resolve(search);\n    // Same shape as one `models` entry when matched; null when nothing in the\n    // catalogue scores within the threshold (caller can fall back to the query).\n    if (!resolved.matched) {\n      process.stdout.write(\"null\\n\");\n      return;\n    }\n    const endpoint = (await backend.models()).find((e) => e.name === resolved.modelId);\n    process.stdout.write(\n      `${JSON.stringify(endpoint ? enrichEndpoint(endpoint) : null, null, 2)}\\n`,\n    );\n  });\n\n  return program;\n}\n\n/** One `models` / `resolve` list entry: endpoint summary + derived capabilities. */\nfunction enrichEndpoint(endpoint: ServingEndpointSummary) {\n  return {\n    ...endpoint,\n    // `chat` = OpenAI chat/completions + Responses; `embedding` = vectors;\n    // `tools` = function/tool calls (every chat endpoint here).\n    capabilities: classify.endpointCapabilities(endpoint),\n  };\n}\n\n/** Parse `argv` and run the matching command. Throws {@link CommanderError} on flag errors. */\nexport async function runCli(argv: string[]): Promise<void> {\n  await buildProgram().parseAsync(argv);\n}\n\nexport { CommanderError };\n"]}

package/lib/src/defaults.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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 declare const DEFAULT_BIND_HOST = "127.0.0.1";
+/** Default TCP port for the local proxy. */
+export declare const DEFAULT_PORT = 4000;
+/**
+ * Resolved policy for absorbing upstream `429 Too Many Requests` responses.
+ *
+ * Databricks Foundation Model endpoints are pay-per-token with an account-level
+ * throughput ceiling that is not exposed as a readable number, so the proxy
+ * cannot pace against it proactively - it can only react. When `enabled`, a 429
+ * is retried in-proxy with exponential backoff (honoring any `Retry-After`)
+ * instead of being relayed to the client, so an agentic caller like Codex sees
+ * a slow success rather than "exceeded retry limit".
+ */
+export interface RetryConfig {
+    /** Retry 429s in-proxy rather than relaying them. */
+    enabled: boolean;
+    /** Maximum retry attempts after the initial try (so N+1 total requests). */
+    maxRetries: number;
+    /** First backoff, doubled each attempt (before jitter and the `Retry-After` override). */
+    baseDelayMs: number;
+    /** Ceiling for any single backoff, including a server-sent `Retry-After`. */
+    maxDelayMs: number;
+}
+/** Built-in retry policy: on, with a bounded exponential backoff. */
+export declare const DEFAULT_RETRY: RetryConfig;
+/**
+ * Resolve the 429-retry policy from, in decreasing precedence: an explicit
+ * override (the CLI flag), environment variables, then {@link DEFAULT_RETRY}.
+ *
+ * `enabled` layers as: a CLI `--no-retry-429` (`override.enabled === false`)
+ * always wins; otherwise `PROXY_RETRY_ON_429` (loose boolean via
+ * {@link object.toBoolean}) may switch it off; otherwise it stays on. There is
+ * deliberately no enable flag - the default is on, so the only meaningful
+ * action is disabling.
+ *
+ * Tunables read `PROXY_RETRY_MAX`, `PROXY_RETRY_BASE_MS`, `PROXY_RETRY_MAX_MS`.
+ */
+export declare function resolveRetryConfig(override?: Partial<RetryConfig>): RetryConfig;

package/lib/src/defaults.js

@@ -0,0 +1,48 @@
+// Default values for the local Databricks model proxy.
+import { object } from "@dbx-tools/shared-core";
+/**
+ * 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;
+/** Built-in retry policy: on, with a bounded exponential backoff. */
+export const DEFAULT_RETRY = {
+    enabled: true,
+    maxRetries: 5,
+    baseDelayMs: 500,
+    maxDelayMs: 30_000,
+};
+/** Positive integer from an env var, or `undefined` when unset/unparseable. */
+function envInt(name) {
+    const raw = process.env[name];
+    if (raw === undefined || raw.trim() === "")
+        return undefined;
+    const value = Number(raw);
+    return Number.isFinite(value) && value >= 0 ? Math.floor(value) : undefined;
+}
+/**
+ * Resolve the 429-retry policy from, in decreasing precedence: an explicit
+ * override (the CLI flag), environment variables, then {@link DEFAULT_RETRY}.
+ *
+ * `enabled` layers as: a CLI `--no-retry-429` (`override.enabled === false`)
+ * always wins; otherwise `PROXY_RETRY_ON_429` (loose boolean via
+ * {@link object.toBoolean}) may switch it off; otherwise it stays on. There is
+ * deliberately no enable flag - the default is on, so the only meaningful
+ * action is disabling.
+ *
+ * Tunables read `PROXY_RETRY_MAX`, `PROXY_RETRY_BASE_MS`, `PROXY_RETRY_MAX_MS`.
+ */
+export function resolveRetryConfig(override = {}) {
+    const envEnabled = object.toBoolean(process.env.PROXY_RETRY_ON_429);
+    const enabled = override.enabled ?? envEnabled ?? DEFAULT_RETRY.enabled;
+    return {
+        enabled,
+        maxRetries: override.maxRetries ?? envInt("PROXY_RETRY_MAX") ?? DEFAULT_RETRY.maxRetries,
+        baseDelayMs: override.baseDelayMs ?? envInt("PROXY_RETRY_BASE_MS") ?? DEFAULT_RETRY.baseDelayMs,
+        maxDelayMs: override.maxDelayMs ?? envInt("PROXY_RETRY_MAX_MS") ?? DEFAULT_RETRY.maxDelayMs,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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