@databricks/appkit 0.21.0 → 0.23.0

package/docs/development/templates.md

@@ -0,0 +1,93 @@
+# Templates
+
+AppKit uses a template system powered by the Databricks CLI's `databricks apps init` command. Templates define the project structure, and `.tmpl` files are processed with Go's `text/template` engine to generate customized output.
+
+## How `.tmpl` files work[​](#how-tmpl-files-work "Direct link to how-tmpl-files-work")
+
+Any file ending in `.tmpl` is processed by the CLI during `databricks apps init`:
+
+1. The `.tmpl` suffix is stripped (e.g. `.env.tmpl` → `.env`)
+2. Go template expressions are evaluated and substituted
+3. The rendered file is written to the output directory
+
+Files named with a `_` prefix are renamed to `.` prefix (e.g. `_gitignore` → `.gitignore`).
+
+### Template variables[​](#template-variables "Direct link to Template variables")
+
+| Variable          | Description                                                                  |
+| ----------------- | ---------------------------------------------------------------------------- |
+| `.projectName`    | Project name from `--name` or interactive prompt                             |
+| `.workspaceHost`  | Databricks workspace URL                                                     |
+| `.profile`        | Databricks CLI profile name (empty if using host-based auth)                 |
+| `.appDescription` | App description                                                              |
+| `.plugins.<name>` | Non-nil for each selected plugin, enabling conditionals                      |
+| `.dotEnv.content` | Generated `.env` content from plugin resources                               |
+| `.dotEnv.example` | Generated `.env.example` content with placeholders                           |
+| `.bundle.*`       | Generated `databricks.yml` sections (variables, resources, target variables) |
+| `.appEnv`         | Generated `app.yaml` env entries                                             |
+
+### Conditional content[​](#conditional-content "Direct link to Conditional content")
+
+Use Go template conditionals to include/exclude code based on selected plugins:
+
+```go
+{{- if .plugins.analytics}}
+import { analytics } from '@databricks/appkit';
+{{- end}}
+
+```
+
+## `appkit.plugins.json`[​](#appkitpluginsjson "Direct link to appkitpluginsjson")
+
+The plugin manifest drives the CLI's behavior during `databricks apps init`:
+
+* **Plugin selection UI** — selectable plugins shown in the interactive prompt
+* **Resource prompts** — required/optional resources prompt the user for values (e.g. SQL Warehouse ID)
+* **`.dotEnv` population** — resource fields with an `env` property are written to `.env`
+* **`app.yaml` generation** — resource fields produce `env` + `valueFrom` entries
+* **`databricks.yml` generation** — resource fields produce bundle variables and app resource entries
+
+### Resource field properties[​](#resource-field-properties "Direct link to Resource field properties")
+
+Each resource field in the manifest can have these properties:
+
+| Property       | Description                                                                         |
+| -------------- | ----------------------------------------------------------------------------------- |
+| `env`          | Environment variable name written to `.env` and `app.yaml`                          |
+| `description`  | Shown in the interactive prompt and bundle variable description                     |
+| `localOnly`    | Only written to `.env` for local dev; excluded from `app.yaml` and bundle variables |
+| `bundleIgnore` | Excluded from `databricks.yml` variables (but still in `.env`)                      |
+| `value`        | Default value used when no user input is provided                                   |
+| `resolve`      | Auto-populated by CLI from API calls instead of prompting (see below)               |
+| `examples`     | Example values shown in field descriptions                                          |
+
+### Resolvers[​](#resolvers "Direct link to Resolvers")
+
+Fields with a `resolve` property are auto-populated by the CLI from API calls rather than user prompts. The format is `<type>:<field>`.
+
+Currently only the `postgres` resource type has a resolver. Given the user-provided `branch` and `database` resource names, it derives:
+
+| Resolve key             | Description                                                 |
+| ----------------------- | ----------------------------------------------------------- |
+| `postgres:host`         | Postgres host from the branch's read-write endpoint         |
+| `postgres:databaseName` | Postgres database name from the database resource           |
+| `postgres:endpointPath` | Lakebase endpoint resource name from the branch's endpoints |
+
+Example field definition:
+
+```json
+{
+  "host": {
+    "env": "PGHOST",
+    "localOnly": true,
+    "resolve": "postgres:host",
+    "description": "Postgres host for local development."
+  }
+}
+
+```
+
+## See also[​](#see-also "Direct link to See also")
+
+* [Plugin management](./docs/plugins/plugin-management.md) — `appkit plugin sync`, `appkit plugin create`
+* [Configuration](./docs/configuration.md) — environment variables

package/docs/development.md

@@ -5,7 +5,7 @@ AppKit provides multiple development workflows to suit different needs: local de
 ## Prerequisites[​](#prerequisites "Direct link to Prerequisites")
 
 * [Node.js](https://nodejs.org) v22+ environment with `npm`
-* Databricks CLI (v0.287.0 or higher): install and configure it according to the [official tutorial](https://docs.databricks.com/aws/en/dev-tools/cli/tutorial).
+* Databricks CLI (v0.295.0 or higher): install and configure it according to the [official tutorial](https://docs.databricks.com/aws/en/dev-tools/cli/tutorial).
 * A new Databricks app with AppKit installed. See [Bootstrap a new Databricks app](./docs.md#quick-start-options) for more details.
 
 ## Development flows[​](#development-flows "Direct link to Development flows")

package/docs/faq.md

@@ -0,0 +1,66 @@
+# FAQ
+
+## Integrations[​](#integrations "Direct link to Integrations")
+
+### What Databricks services are available through AppKit?[​](#what-databricks-services-are-available-through-appkit "Direct link to What Databricks services are available through AppKit?")
+
+AppKit provides built-in integrations with the following Databricks services via its [plugin system](./docs/plugins.md):
+
+| Plugin                                         | Databricks Service                | What It Does                                                                            |
+| ---------------------------------------------- | --------------------------------- | --------------------------------------------------------------------------------------- |
+| [Analytics](./docs/plugins/analytics.md) | SQL Warehouses                    | Execute parameterized SQL queries with built-in caching, retry, and Arrow support       |
+| [Lakebase](./docs/plugins/lakebase.md)   | Lakebase Autoscaling (PostgreSQL) | Relational database access via standard pg.Pool with automatic OAuth token refresh      |
+| [Genie](./docs/plugins/genie.md)         | AI/BI Genie Spaces                | Natural language data queries with conversation management and streaming                |
+| [Files](./docs/plugins/files.md)         | Unity Catalog Volumes             | Multi-volume file operations (list, read, upload, download, delete, preview)            |
+| [Serving](./docs/plugins/serving.md)     | Model Serving                     | Authenticated proxy to Model Serving endpoints with invoke and streaming support        |
+| [Server](./docs/plugins/server.md)       | N/A                               | Express HTTP server with static file serving, Vite dev mode, and plugin route injection |
+
+Stay tuned for new plugins as we constantly expand integrations!
+
+### Can I add custom integrations?[​](#can-i-add-custom-integrations "Direct link to Can I add custom integrations?")
+
+Yes. AppKit's plugin architecture is extensible - you can create custom plugins using the CLI (`npx appkit plugin create`) or manually. See the [creating custom plugins guide](./docs/plugins/custom-plugins.md).
+
+## Authentication[​](#authentication "Direct link to Authentication")
+
+### How does authentication work in AppKit apps?[​](#how-does-authentication-work-in-appkit-apps "Direct link to How does authentication work in AppKit apps?")
+
+AppKit apps are designed to run on [Databricks Apps](https://docs.databricks.com/aws/en/dev-tools/databricks-apps/), which handles user authentication and authorization. Databricks Apps forwards user identity to the app via request headers, and AppKit integrates with this through the `.asUser(req)` pattern for on-behalf-of (OBO) execution — allowing plugins to act on behalf of the authenticated user.
+
+For details on how authentication and authorization work in Databricks Apps, see the [official auth documentation](https://docs.databricks.com/aws/en/dev-tools/databricks-apps/auth).
+
+## Databases[​](#databases "Direct link to Databases")
+
+*Also: Lakebase, PostgreSQL, OLTP*
+
+### How does AppKit handle databases?[​](#how-does-appkit-handle-databases "Direct link to How does AppKit handle databases?")
+
+AppKit is a TypeScript SDK (Express + React) and does not manage databases directly.
+
+To add database support, use the [Lakebase plugin](./docs/plugins/lakebase.md), which integrates with Lakebase Autoscaling.
+
+AppKit also uses Lakebase for caching when it is available (see the [caching](#does-appkit-support-caching) section below).
+
+You can manage Lakebase Autoscaling projects and branches using the dedicated agent skill from [Databricks Agent Skills](./docs/development/ai-assisted-development.md), installed with the Databricks CLI.
+
+### How does database setup and permission management work in AppKit?[​](#how-does-database-setup-and-permission-management-work-in-appkit "Direct link to How does database setup and permission management work in AppKit?")
+
+AppKit apps can have an attached Lakebase Autoscaling instance. No database is bundled by default - you add one by configuring the [Lakebase plugin](./docs/plugins/lakebase.md). When running `databricks apps init` and selecting the Lakebase plugin, the selected database is automatically attached as an app resource after deployment.
+
+With [AI-assisted development](./docs/development/ai-assisted-development.md), you can also ask the Agent to create a Lakebase project and branch for you.
+
+When deployed, a Databricks app uses its Service Principal for schema and table creation. If you configure the Lakebase Autoscaling project as an [app resource](https://docs.databricks.com/aws/en/dev-tools/databricks-apps/resources), the necessary connect and create permissions are granted automatically to the app's Service Principal.
+
+### Does AppKit support Lakebase Provisioned?[​](#does-appkit-support-lakebase-provisioned "Direct link to Does AppKit support Lakebase Provisioned?")
+
+No. AppKit only supports Lakebase Autoscaling. Lakebase Provisioned databases are not supported by the [Lakebase plugin](./docs/plugins/lakebase.md) or Lakebase agent skill from [Databricks Agent Skills](./docs/development/ai-assisted-development.md).
+
+## Caching[​](#caching "Direct link to Caching")
+
+### Does AppKit support caching?[​](#does-appkit-support-caching "Direct link to Does AppKit support caching?")
+
+Yes. The [Analytics plugin](./docs/plugins/analytics.md) - used for executing SQL queries against Databricks SQL Warehouses - supports an optional cache layer.
+
+Caching is configured per plugin and can use either [Lakebase Autoscaling](https://docs.databricks.com/aws/en/oltp/) or an in-memory store, depending on the configuration.
+
+If the Lakebase Autoscaling connection is configured, the AppKit-based app creates an `appkit` schema in the configured database with internal tables required for caching.

package/docs/plugins/caching.md

@@ -16,7 +16,9 @@ await createApp({
 
 ```
 
-Storage auto-selects **Lakebase V1 (Provisioned) persistent cache when healthy**, otherwise falls back to in-memory. Support for Lakebase Autoscaling coming soon.
+Storage auto-selects **Lakebase Autoscaling persistent cache when healthy**, otherwise falls back to in-memory.
+
+The database-backed cache requires the same Lakebase environment variables as the [Lakebase plugin](./docs/plugins/lakebase.md#environment-variables) (`PGHOST`, `PGDATABASE`, `LAKEBASE_ENDPOINT`, `PGSSLMODE`).
 
 ## Plugin-level caching[​](#plugin-level-caching "Direct link to Plugin-level caching")
 

package/docs/plugins/execution-context.md

@@ -42,4 +42,4 @@ Exported from `@databricks/appkit`:
 
 ## Development mode behavior[​](#development-mode-behavior "Direct link to Development mode behavior")
 
-In local development (`NODE_ENV=development`), if `asUser(req)` is called without a user token, it logs a warning and falls back to the service principal.
+In local development (`NODE_ENV=development`), if `asUser(req)` is called without a user token, it logs a warning and skips user impersonation — the operation runs with the default credentials configured for the app instead.

package/docs/plugins/lakebase.md

@@ -17,7 +17,7 @@ The easiest way to get started with the Lakebase plugin is to use the Databricks
 ### Prerequisites[​](#prerequisites "Direct link to Prerequisites")
 
 * [Node.js](https://nodejs.org) v22+ environment with `npm`
-* Databricks CLI (v0.287.0 or higher): install and configure it according to the [official tutorial](https://docs.databricks.com/aws/en/dev-tools/cli/tutorial).
+* Databricks CLI (v0.295.0 or higher): install and configure it according to the [official tutorial](https://docs.databricks.com/aws/en/dev-tools/cli/tutorial).
 * A new Databricks app with AppKit installed. See [Bootstrap a new Databricks app](./docs.md#quick-start-options) for more details.
 
 ### Steps[​](#steps "Direct link to Steps")

package/docs/plugins/serving.md

@@ -0,0 +1,223 @@
+# Serving plugin
+
+Provides an authenticated proxy to [Databricks Model Serving](https://docs.databricks.com/aws/en/machine-learning/model-serving) endpoints, with invoke and streaming support.
+
+**Key features:**
+
+* Named endpoint aliases for multiple serving endpoints
+* Non-streaming (`invoke`) and SSE streaming (`stream`) invocation
+* Automatic OpenAPI type generation for request/response schemas
+* Request body filtering based on endpoint schema
+* On-behalf-of (OBO) user execution
+
+## Basic usage[​](#basic-usage "Direct link to Basic usage")
+
+```ts
+import { createApp, server, serving } from "@databricks/appkit";
+
+await createApp({
+  plugins: [
+    server(),
+    serving(),
+  ],
+});
+
+```
+
+With no configuration, the plugin reads `DATABRICKS_SERVING_ENDPOINT_NAME` from the environment and registers it under the `default` alias.
+
+## Configuration options[​](#configuration-options "Direct link to Configuration options")
+
+| Option      | Type                             | Default                                                    | Description                            |
+| ----------- | -------------------------------- | ---------------------------------------------------------- | -------------------------------------- |
+| `endpoints` | `Record<string, EndpointConfig>` | `{ default: { env: "DATABRICKS_SERVING_ENDPOINT_NAME" } }` | Map of alias names to endpoint configs |
+| `timeout`   | `number`                         | `120000`                                                   | Request timeout in ms                  |
+
+### Endpoint aliases[​](#endpoint-aliases "Direct link to Endpoint aliases")
+
+Endpoint aliases let you reference multiple serving endpoints by name:
+
+```ts
+serving({
+  endpoints: {
+    llm: { env: "DATABRICKS_SERVING_ENDPOINT_NAME" },
+    classifier: { env: "DATABRICKS_SERVING_ENDPOINT_CLASSIFIER" },
+  },
+})
+
+```
+
+Each alias maps to an environment variable holding the actual endpoint name. If an endpoint serves multiple models, you can use `servedModel` to bypass traffic routing and target a specific model directly:
+
+```ts
+serving({
+  endpoints: {
+    llm: { env: "DATABRICKS_SERVING_ENDPOINT_NAME", servedModel: "llama-v2" },
+  },
+})
+
+```
+
+## Type generation[​](#type-generation "Direct link to Type generation")
+
+The `appKitServingTypesPlugin()` Vite plugin generates TypeScript types from your serving endpoints' OpenAPI schemas. **No manual setup needed** — the AppKit dev server includes this plugin automatically.
+
+The plugin auto-discovers endpoint configuration from your server file (`server/index.ts` or `server/server.ts`).
+
+Generated types provide:
+
+* **Alias autocomplete** in both backend (`AppKit.serving("alias")`) and frontend hooks (`useServingStream`, `useServingInvoke`)
+* **Typed request/response/chunk** per endpoint based on OpenAPI schemas
+
+If an endpoint's OpenAPI schema is unavailable (not deployed, env var not set), the plugin generates generic fallback types. The endpoint is still usable — just without typed request/response.
+
+note
+
+Endpoints that don't define a streaming response schema in their OpenAPI spec will have `chunk: unknown`. For these endpoints, use `useServingInvoke` instead of `useServingStream` — the `response` type will still be properly typed.
+
+## Environment variables[​](#environment-variables "Direct link to Environment variables")
+
+| Variable                           | Description                                                     |
+| ---------------------------------- | --------------------------------------------------------------- |
+| `DATABRICKS_SERVING_ENDPOINT_NAME` | Default endpoint name (used when `endpoints` config is omitted) |
+
+When using named endpoints, define a custom environment variable per alias (e.g. `DATABRICKS_SERVING_ENDPOINT_CLASSIFIER`).
+
+## Execution context[​](#execution-context "Direct link to Execution context")
+
+All serving routes execute on behalf of the authenticated user (OBO) by default, consistent with the Genie and Files plugins. This ensures per-user `CAN_QUERY` permissions are enforced on the serving endpoint.
+
+For programmatic access via `exports()`, use `.asUser(req)` to run in user context:
+
+```ts
+// Service principal context (default)
+const result = await AppKit.serving("llm").invoke({ messages });
+
+// User context (recommended in route handlers)
+const result = await AppKit.serving("llm").asUser(req).invoke({ messages });
+
+```
+
+## HTTP endpoints[​](#http-endpoints "Direct link to HTTP endpoints")
+
+### Named mode (with `endpoints` config)[​](#named-mode-with-endpoints-config "Direct link to named-mode-with-endpoints-config")
+
+* `POST /api/serving/:alias/invoke` — Non-streaming invocation
+* `POST /api/serving/:alias/stream` — SSE streaming invocation
+
+### Default mode (no `endpoints` config)[​](#default-mode-no-endpoints-config "Direct link to default-mode-no-endpoints-config")
+
+* `POST /api/serving/invoke` — Non-streaming invocation
+* `POST /api/serving/stream` — SSE streaming invocation
+
+### Request format[​](#request-format "Direct link to Request format")
+
+```text
+POST /api/serving/:alias/invoke
+Content-Type: application/json
+
+{
+  "messages": [
+    { "role": "user", "content": "Hello" }
+  ]
+}
+
+```
+
+## Programmatic access[​](#programmatic-access "Direct link to Programmatic access")
+
+The plugin exports `invoke` and `stream` methods for server-side use:
+
+```ts
+const AppKit = await createApp({
+  plugins: [
+    server(),
+    serving({
+      endpoints: {
+        llm: { env: "DATABRICKS_SERVING_ENDPOINT_NAME" },
+      },
+    }),
+  ],
+});
+
+// Non-streaming
+const result = await AppKit.serving("llm").invoke({
+  messages: [{ role: "user", content: "Hello" }],
+});
+
+// Streaming
+for await (const chunk of AppKit.serving("llm").stream({
+  messages: [{ role: "user", content: "Hello" }],
+})) {
+  console.log(chunk);
+}
+
+```
+
+## Frontend hooks[​](#frontend-hooks "Direct link to Frontend hooks")
+
+The `@databricks/appkit-ui` package provides React hooks for serving endpoints:
+
+### useServingStream[​](#useservingstream "Direct link to useServingStream")
+
+Streaming invocation via SSE:
+
+```tsx
+import { useServingStream } from "@databricks/appkit-ui/react";
+
+function ChatStream() {
+  const { stream, chunks, streaming, error, reset } = useServingStream(
+    { messages: [{ role: "user", content: "Hello" }] },
+    {
+      alias: "llm",
+      onComplete: (finalChunks) => {
+        // Called with all accumulated chunks when the stream finishes
+        console.log("Stream done, got", finalChunks.length, "chunks");
+      },
+    },
+  );
+
+  return (
+    <>
+      <button onClick={stream} disabled={streaming}>Send</button>
+      <button onClick={reset}>Reset</button>
+      {chunks.map((chunk, i) => <pre key={i}>{JSON.stringify(chunk)}</pre>)}
+      {error && <p>{error}</p>}
+    </>
+  );
+}
+
+```
+
+### useServingInvoke[​](#useservinginvoke "Direct link to useServingInvoke")
+
+Non-streaming invocation. `invoke()` returns a promise with the response data (or `null` on error):
+
+```tsx
+import { useServingInvoke } from "@databricks/appkit-ui/react";
+
+function Classify() {
+  const { invoke, data, loading, error } = useServingInvoke(
+    { inputs: ["sample text"] },
+    { alias: "classifier" },
+  );
+
+  async function handleClick() {
+    const result = await invoke();
+    if (result) {
+      console.log("Classification result:", result);
+    }
+  }
+
+  return (
+    <>
+      <button onClick={handleClick} disabled={loading}>Classify</button>
+      {data && <pre>{JSON.stringify(data)}</pre>}
+      {error && <p>{error}</p>}
+    </>
+  );
+}
+
+```
+
+Both hooks accept `autoStart: true` to invoke automatically on mount.

package/docs.md

@@ -19,7 +19,7 @@ AppKit simplifies building data applications on Databricks by providing:
 ## Prerequisites[​](#prerequisites "Direct link to Prerequisites")
 
 * [Node.js](https://nodejs.org) v22+ environment with `npm`
-* Databricks CLI (v0.287.0 or higher): install and configure it according to the [official tutorial](https://docs.databricks.com/aws/en/dev-tools/cli/tutorial).
+* Databricks CLI (v0.295.0 or higher): install and configure it according to the [official tutorial](https://docs.databricks.com/aws/en/dev-tools/cli/tutorial).
 
 ## Quick start options[​](#quick-start-options "Direct link to Quick start options")
 
@@ -37,7 +37,7 @@ Databricks AppKit is designed to work with AI coding assistants through Agent Sk
 Install Agent Skills and configure it for use with your preferred AI assistant:
 
 ```bash
-databricks experimental aitools skills install
+databricks experimental aitools install
 
 ```
 

package/llms.txt

@@ -27,6 +27,7 @@ npx @databricks/appkit docs <query>
 - [Configuration](./docs/configuration.md): This guide covers environment variables and configuration options for AppKit applications.
 - [Core principles](./docs/core-principles.md): Learn about the fundamental concepts and principles behind AppKit.
 - [Development](./docs/development.md): AppKit provides multiple development workflows to suit different needs: local development with hot reload, AI-assisted development with Agent Skills, and remote tunneling to deployed backends.
+- [FAQ](./docs/faq.md): Integrations
 - [Plugins](./docs/plugins.md): Plugins are modular extensions that add capabilities to your AppKit application. They follow a defined lifecycle and have access to shared services like caching, telemetry, and streaming.
 
 ## Development
@@ -36,6 +37,7 @@ npx @databricks/appkit docs <query>
 - [Local development](./docs/development/local-development.md): Once your app is bootstrapped according to the Manual quick start guide, you can start the development server with hot reload for both UI and backend code.
 - [Project setup](./docs/development/project-setup.md): This guide covers the recommended project structure and scaffolding for AppKit applications.
 - [Remote Bridge](./docs/development/remote-bridge.md): Remote bridge allows you to develop against a deployed backend while keeping your UI and queries local. This is useful for testing against production data or debugging deployed backend code without redeploying your app.
+- [Templates](./docs/development/templates.md): AppKit uses a template system powered by the Databricks CLI's databricks apps init command. Templates define the project structure, and .tmpl files are processed with Go's text/template engine to generate customized output.
 - [Type generation](./docs/development/type-generation.md): AppKit can automatically generate TypeScript types for your SQL queries, providing end-to-end type safety from database to UI.
 
 ## Plugins
@@ -49,6 +51,7 @@ npx @databricks/appkit docs <query>
 - [Lakebase plugin](./docs/plugins/lakebase.md): Provides a PostgreSQL connection pool for Databricks Lakebase Autoscaling with automatic OAuth token refresh.
 - [Plugin management](./docs/plugins/plugin-management.md): AppKit includes a CLI for managing plugins. All commands are available under npx @databricks/appkit plugin.
 - [Server plugin](./docs/plugins/server.md): Provides HTTP server capabilities with development and production modes.
+- [Serving plugin](./docs/plugins/serving.md): Provides an authenticated proxy to Databricks Model Serving endpoints, with invoke and streaming support.
 
 ## appkit API reference [collapsed]
 
@@ -66,9 +69,12 @@ npx @databricks/appkit docs <query>
 - [Class: ValidationError](./docs/api/appkit/Class.ValidationError.md): Error thrown when input validation fails.
 - [Enumeration: RequestedClaimsPermissionSet](./docs/api/appkit/Enumeration.RequestedClaimsPermissionSet.md): Permission set for Unity Catalog table access
 - [Enumeration: ResourceType](./docs/api/appkit/Enumeration.ResourceType.md): Resource types from schema $defs.resourceType.enum
+- [Function: appKitServingTypesPlugin()](./docs/api/appkit/Function.appKitServingTypesPlugin.md): Vite plugin to generate TypeScript types for AppKit serving endpoints.
 - [Function: appKitTypesPlugin()](./docs/api/appkit/Function.appKitTypesPlugin.md): Vite plugin to generate types for AppKit queries.
 - [Function: createApp()](./docs/api/appkit/Function.createApp.md): Bootstraps AppKit with the provided configuration.
 - [Function: createLakebasePool()](./docs/api/appkit/Function.createLakebasePool.md): Create a Lakebase pool with appkit's logger integration.
+- [Function: extractServingEndpoints()](./docs/api/appkit/Function.extractServingEndpoints.md): Extract serving endpoint config from a server file by AST-parsing it.
+- [Function: findServerFile()](./docs/api/appkit/Function.findServerFile.md): Find the server entry file by checking candidate paths in order.
 - [Function: generateDatabaseCredential()](./docs/api/appkit/Function.generateDatabaseCredential.md): Generate OAuth credentials for Postgres database connection using the proper Postgres API.
 - [Function: getExecutionContext()](./docs/api/appkit/Function.getExecutionContext.md): Get the current execution context.
 - [Function: getLakebaseOrmConfig()](./docs/api/appkit/Function.getLakebaseOrmConfig.md): Get Lakebase connection configuration for ORMs that don't accept pg.Pool directly.
@@ -81,6 +87,7 @@ npx @databricks/appkit docs <query>
 - [Interface: BasePluginConfig](./docs/api/appkit/Interface.BasePluginConfig.md): Base configuration interface for AppKit plugins
 - [Interface: CacheConfig](./docs/api/appkit/Interface.CacheConfig.md): Configuration for the CacheInterceptor. Controls TTL, size limits, storage backend, and probabilistic cleanup.
 - [Interface: DatabaseCredential](./docs/api/appkit/Interface.DatabaseCredential.md): Database credentials with OAuth token for Postgres connection
+- [Interface: EndpointConfig](./docs/api/appkit/Interface.EndpointConfig.md): Properties
 - [Interface: GenerateDatabaseCredentialRequest](./docs/api/appkit/Interface.GenerateDatabaseCredentialRequest.md): Request parameters for generating database OAuth credentials
 - [Interface: ITelemetry](./docs/api/appkit/Interface.ITelemetry.md): Plugin-facing interface for OpenTelemetry instrumentation.
 - [Interface: LakebasePoolConfig](./docs/api/appkit/Interface.LakebasePoolConfig.md): Configuration for creating a Lakebase connection pool
@@ -90,13 +97,17 @@ npx @databricks/appkit docs <query>
 - [Interface: ResourceEntry](./docs/api/appkit/Interface.ResourceEntry.md): Internal representation of a resource in the registry.
 - [Interface: ResourceFieldEntry](./docs/api/appkit/Interface.ResourceFieldEntry.md): Defines a single field for a resource. Each field has its own environment variable and optional description. Single-value types use one key (e.g. id); multi-value types (database, secret) use multiple (e.g. instancename, databasename or scope, key).
 - [Interface: ResourceRequirement](./docs/api/appkit/Interface.ResourceRequirement.md): Declares a resource requirement for a plugin.
+- [Interface: ServingEndpointEntry](./docs/api/appkit/Interface.ServingEndpointEntry.md): Shape of a single registry entry.
+- [Interface: ServingEndpointRegistry](./docs/api/appkit/Interface.ServingEndpointRegistry.md): Registry interface for serving endpoint type generation.
 - [Interface: StreamExecutionSettings](./docs/api/appkit/Interface.StreamExecutionSettings.md): Execution settings for streaming endpoints. Extends PluginExecutionSettings with SSE stream configuration.
 - [Interface: TelemetryConfig](./docs/api/appkit/Interface.TelemetryConfig.md): OpenTelemetry configuration for AppKit applications
 - [Interface: ValidationResult](./docs/api/appkit/Interface.ValidationResult.md): Result of validating all registered resources against the environment.
 - [Type Alias: ConfigSchema](./docs/api/appkit/TypeAlias.ConfigSchema.md): Configuration schema definition for plugin config.
+- [Type Alias: ExecutionResult<T>](./docs/api/appkit/TypeAlias.ExecutionResult.md): Discriminated union for plugin execution results.
 - [Type Alias: IAppRouter](./docs/api/appkit/TypeAlias.IAppRouter.md): Express router type for plugin route registration
 - [Type Alias: PluginData<T, U, N>](./docs/api/appkit/TypeAlias.PluginData.md): Tuple of plugin class, config, and name. Created by toPlugin() and passed to createApp().
 - [Type Alias: ResourcePermission](./docs/api/appkit/TypeAlias.ResourcePermission.md): Union of all possible permission levels across all resource types.
+- [Type Alias: ServingFactory](./docs/api/appkit/TypeAlias.ServingFactory.md): Factory function returned by AppKit.serving.
 - [Type Alias: ToPlugin()<T, U, N>](./docs/api/appkit/TypeAlias.ToPlugin.md): Factory function type returned by toPlugin(). Accepts optional config and returns a PluginData tuple.
 - [Variable: sql](./docs/api/appkit/Variable.sql.md): SQL helper namespace
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@databricks/appkit",
   "type": "module",
-  "version": "0.21.0",
+  "version": "0.23.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "packageManager": "pnpm@10.21.0",
@@ -21,7 +21,8 @@
     "llms.txt",
     "README.md",
     "DCO",
-    "NOTICE.md"
+    "NOTICE.md",
+    "sbom.cdx.json"
   ],
   "exports": {
     ".": "./dist/index.js",
@@ -40,44 +41,44 @@
     "postinstall": "node scripts/postinstall.js"
   },
   "dependencies": {
+    "@ast-grep/napi": "0.37.0",
     "@databricks/lakebase": "0.2.0",
-    "@databricks/sdk-experimental": "^0.16.0",
-    "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/api-logs": "^0.208.0",
-    "@opentelemetry/auto-instrumentations-node": "^0.67.0",
-    "@opentelemetry/exporter-logs-otlp-proto": "^0.208.0",
-    "@opentelemetry/exporter-metrics-otlp-proto": "^0.208.0",
-    "@opentelemetry/exporter-trace-otlp-proto": "^0.208.0",
-    "@opentelemetry/instrumentation": "^0.208.0",
-    "@opentelemetry/instrumentation-express": "^0.57.0",
-    "@opentelemetry/instrumentation-http": "^0.208.0",
-    "@opentelemetry/resources": "^2.2.0",
-    "@opentelemetry/sdk-logs": "^0.208.0",
-    "@opentelemetry/sdk-metrics": "^2.2.0",
-    "@opentelemetry/sdk-node": "^0.208.0",
-    "@opentelemetry/sdk-trace-base": "^2.6.0",
-    "@opentelemetry/semantic-conventions": "^1.38.0",
-    "@types/semver": "^7.7.1",
-    "dotenv": "^16.6.1",
-    "express": "^4.22.0",
-    "obug": "^2.1.1",
-    "pg": "^8.18.0",
-    "picocolors": "^1.1.1",
-    "semver": "^7.7.3",
+    "@databricks/sdk-experimental": "0.16.0",
+    "@opentelemetry/api": "1.9.0",
+    "@opentelemetry/api-logs": "0.208.0",
+    "@opentelemetry/auto-instrumentations-node": "0.67.2",
+    "@opentelemetry/exporter-logs-otlp-proto": "0.208.0",
+    "@opentelemetry/exporter-metrics-otlp-proto": "0.208.0",
+    "@opentelemetry/exporter-trace-otlp-proto": "0.208.0",
+    "@opentelemetry/instrumentation": "0.208.0",
+    "@opentelemetry/instrumentation-express": "0.57.0",
+    "@opentelemetry/instrumentation-http": "0.208.0",
+    "@opentelemetry/resources": "2.2.0",
+    "@opentelemetry/sdk-logs": "0.208.0",
+    "@opentelemetry/sdk-metrics": "2.2.0",
+    "@opentelemetry/sdk-node": "0.208.0",
+    "@opentelemetry/sdk-trace-base": "2.6.0",
+    "@opentelemetry/semantic-conventions": "1.38.0",
+    "@types/semver": "7.7.1",
+    "dotenv": "16.6.1",
+    "express": "4.22.0",
+    "obug": "2.1.1",
+    "pg": "8.18.0",
+    "picocolors": "1.1.1",
+    "semver": "7.7.3",
     "vite": "npm:rolldown-vite@7.1.14",
-    "ws": "^8.18.3",
-    "@ast-grep/napi": "^0.37.0",
-    "ajv": "^8.17.1",
-    "ajv-formats": "^3.0.1",
-    "@clack/prompts": "^1.0.1",
-    "commander": "^12.1.0"
+    "ws": "8.18.3",
+    "ajv": "8.17.1",
+    "ajv-formats": "3.0.1",
+    "@clack/prompts": "1.0.1",
+    "commander": "12.1.0"
   },
   "devDependencies": {
-    "@types/express": "^4.17.25",
-    "@types/json-schema": "^7.0.15",
-    "@types/pg": "^8.16.0",
-    "@types/ws": "^8.18.1",
-    "@vitejs/plugin-react": "^5.1.1"
+    "@types/express": "4.17.25",
+    "@types/json-schema": "7.0.15",
+    "@types/pg": "8.16.0",
+    "@types/ws": "8.18.1",
+    "@vitejs/plugin-react": "5.1.1"
   },
   "overrides": {
     "vite": "npm:rolldown-vite@7.1.14"