@dbx-tools/shared-model 0.3.44 → 0.4.0

package/lib/src/model.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Wire-format types for the model toolkit: the model class taxonomy,
+ * the Foundation Model API score profile, the minimal serving-endpoint
+ * descriptor, and the model-lookup request / ranked-result contract.
+ * Pure types and zod schemas - no Node-only imports - so a browser
+ * client (or an agent tool's `inputSchema`) can validate a lookup
+ * request and type a ranked response without dragging in server
+ * dependencies.
+ *
+ * @module
+ */
+import { z } from "zod";
+/**
+ * Class of a Databricks Model Serving endpoint - its modality plus,
+ * for chat models, a capability band. Chat endpoints split by measured
+ * `quality` into a three-rung ladder; embeddings are a separate
+ * modality, not a rung on that ladder.
+ *
+ * String enum so the value is the slug used in cache keys, logs, query
+ * strings, and serialized configs - and is what a client sends to
+ * request a class.
+ */
+export declare enum ModelClass {
+    ChatThinking = "chat-thinking",
+    ChatBalanced = "chat-balanced",
+    ChatFast = "chat-fast",
+    Embedding = "embedding"
+}
+export declare const ModelClassSchema: z.ZodEnum<typeof ModelClass>;
+/**
+ * Foundation Model API quality / speed / cost scores Databricks
+ * publishes per pay-per-token endpoint (the bars shown in the AI
+ * Playground). Surfaced from the serving list under
+ * `config.served_entities[].foundation_model.ai_gateway_model_profile`
+ * so the class classifier can rank models from live, workspace-local
+ * numbers instead of a hand-maintained table. Scales are relative and
+ * unitless; all axes are absent for custom or brand-new endpoints that
+ * have no profile yet.
+ */
+export declare const ModelProfileSchema: z.ZodObject<{
+    quality: z.ZodOptional<z.ZodNumber>;
+    speed: z.ZodOptional<z.ZodNumber>;
+    cost: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ModelProfile = z.infer<typeof ModelProfileSchema>;
+/**
+ * Minimal descriptor for a Databricks Model Serving endpoint - a
+ * stable subset of the SDK type so cache hits and `/models` responses
+ * never expose SDK internals.
+ */
+export declare const ServingEndpointSummarySchema: z.ZodObject<{
+    name: z.ZodString;
+    displayName: z.ZodOptional<z.ZodString>;
+    task: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    profile: z.ZodOptional<z.ZodObject<{
+        quality: z.ZodOptional<z.ZodNumber>;
+        speed: z.ZodOptional<z.ZodNumber>;
+        cost: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    class: z.ZodOptional<z.ZodEnum<typeof ModelClass>>;
+    dimension: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ServingEndpointSummary = z.infer<typeof ServingEndpointSummarySchema>;
+/**
+ * A model-lookup request: search string, capability ceiling, both, or
+ * nothing. This is the caller-facing query the `@dbx-tools/model`
+ * ranker reads - shaped as a zod schema (with per-field descriptions)
+ * so an agent tool can adopt it directly as its `inputSchema` and a
+ * browser client can validate args before calling the model service.
+ *
+ * Every field is optional: an empty query ranks the live catalogue by
+ * class alone. The "this class and below" ceiling semantics and the
+ * match-then-class ordering live in the service, not here - this
+ * surface is declarative.
+ */
+export declare const ModelQuerySchema: z.ZodObject<{
+    search: z.ZodOptional<z.ZodString>;
+    modelClass: z.ZodOptional<z.ZodEnum<typeof ModelClass>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    threshold: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ModelQuery = z.infer<typeof ModelQuerySchema>;
+/**
+ * One ranked lookup result. Backs an agent tool's `outputSchema` and a
+ * `/models` ranked response.
+ */
+export declare const RankedModelSchema: z.ZodObject<{
+    endpoint: z.ZodObject<{
+        name: z.ZodString;
+        displayName: z.ZodOptional<z.ZodString>;
+        task: z.ZodOptional<z.ZodString>;
+        state: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        profile: z.ZodOptional<z.ZodObject<{
+            quality: z.ZodOptional<z.ZodNumber>;
+            speed: z.ZodOptional<z.ZodNumber>;
+            cost: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        class: z.ZodOptional<z.ZodEnum<typeof ModelClass>>;
+        dimension: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    modelClass: z.ZodEnum<typeof ModelClass>;
+    score: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type RankedModel = z.infer<typeof RankedModelSchema>;

package/lib/src/model.js

@@ -0,0 +1,123 @@
+/**
+ * Wire-format types for the model toolkit: the model class taxonomy,
+ * the Foundation Model API score profile, the minimal serving-endpoint
+ * descriptor, and the model-lookup request / ranked-result contract.
+ * Pure types and zod schemas - no Node-only imports - so a browser
+ * client (or an agent tool's `inputSchema`) can validate a lookup
+ * request and type a ranked response without dragging in server
+ * dependencies.
+ *
+ * @module
+ */
+import { z } from "zod";
+/**
+ * Class of a Databricks Model Serving endpoint - its modality plus,
+ * for chat models, a capability band. Chat endpoints split by measured
+ * `quality` into a three-rung ladder; embeddings are a separate
+ * modality, not a rung on that ladder.
+ *
+ * String enum so the value is the slug used in cache keys, logs, query
+ * strings, and serialized configs - and is what a client sends to
+ * request a class.
+ */
+export var ModelClass;
+(function (ModelClass) {
+    ModelClass["ChatThinking"] = "chat-thinking";
+    ModelClass["ChatBalanced"] = "chat-balanced";
+    ModelClass["ChatFast"] = "chat-fast";
+    ModelClass["Embedding"] = "embedding";
+})(ModelClass || (ModelClass = {}));
+const ModelClassDescriptions = {
+    [ModelClass.ChatThinking]: "Most capable reasoning for hard, multi-step tasks; slowest and most expensive.",
+    [ModelClass.ChatBalanced]: "Good default for most chat and agent work; balances quality, speed, and cost.",
+    [ModelClass.ChatFast]: "Fastest and cheapest; best for simple tasks like classification, routing, and short summaries.",
+    [ModelClass.Embedding]: "Produces text embeddings (vectors), not chat replies; not interchangeable with chat models.",
+};
+export const ModelClassSchema = z.enum(ModelClass).describe(`Endpoint class slug: ${Object.values(ModelClass)
+    .map((modelClass) => {
+    return `'${modelClass}' (${ModelClassDescriptions[modelClass]})`;
+})
+    .join(", ")}.`);
+/**
+ * Foundation Model API quality / speed / cost scores Databricks
+ * publishes per pay-per-token endpoint (the bars shown in the AI
+ * Playground). Surfaced from the serving list under
+ * `config.served_entities[].foundation_model.ai_gateway_model_profile`
+ * so the class classifier can rank models from live, workspace-local
+ * numbers instead of a hand-maintained table. Scales are relative and
+ * unitless; all axes are absent for custom or brand-new endpoints that
+ * have no profile yet.
+ */
+export const ModelProfileSchema = z.object({
+    quality: z.number().optional().describe("Relative quality score; higher is better."),
+    speed: z.number().optional().describe("Relative throughput score; higher is faster."),
+    cost: z.number().optional().describe("Relative price score; lower is cheaper."),
+});
+/**
+ * Minimal descriptor for a Databricks Model Serving endpoint - a
+ * stable subset of the SDK type so cache hits and `/models` responses
+ * never expose SDK internals.
+ */
+export const ServingEndpointSummarySchema = z.object({
+    name: z
+        .string()
+        .describe("Endpoint name as listed by the Model Serving REST API; the id used to invoke the model."),
+    displayName: z
+        .string()
+        .optional()
+        .describe("Human-readable label for the endpoint: a Databricks-provided name when present (a display-name tag or external-model name), else a title-cased rendering of `name` with vendor prefixes stripped. `name` remains the invoke id."),
+    task: z.string().optional().describe("Task hint, e.g. 'llm/v1/chat' or 'llm/v1/embeddings'."),
+    state: z.string().optional().describe("Deployment state, e.g. ready, updating, or failed."),
+    description: z.string().optional().describe("Free-form endpoint description; informational."),
+    profile: ModelProfileSchema.optional().describe("Foundation Model API quality/speed/cost scores when the endpoint is a scored pay-per-token model; absent otherwise."),
+    class: ModelClassSchema.optional().describe("Class the endpoint was classified into; absent when the classifier doesn't recognize it."),
+    dimension: z
+        .number()
+        .optional()
+        .describe("Embedding vector length, measured by a best-effort server-side ping. Only set for embedding endpoints, and only when the probe succeeded."),
+});
+/**
+ * A model-lookup request: search string, capability ceiling, both, or
+ * nothing. This is the caller-facing query the `@dbx-tools/model`
+ * ranker reads - shaped as a zod schema (with per-field descriptions)
+ * so an agent tool can adopt it directly as its `inputSchema` and a
+ * browser client can validate args before calling the model service.
+ *
+ * Every field is optional: an empty query ranks the live catalogue by
+ * class alone. The "this class and below" ceiling semantics and the
+ * match-then-class ordering live in the service, not here - this
+ * surface is declarative.
+ */
+export const ModelQuerySchema = z.object({
+    search: z
+        .string()
+        .optional()
+        .describe("Loose name fuzzy-matched against endpoint names, e.g. 'claude sonnet'. Omit to rank by class alone."),
+    modelClass: ModelClassSchema.optional().describe("Capability ceiling: a chat class restricts to that band and the less-capable chat bands below it; 'embedding' restricts to embedding endpoints. Omit to consider every chat band."),
+    limit: z
+        .number()
+        .int()
+        .positive()
+        .max(50)
+        .optional()
+        .describe("Maximum number of ranked results to return."),
+    threshold: z
+        .number()
+        .min(0)
+        .max(1)
+        .optional()
+        .describe("Fuzzy-match distance cutoff (0 = exact, 1 = match anything). Default 0.4."),
+});
+/**
+ * One ranked lookup result. Backs an agent tool's `outputSchema` and a
+ * `/models` ranked response.
+ */
+export const RankedModelSchema = z.object({
+    endpoint: ServingEndpointSummarySchema.describe("The matched serving endpoint."),
+    modelClass: ModelClassSchema.describe("Class the endpoint was classified into."),
+    score: z
+        .number()
+        .optional()
+        .describe("Fuzzy-match distance (0 = exact .. 1 = worst) when the query carried a search; absent for class-only ranking."),
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model.js","sourceRoot":"","sources":["../../src/model.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Wire-format types for the model toolkit: the model class taxonomy,\n * the Foundation Model API score profile, the minimal serving-endpoint\n * descriptor, and the model-lookup request / ranked-result contract.\n * Pure types and zod schemas - no Node-only imports - so a browser\n * client (or an agent tool's `inputSchema`) can validate a lookup\n * request and type a ranked response without dragging in server\n * dependencies.\n *\n * @module\n */\n\nimport { z } from \"zod\";\n\n/**\n * Class of a Databricks Model Serving endpoint - its modality plus,\n * for chat models, a capability band. Chat endpoints split by measured\n * `quality` into a three-rung ladder; embeddings are a separate\n * modality, not a rung on that ladder.\n *\n * String enum so the value is the slug used in cache keys, logs, query\n * strings, and serialized configs - and is what a client sends to\n * request a class.\n */\nexport enum ModelClass {\n  ChatThinking = \"chat-thinking\",\n  ChatBalanced = \"chat-balanced\",\n  ChatFast = \"chat-fast\",\n  Embedding = \"embedding\",\n}\n\nconst ModelClassDescriptions: Record<ModelClass, string> = {\n  [ModelClass.ChatThinking]:\n    \"Most capable reasoning for hard, multi-step tasks; slowest and most expensive.\",\n  [ModelClass.ChatBalanced]:\n    \"Good default for most chat and agent work; balances quality, speed, and cost.\",\n  [ModelClass.ChatFast]:\n    \"Fastest and cheapest; best for simple tasks like classification, routing, and short summaries.\",\n  [ModelClass.Embedding]:\n    \"Produces text embeddings (vectors), not chat replies; not interchangeable with chat models.\",\n};\n\nexport const ModelClassSchema = z.enum(ModelClass).describe(\n  `Endpoint class slug: ${(Object.values(ModelClass) as ModelClass[])\n    .map((modelClass) => {\n      return `'${modelClass}' (${ModelClassDescriptions[modelClass]})`;\n    })\n    .join(\", \")}.`,\n);\n\n/**\n * Foundation Model API quality / speed / cost scores Databricks\n * publishes per pay-per-token endpoint (the bars shown in the AI\n * Playground). Surfaced from the serving list under\n * `config.served_entities[].foundation_model.ai_gateway_model_profile`\n * so the class classifier can rank models from live, workspace-local\n * numbers instead of a hand-maintained table. Scales are relative and\n * unitless; all axes are absent for custom or brand-new endpoints that\n * have no profile yet.\n */\nexport const ModelProfileSchema = z.object({\n  quality: z.number().optional().describe(\"Relative quality score; higher is better.\"),\n  speed: z.number().optional().describe(\"Relative throughput score; higher is faster.\"),\n  cost: z.number().optional().describe(\"Relative price score; lower is cheaper.\"),\n});\nexport type ModelProfile = z.infer<typeof ModelProfileSchema>;\n\n/**\n * Minimal descriptor for a Databricks Model Serving endpoint - a\n * stable subset of the SDK type so cache hits and `/models` responses\n * never expose SDK internals.\n */\nexport const ServingEndpointSummarySchema = z.object({\n  name: z\n    .string()\n    .describe(\n      \"Endpoint name as listed by the Model Serving REST API; the id used to invoke the model.\",\n    ),\n  displayName: z\n    .string()\n    .optional()\n    .describe(\n      \"Human-readable label for the endpoint: a Databricks-provided name when present (a display-name tag or external-model name), else a title-cased rendering of `name` with vendor prefixes stripped. `name` remains the invoke id.\",\n    ),\n  task: z.string().optional().describe(\"Task hint, e.g. 'llm/v1/chat' or 'llm/v1/embeddings'.\"),\n  state: z.string().optional().describe(\"Deployment state, e.g. ready, updating, or failed.\"),\n  description: z.string().optional().describe(\"Free-form endpoint description; informational.\"),\n  profile: ModelProfileSchema.optional().describe(\n    \"Foundation Model API quality/speed/cost scores when the endpoint is a scored pay-per-token model; absent otherwise.\",\n  ),\n  class: ModelClassSchema.optional().describe(\n    \"Class the endpoint was classified into; absent when the classifier doesn't recognize it.\",\n  ),\n  dimension: z\n    .number()\n    .optional()\n    .describe(\n      \"Embedding vector length, measured by a best-effort server-side ping. Only set for embedding endpoints, and only when the probe succeeded.\",\n    ),\n});\nexport type ServingEndpointSummary = z.infer<typeof ServingEndpointSummarySchema>;\n\n/**\n * A model-lookup request: search string, capability ceiling, both, or\n * nothing. This is the caller-facing query the `@dbx-tools/model`\n * ranker reads - shaped as a zod schema (with per-field descriptions)\n * so an agent tool can adopt it directly as its `inputSchema` and a\n * browser client can validate args before calling the model service.\n *\n * Every field is optional: an empty query ranks the live catalogue by\n * class alone. The \"this class and below\" ceiling semantics and the\n * match-then-class ordering live in the service, not here - this\n * surface is declarative.\n */\nexport const ModelQuerySchema = z.object({\n  search: z\n    .string()\n    .optional()\n    .describe(\n      \"Loose name fuzzy-matched against endpoint names, e.g. 'claude sonnet'. Omit to rank by class alone.\",\n    ),\n  modelClass: ModelClassSchema.optional().describe(\n    \"Capability ceiling: a chat class restricts to that band and the less-capable chat bands below it; 'embedding' restricts to embedding endpoints. Omit to consider every chat band.\",\n  ),\n  limit: z\n    .number()\n    .int()\n    .positive()\n    .max(50)\n    .optional()\n    .describe(\"Maximum number of ranked results to return.\"),\n  threshold: z\n    .number()\n    .min(0)\n    .max(1)\n    .optional()\n    .describe(\"Fuzzy-match distance cutoff (0 = exact, 1 = match anything). Default 0.4.\"),\n});\nexport type ModelQuery = z.infer<typeof ModelQuerySchema>;\n\n/**\n * One ranked lookup result. Backs an agent tool's `outputSchema` and a\n * `/models` ranked response.\n */\nexport const RankedModelSchema = z.object({\n  endpoint: ServingEndpointSummarySchema.describe(\"The matched serving endpoint.\"),\n  modelClass: ModelClassSchema.describe(\"Class the endpoint was classified into.\"),\n  score: z\n    .number()\n    .optional()\n    .describe(\n      \"Fuzzy-match distance (0 = exact .. 1 = worst) when the query carried a search; absent for class-only ranking.\",\n    ),\n});\nexport type RankedModel = z.infer<typeof RankedModelSchema>;\n"]}

package/lib/src/openai-chat.d.ts

@@ -0,0 +1,108 @@
+/**
+ * OpenAI Chat Completions wire shapes, as Databricks Model Serving speaks them.
+ *
+ * These are the request/reply payload types for `/chat/completions` and a
+ * serving endpoint's `invocations` URL. They are deliberately declared here
+ * rather than imported from the OpenAI or AI SDK packages: both keep these
+ * fields under internal namespaces that are not part of their public API,
+ * whereas the wire payload itself is the stable contract every caller in this
+ * repo actually codes against.
+ *
+ * Pure types plus one text-flattening helper - no zod, no runtime deps - so a
+ * browser client, a Node proxy, and an AppKit plugin can all agree on the shape
+ * without any of them pulling in the others' dependencies.
+ *
+ * @module
+ */
+/**
+ * The roles OpenAI defines for a chat turn. {@link ChatMessage.role} is typed as
+ * a plain string rather than this union, because providers add their own (for
+ * example Databricks-hosted Claude replays a `"reasoning"` turn); use this when
+ * you want the standard set named.
+ */
+export type ChatRole = "system" | "developer" | "user" | "assistant" | "tool";
+/**
+ * One entry of a structured `content` array. Only `type` and `text` are read
+ * here; the index signature keeps provider-specific parts (images, thinking
+ * blocks, cache markers) intact through a parse/serialize round trip.
+ */
+export interface ChatContentPart {
+    type?: string;
+    text?: string;
+    [key: string]: unknown;
+}
+/** The function a tool call invokes, with its arguments as a JSON string. */
+export interface ChatToolCallFunction {
+    name: string;
+    /** JSON-encoded argument object. Streamed in fragments, so assemble before parsing. */
+    arguments: string;
+}
+/** One tool call attached to an assistant turn. */
+export interface ChatToolCall {
+    id: string;
+    /** `"function"` in practice; widened so an unrecognized type round-trips. */
+    type: string;
+    function: ChatToolCallFunction;
+}
+/**
+ * A single chat message. `content` is nullable because an assistant turn that
+ * only calls tools carries `content: null`.
+ */
+export interface ChatMessage {
+    /** See {@link ChatRole} for the standard values; widened for provider extensions. */
+    role: string;
+    content?: string | ChatContentPart[] | null;
+    tool_calls?: ChatToolCall[];
+    /** Set on a `tool` turn, keying it back to the call it answers. */
+    tool_call_id?: string;
+    name?: string;
+}
+/**
+ * Top-level request fields an OpenAI client may send that Databricks Model
+ * Serving rejects outright, failing the whole turn rather than ignoring them.
+ *
+ * Databricks validates the chat body strictly, so an unrecognized key comes
+ * back as `parallel_tool_calls: Extra inputs are not permitted` (the
+ * gateway's pydantic validation) or `json: unknown field "parallel_tool_calls"`
+ * (its strict JSON decode), depending on the endpoint. Everything listed here
+ * is either OpenAI-platform bookkeeping with no bearing on the completion, or -
+ * in the case of `parallel_tool_calls` - a real setting Databricks has no way
+ * to accept, so dropping it is the only way the request can succeed at all.
+ *
+ * Callers that translate a request field-by-field (an allowlist, as
+ * `openaiResponses.responsesToChat` does) never need this; it exists for the
+ * paths that forward a client body largely as-is.
+ */
+export declare const UNSUPPORTED_CHAT_FIELDS: readonly string[];
+/**
+ * Delete the fields Databricks rejects from a chat request body, in place.
+ * Returns the names actually removed so a caller can log what it dropped.
+ *
+ * @param body - Parsed chat request body. Mutated.
+ * @param extra - Additional field names to drop, for a workspace or endpoint
+ *   that rejects something not yet in {@link UNSUPPORTED_CHAT_FIELDS}.
+ */
+export declare function stripUnsupportedChatFields(body: Record<string, unknown>, extra?: readonly string[]): string[];
+/** Options for {@link chatContentToText}. */
+export interface ChatContentToTextOptions {
+    /**
+     * Placed between parts. Defaults to `""`, which reassembles a message that was
+     * split purely for transport; pass `"\n\n"` when the parts are separate
+     * paragraphs that a human will read.
+     */
+    separator?: string;
+    /**
+     * Restrict to these `type` values. Defaults to accepting any part carrying
+     * `text`, which covers the `input_text` / `output_text` / `text` spellings
+     * different APIs use for the same thing.
+     */
+    types?: readonly string[];
+}
+/**
+ * Flatten a message `content` value to plain text. Accepts the string form and
+ * the structured-parts form ({@link ChatContentPart}), and yields `""` for
+ * anything else (null, a lone image part, a malformed payload). Typed as
+ * `unknown` because most callers are reading a just-parsed JSON body, and the
+ * point of this helper is that they do not have to pre-check it.
+ */
+export declare function chatContentToText(content: unknown, options?: ChatContentToTextOptions): string;

package/lib/src/openai-chat.js

@@ -0,0 +1,87 @@
+/**
+ * OpenAI Chat Completions wire shapes, as Databricks Model Serving speaks them.
+ *
+ * These are the request/reply payload types for `/chat/completions` and a
+ * serving endpoint's `invocations` URL. They are deliberately declared here
+ * rather than imported from the OpenAI or AI SDK packages: both keep these
+ * fields under internal namespaces that are not part of their public API,
+ * whereas the wire payload itself is the stable contract every caller in this
+ * repo actually codes against.
+ *
+ * Pure types plus one text-flattening helper - no zod, no runtime deps - so a
+ * browser client, a Node proxy, and an AppKit plugin can all agree on the shape
+ * without any of them pulling in the others' dependencies.
+ *
+ * @module
+ */
+/**
+ * Top-level request fields an OpenAI client may send that Databricks Model
+ * Serving rejects outright, failing the whole turn rather than ignoring them.
+ *
+ * Databricks validates the chat body strictly, so an unrecognized key comes
+ * back as `parallel_tool_calls: Extra inputs are not permitted` (the
+ * gateway's pydantic validation) or `json: unknown field "parallel_tool_calls"`
+ * (its strict JSON decode), depending on the endpoint. Everything listed here
+ * is either OpenAI-platform bookkeeping with no bearing on the completion, or -
+ * in the case of `parallel_tool_calls` - a real setting Databricks has no way
+ * to accept, so dropping it is the only way the request can succeed at all.
+ *
+ * Callers that translate a request field-by-field (an allowlist, as
+ * `openaiResponses.responsesToChat` does) never need this; it exists for the
+ * paths that forward a client body largely as-is.
+ */
+export const UNSUPPORTED_CHAT_FIELDS = [
+    // Tool-calling concurrency hint. Databricks rejects it; the upstream provider
+    // decides parallelism itself.
+    "parallel_tool_calls",
+    // Response-persistence and bookkeeping fields for OpenAI's own platform.
+    "store",
+    "metadata",
+    "service_tier",
+    "prompt_cache_key",
+    "safety_identifier",
+];
+/**
+ * Delete the fields Databricks rejects from a chat request body, in place.
+ * Returns the names actually removed so a caller can log what it dropped.
+ *
+ * @param body - Parsed chat request body. Mutated.
+ * @param extra - Additional field names to drop, for a workspace or endpoint
+ *   that rejects something not yet in {@link UNSUPPORTED_CHAT_FIELDS}.
+ */
+export function stripUnsupportedChatFields(body, extra = []) {
+    const dropped = [];
+    for (const field of [...UNSUPPORTED_CHAT_FIELDS, ...extra]) {
+        if (!(field in body))
+            continue;
+        delete body[field];
+        dropped.push(field);
+    }
+    return dropped;
+}
+/**
+ * Flatten a message `content` value to plain text. Accepts the string form and
+ * the structured-parts form ({@link ChatContentPart}), and yields `""` for
+ * anything else (null, a lone image part, a malformed payload). Typed as
+ * `unknown` because most callers are reading a just-parsed JSON body, and the
+ * point of this helper is that they do not have to pre-check it.
+ */
+export function chatContentToText(content, options = {}) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    const { separator = "", types } = options;
+    const parts = [];
+    for (const raw of content) {
+        if (!raw || typeof raw !== "object")
+            continue;
+        const part = raw;
+        if (types && (typeof part.type !== "string" || !types.includes(part.type)))
+            continue;
+        if (typeof part.text === "string")
+            parts.push(part.text);
+    }
+    return parts.join(separator);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"openai-chat.js","sourceRoot":"","sources":["../../src/openai-chat.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAkDH;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAsB;IACxD,8EAA8E;IAC9E,8BAA8B;IAC9B,qBAAqB;IACrB,yEAAyE;IACzE,OAAO;IACP,UAAU;IACV,cAAc;IACd,kBAAkB;IAClB,mBAAmB;CACpB,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,UAAU,0BAA0B,CACxC,IAA6B,EAC7B,QAA2B,EAAE;IAE7B,MAAM,OAAO,GAAa,EAAE,CAAC;IAC7B,KAAK,MAAM,KAAK,IAAI,CAAC,GAAG,uBAAuB,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC;QAC3D,IAAI,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC;YAAE,SAAS;QAC/B,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC;QACnB,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACtB,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAkBD;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAC/B,OAAgB,EAChB,UAAoC,EAAE;IAEtC,IAAI,OAAO,OAAO,KAAK,QAAQ;QAAE,OAAO,OAAO,CAAC;IAChD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;QAAE,OAAO,EAAE,CAAC;IACvC,MAAM,EAAE,SAAS,GAAG,EAAE,EAAE,KAAK,EAAE,GAAG,OAAO,CAAC;IAC1C,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,KAAK,MAAM,GAAG,IAAI,OAAO,EAAE,CAAC;QAC1B,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ;YAAE,SAAS;QAC9C,MAAM,IAAI,GAAG,GAAsB,CAAC;QACpC,IAAI,KAAK,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAAE,SAAS;QACrF,IAAI,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ;YAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC3D,CAAC;IACD,OAAO,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AAC/B,CAAC","sourcesContent":["/**\n * OpenAI Chat Completions wire shapes, as Databricks Model Serving speaks them.\n *\n * These are the request/reply payload types for `/chat/completions` and a\n * serving endpoint's `invocations` URL. They are deliberately declared here\n * rather than imported from the OpenAI or AI SDK packages: both keep these\n * fields under internal namespaces that are not part of their public API,\n * whereas the wire payload itself is the stable contract every caller in this\n * repo actually codes against.\n *\n * Pure types plus one text-flattening helper - no zod, no runtime deps - so a\n * browser client, a Node proxy, and an AppKit plugin can all agree on the shape\n * without any of them pulling in the others' dependencies.\n *\n * @module\n */\n\n/**\n * The roles OpenAI defines for a chat turn. {@link ChatMessage.role} is typed as\n * a plain string rather than this union, because providers add their own (for\n * example Databricks-hosted Claude replays a `\"reasoning\"` turn); use this when\n * you want the standard set named.\n */\nexport type ChatRole = \"system\" | \"developer\" | \"user\" | \"assistant\" | \"tool\";\n\n/**\n * One entry of a structured `content` array. Only `type` and `text` are read\n * here; the index signature keeps provider-specific parts (images, thinking\n * blocks, cache markers) intact through a parse/serialize round trip.\n */\nexport interface ChatContentPart {\n  type?: string;\n  text?: string;\n  [key: string]: unknown;\n}\n\n/** The function a tool call invokes, with its arguments as a JSON string. */\nexport interface ChatToolCallFunction {\n  name: string;\n  /** JSON-encoded argument object. Streamed in fragments, so assemble before parsing. */\n  arguments: string;\n}\n\n/** One tool call attached to an assistant turn. */\nexport interface ChatToolCall {\n  id: string;\n  /** `\"function\"` in practice; widened so an unrecognized type round-trips. */\n  type: string;\n  function: ChatToolCallFunction;\n}\n\n/**\n * A single chat message. `content` is nullable because an assistant turn that\n * only calls tools carries `content: null`.\n */\nexport interface ChatMessage {\n  /** See {@link ChatRole} for the standard values; widened for provider extensions. */\n  role: string;\n  content?: string | ChatContentPart[] | null;\n  tool_calls?: ChatToolCall[];\n  /** Set on a `tool` turn, keying it back to the call it answers. */\n  tool_call_id?: string;\n  name?: string;\n}\n\n/**\n * Top-level request fields an OpenAI client may send that Databricks Model\n * Serving rejects outright, failing the whole turn rather than ignoring them.\n *\n * Databricks validates the chat body strictly, so an unrecognized key comes\n * back as `parallel_tool_calls: Extra inputs are not permitted` (the\n * gateway's pydantic validation) or `json: unknown field \"parallel_tool_calls\"`\n * (its strict JSON decode), depending on the endpoint. Everything listed here\n * is either OpenAI-platform bookkeeping with no bearing on the completion, or -\n * in the case of `parallel_tool_calls` - a real setting Databricks has no way\n * to accept, so dropping it is the only way the request can succeed at all.\n *\n * Callers that translate a request field-by-field (an allowlist, as\n * `openaiResponses.responsesToChat` does) never need this; it exists for the\n * paths that forward a client body largely as-is.\n */\nexport const UNSUPPORTED_CHAT_FIELDS: readonly string[] = [\n  // Tool-calling concurrency hint. Databricks rejects it; the upstream provider\n  // decides parallelism itself.\n  \"parallel_tool_calls\",\n  // Response-persistence and bookkeeping fields for OpenAI's own platform.\n  \"store\",\n  \"metadata\",\n  \"service_tier\",\n  \"prompt_cache_key\",\n  \"safety_identifier\",\n];\n\n/**\n * Delete the fields Databricks rejects from a chat request body, in place.\n * Returns the names actually removed so a caller can log what it dropped.\n *\n * @param body - Parsed chat request body. Mutated.\n * @param extra - Additional field names to drop, for a workspace or endpoint\n *   that rejects something not yet in {@link UNSUPPORTED_CHAT_FIELDS}.\n */\nexport function stripUnsupportedChatFields(\n  body: Record<string, unknown>,\n  extra: readonly string[] = [],\n): string[] {\n  const dropped: string[] = [];\n  for (const field of [...UNSUPPORTED_CHAT_FIELDS, ...extra]) {\n    if (!(field in body)) continue;\n    delete body[field];\n    dropped.push(field);\n  }\n  return dropped;\n}\n\n/** Options for {@link chatContentToText}. */\nexport interface ChatContentToTextOptions {\n  /**\n   * Placed between parts. Defaults to `\"\"`, which reassembles a message that was\n   * split purely for transport; pass `\"\\n\\n\"` when the parts are separate\n   * paragraphs that a human will read.\n   */\n  separator?: string;\n  /**\n   * Restrict to these `type` values. Defaults to accepting any part carrying\n   * `text`, which covers the `input_text` / `output_text` / `text` spellings\n   * different APIs use for the same thing.\n   */\n  types?: readonly string[];\n}\n\n/**\n * Flatten a message `content` value to plain text. Accepts the string form and\n * the structured-parts form ({@link ChatContentPart}), and yields `\"\"` for\n * anything else (null, a lone image part, a malformed payload). Typed as\n * `unknown` because most callers are reading a just-parsed JSON body, and the\n * point of this helper is that they do not have to pre-check it.\n */\nexport function chatContentToText(\n  content: unknown,\n  options: ChatContentToTextOptions = {},\n): string {\n  if (typeof content === \"string\") return content;\n  if (!Array.isArray(content)) return \"\";\n  const { separator = \"\", types } = options;\n  const parts: string[] = [];\n  for (const raw of content) {\n    if (!raw || typeof raw !== \"object\") continue;\n    const part = raw as ChatContentPart;\n    if (types && (typeof part.type !== \"string\" || !types.includes(part.type))) continue;\n    if (typeof part.text === \"string\") parts.push(part.text);\n  }\n  return parts.join(separator);\n}\n"]}

package/lib/src/openai-responses.d.ts

@@ -0,0 +1,175 @@
+/**
+ * OpenAI Responses API <-> Chat Completions translation.
+ *
+ * Some clients speak only the Responses API (`POST /v1/responses`) - the Codex
+ * CLI is the motivating one. Databricks now also exposes native Responses
+ * surfaces (`/serving-endpoints/responses` and `/serving-endpoints/open-responses`),
+ * while most endpoints still speak Chat Completions at `/invocations`. This
+ * module bridges the two, in both directions:
+ *
+ *   - {@link responsesToChat} lowers a Responses request body to a chat
+ *     completions body (instructions -> system message, typed `input` items ->
+ *     `messages`, `tools`/`tool_choice` carried through, function-call outputs
+ *     folded back into the transcript).
+ *   - {@link chatToResponsesRequest} raises a chat-completions request into a
+ *     Responses request (the inverse of {@link responsesToChat}), for routing a
+ *     chat client at a Responses-only model like Codex.
+ *   - {@link chatToResponse} lifts a non-streaming chat completion back into a
+ *     Responses `response` object.
+ *   - {@link responseToChatCompletion} lifts a native Responses `response`
+ *     back into a chat-completions body (the inverse of {@link chatToResponse}).
+ *   - {@link createResponsesStreamTranslator} lifts a streaming chat completion
+ *     (an OpenAI SSE `chat.completion.chunk` stream) into the Responses SSE
+ *     event stream those clients consume (`response.created`,
+ *     `response.output_text.delta`, function-call argument deltas,
+ *     `response.completed`).
+ *   - {@link readResponsesOutput} reads the other direction: pull the answer
+ *     text and citations out of a `response` object returned by an endpoint
+ *     that speaks Responses natively (the Databricks native web-search tool).
+ *   - {@link sanitizeResponsesTools} keeps only `function` tools on a Responses
+ *     request body (for `/open-responses` / Anthropic, which reject Codex
+ *     built-ins like `web_search`).
+ *   - {@link sanitizeOpenResponsesInput} rewrites `output_*` content part types
+ *     in `input` to `input_*`, and drops Claude thinking / reasoning blocks
+ *     that Open Responses rejects on replay (`redacted_thinking`, …).
+ *
+ * Only the surface real clients exercise is translated; unknown fields are
+ * ignored rather than rejected, so a newer client degrades instead of breaking.
+ *
+ * Browser-safe: pure functions over plain JSON, no transport and no Node
+ * built-ins, so the same translation runs in a proxy, a server route, or a test.
+ *
+ * @module
+ */
+/**
+ * Lower a Responses request body to a chat-completions body. Returns the chat
+ * body plus whether the caller asked for streaming (the server needs it to pick
+ * the upstream `accept` header and the translation path).
+ */
+export declare function responsesToChat(body: Record<string, unknown>): {
+    chat: Record<string, unknown>;
+    stream: boolean;
+};
+/**
+ * Raise a chat-completions request into a Responses request body. Inverse of
+ * {@link responsesToChat}: used when a chat client hits a Responses-only
+ * Databricks model (e.g. Codex) so the proxy can POST to
+ * `/serving-endpoints/responses` without the client knowing.
+ */
+export declare function chatToResponsesRequest(body: Record<string, unknown>): {
+    responses: Record<string, unknown>;
+    stream: boolean;
+};
+/** Lift a non-streaming chat completion JSON into a Responses `response` object. */
+export declare function chatToResponse(chat: Record<string, unknown>, model: string): unknown;
+/**
+ * Lift a native Responses `response` object into a chat-completions body.
+ * Inverse of {@link chatToResponse}: used after a Responses-only upstream call
+ * when the client spoke Chat Completions.
+ */
+export declare function responseToChatCompletion(response: Record<string, unknown>, model: string): Record<string, unknown>;
+/**
+ * Incremental chat-chunk -> Responses-SSE translator. `feed` and `finish` both
+ * return the SSE bytes to forward, or `""` when a chunk produced no event.
+ */
+export interface ResponsesStreamTranslator {
+    /** Translate one upstream `chat.completion.chunk` object. */
+    feed(chunk: Record<string, unknown>): string;
+    /** Close any open items and emit `response.completed`. Call once, at end of stream. */
+    finish(): string;
+}
+/**
+ * Translate an upstream chat-completions SSE stream into the Responses SSE
+ * event stream a Responses client consumes.
+ *
+ * Upstream chunks are `chat.completion.chunk` objects whose `choices[0].delta`
+ * carries incremental `content` (assistant text) and/or `tool_calls` (function
+ * calls, streamed by `index` with partial `arguments`). We emit the Responses
+ * lifecycle around them:
+ *
+ *   response.created
+ *   -> per text run:  output_item.added → output_text.delta* → output_item.done
+ *   -> per tool call: output_item.added → function_call_arguments.delta*
+ *                       → function_call_arguments.done → output_item.done
+ *   response.completed   (with the assembled final `response` object)
+ *
+ * The translator is intentionally tolerant: malformed/keepalive lines yield
+ * nothing.
+ */
+export declare function createResponsesStreamTranslator(model: string, responseId: string): ResponsesStreamTranslator;
+/** A source the model cited, as carried by a Responses content-part annotation. */
+export interface ResponsesCitation {
+    url: string;
+    title?: string;
+}
+/** What {@link readResponsesOutput} pulls out of a `response` object. */
+export interface ResponsesOutput {
+    /** The assistant's answer, with the output items concatenated. */
+    text: string;
+    /** Cited sources in first-seen order, deduplicated by URL. */
+    citations: ResponsesCitation[];
+}
+/**
+ * Read the answer text and cited sources out of a Responses `response` payload.
+ *
+ * This is the inverse of {@link chatToResponse}: it consumes what an endpoint
+ * speaking Responses natively returns, rather than producing it. The Databricks
+ * native web-search tool answers this way, with each source attached as a
+ * `url_citation` annotation on the content part that used it.
+ *
+ * Prefers the flattened `output_text` when the payload carries it, and falls
+ * back to walking `output[].content[].text`. Every field is optional upstream,
+ * so a payload missing any of it yields empty results rather than throwing.
+ */
+export declare function readResponsesOutput(payload: Record<string, unknown>): ResponsesOutput;
+/**
+ * Strip tool types the upstream model doesn't support from a Responses request
+ * body, returning a shallow copy safe to forward (the input is not mutated).
+ *
+ * Clients like the Codex CLI include built-in Responses tools (`web_search`,
+ * `local_shell`, `custom`, ...) alongside their `function` tools. Databricks'
+ * Open Responses surface for Anthropic/Claude (and other non-OpenAI providers)
+ * only accepts `function` tools and hard-errors otherwise:
+ *   "Anthropic does not support tool type 'web_search'. Only 'function' is supported."
+ * Call this before forwarding to `/serving-endpoints/open-responses`. The OpenAI
+ * `/serving-endpoints/responses` path should keep built-ins (GPT supports them).
+ * If filtering empties the list, `tools` / `tool_choice` / `parallel_tool_calls`
+ * are dropped so we never send an empty `tools: []`.
+ */
+export declare function sanitizeResponsesTools(body: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Content-part / input-item types Claude extended thinking uses on the wire.
+ *
+ * Shared so both wire surfaces strip the same set: the Responses path here
+ * ({@link sanitizeOpenResponsesInput}) and the Chat Completions path in
+ * `@dbx-tools/appkit-mastra`'s serving sanitize. Anthropic signs these blocks,
+ * so a replay that mutates one is rejected outright - both paths must agree on
+ * what counts as a reasoning block.
+ */
+export declare const REASONING_TYPES: ReadonlySet<string>;
+/**
+ * Rewrite Responses `input` so Open Responses will accept it.
+ *
+ * Two OpenAI / Codex shapes that Databricks Open Responses (Claude, Gemini, …)
+ * reject:
+ *
+ * 1. Prior assistant turns with `output_text` / `output_*` content parts —
+ *    Open Responses only allows `input_text`, `input_image`, `input_file`,
+ *    `input_audio`. Map every `output_<kind>` part to `input_<kind>`.
+ * 2. Replayed extended-thinking blocks (`thinking`, `redacted_thinking`,
+ *    `reasoning` content parts, and top-level `reasoning` input items). Claude
+ *    signs those; any client round-trip that mutates them (or a cross-provider
+ *    replay) fails with e.g.
+ *      "messages.N.content.M: Invalid `data` in `redacted_thinking` block"
+ *    Strip them — the UI/client already showed the thinking; replay does not
+ *    need the signed blob. Same policy as appkit-mastra's serving sanitize.
+ *
+ * Returns a shallow copy when anything changes; otherwise the input body.
+ */
+export declare function sanitizeOpenResponsesInput(body: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Full Open Responses request sanitizer: strip non-`function` tools, rewrite
+ * `output_*` content parts, and drop thinking / reasoning blocks. Safe no-op
+ * when nothing needs changing.
+ */
+export declare function sanitizeOpenResponsesRequest(body: Record<string, unknown>): Record<string, unknown>;