@databricks/appkit 0.37.0 → 0.38.0

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.295.0 or higher): install and configure it according to the [official tutorial](https://docs.databricks.com/aws/en/dev-tools/cli/tutorial).
+* Databricks CLI (v1.0.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/plugins/custom-plugins.md

@@ -15,34 +15,42 @@ For a deeper understanding of the plugin structure, read on.
 
 ## Basic plugin example[​](#basic-plugin-example "Direct link to Basic plugin example")
 
-Extend the [`Plugin`](./docs/api/appkit/Class.Plugin.md) class and export with `toPlugin()`:
+Author the manifest as JSON, import it, and attach it to a [`Plugin`](./docs/api/appkit/Class.Plugin.md) subclass via `static manifest`. Export with `toPlugin()`:
+
+```json
+// my-plugin/manifest.json
+{
+  "$schema": "https://databricks.github.io/appkit/schemas/plugin-manifest.schema.json",
+  "name": "my-plugin",
+  "displayName": "My Plugin",
+  "description": "A custom plugin",
+  "resources": {
+    "required": [
+      {
+        "type": "secret",
+        "alias": "apiKey",
+        "resourceKey": "api-key",
+        "description": "API key for external service",
+        "permission": "READ",
+        "fields": {
+          "scope": { "env": "MY_SECRET_SCOPE", "description": "Secret scope" },
+          "key": { "env": "MY_API_KEY", "description": "Secret key name" }
+        }
+      }
+    ],
+    "optional": []
+  }
+}
+
+```
 
 ```typescript
+// my-plugin/index.ts
 import { Plugin, toPlugin, type PluginManifest } from "@databricks/appkit";
-import type express from "express";
+import manifest from "./manifest.json";
 
 class MyPlugin extends Plugin {
-  static manifest = {
-    name: "myPlugin",
-    displayName: "My Plugin",
-    description: "A custom plugin",
-    resources: {
-      required: [
-        {
-          type: "secret",
-          alias: "apiKey",
-          resourceKey: "apiKey",
-          description: "API key for external service",
-          permission: "READ",
-          fields: {
-            scope: { env: "MY_SECRET_SCOPE", description: "Secret scope" },
-            key: { env: "MY_API_KEY", description: "Secret key name" }
-          }
-        }
-      ],
-      optional: []
-    }
-  } satisfies PluginManifest<"myPlugin">;
+  static manifest = manifest as PluginManifest<"my-plugin">;
 
   async setup() {
     // Initialize your plugin
@@ -67,6 +75,8 @@ export const myPlugin = toPlugin(MyPlugin);
 
 ```
 
+JSON is the canonical authoring surface — it is what `appkit plugin sync` reads when aggregating manifests for templates. For the full v2.0 manifest contract (resources, discovery descriptors, scaffolding rules), see [Plugin manifest](./docs/plugins/manifest.md).
+
 ## Config-dependent resources[​](#config-dependent-resources "Direct link to Config-dependent resources")
 
 The manifest defines resources as either `required` (always needed) or `optional` (may be needed). For resources that become required based on plugin configuration, implement a static `getResourceRequirements(config)` method:

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.295.0 or higher): install and configure it according to the [official tutorial](https://docs.databricks.com/aws/en/dev-tools/cli/tutorial).
+* Databricks CLI (v1.0.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/manifest.md

@@ -0,0 +1,293 @@
+# Plugin manifest
+
+Every plugin ships a `manifest.json` next to its source code. The manifest declares plugin metadata, the Databricks resources the plugin needs, and any structured rules a scaffolding agent must honor when running `databricks apps init`. It is consumed at three stages:
+
+* **Authoring** — `import manifest from "./manifest.json"` and attach it to the `Plugin` subclass via `static manifest`.
+* **Sync** — `appkit plugin sync --write` aggregates manifests from installed packages and local plugins into `appkit.plugins.json`.
+* **Init** — `databricks apps init` reads `appkit.plugins.json` to drive plugin selection, resource prompts, and `.env` / `databricks.yml` / `app.yaml` generation.
+
+This page documents the **v2.0** manifest contract. JSON Schema is published at `https://databricks.github.io/appkit/schemas/plugin-manifest.schema.json`; reference it via `$schema` for editor validation.
+
+## Recommended pattern[​](#recommended-pattern "Direct link to Recommended pattern")
+
+Author the manifest as JSON, import it into the plugin module, and assert the type:
+
+```typescript
+// packages/my-plugin/src/index.ts
+import { Plugin, toPlugin } from "@databricks/appkit";
+import type { PluginManifest } from "@databricks/appkit";
+import manifest from "./manifest.json";
+
+class MyPlugin extends Plugin {
+  static manifest = manifest as PluginManifest<"my-plugin">;
+  // ...
+}
+
+export const myPlugin = toPlugin(MyPlugin);
+
+```
+
+```json
+// packages/my-plugin/src/manifest.json
+{
+  "$schema": "https://databricks.github.io/appkit/schemas/plugin-manifest.schema.json",
+  "name": "my-plugin",
+  "displayName": "My Plugin",
+  "description": "A custom plugin",
+  "resources": {
+    "required": [],
+    "optional": []
+  }
+}
+
+```
+
+JSON is the canonical authoring surface — it is what `appkit plugin sync` reads. JS manifests (`manifest.js` / `manifest.cjs`) are ignored by default and require `--allow-js-manifest` to opt in (executes plugin code; trust required). For end-to-end CLI behavior, see [Plugin management](./docs/plugins/plugin-management.md).
+
+## Required fields[​](#required-fields "Direct link to Required fields")
+
+| Field                | Type                    | Notes                                                                 |
+| -------------------- | ----------------------- | --------------------------------------------------------------------- |
+| `name`               | `string`                | Plugin identifier. Lowercase, starts with a letter, `[a-z0-9-]` only. |
+| `displayName`        | `string`                | Shown in UI and CLI prompts.                                          |
+| `description`        | `string`                | Brief summary.                                                        |
+| `resources.required` | `ResourceRequirement[]` | Resources the plugin cannot run without.                              |
+| `resources.optional` | `ResourceRequirement[]` | Resources that enhance behavior but are not mandatory.                |
+
+## Resources[​](#resources "Direct link to Resources")
+
+A resource requirement declares one Databricks resource the plugin depends on. The shape is keyed by `type`; each type fixes its valid `permission` values (validated by the schema as a discriminated union):
+
+| `type`                | Permissions                                     |
+| --------------------- | ----------------------------------------------- |
+| `secret`              | `READ`, `WRITE`, `MANAGE`                       |
+| `job`                 | `CAN_VIEW`, `CAN_MANAGE_RUN`, `CAN_MANAGE`      |
+| `sql_warehouse`       | `CAN_USE`, `CAN_MANAGE`                         |
+| `serving_endpoint`    | `CAN_VIEW`, `CAN_QUERY`, `CAN_MANAGE`           |
+| `volume`              | `READ_VOLUME`, `WRITE_VOLUME`                   |
+| `vector_search_index` | `SELECT`                                        |
+| `uc_function`         | `EXECUTE`                                       |
+| `uc_connection`       | `USE_CONNECTION`                                |
+| `database`            | `CAN_CONNECT_AND_CREATE`                        |
+| `postgres`            | `CAN_CONNECT_AND_CREATE`                        |
+| `genie_space`         | `CAN_VIEW`, `CAN_RUN`, `CAN_EDIT`, `CAN_MANAGE` |
+| `experiment`          | `CAN_READ`, `CAN_EDIT`, `CAN_MANAGE`            |
+| `app`                 | `CAN_USE`                                       |
+
+Every requirement has:
+
+* `alias` — human-readable label used in UI / CLI output.
+* `resourceKey` — stable machine key (`[a-z][a-z0-9-]*`). Used for deduplication, env naming, and references in `app.yaml`. **Identity is keyed on `resourceKey`, not `alias`.**
+* `description` — explains *why* this resource is needed; surfaces in interactive prompts.
+* `fields` — map of field name → field entry (see below). At least one entry when present.
+* `permission` — must match the type's allowed enum.
+
+Single-value resource types (e.g. `sql_warehouse`) typically declare one field (`id`). Multi-value types (e.g. `secret`, `database`) declare several (`scope` + `key`, `instance_name` + `database_name`).
+
+### Field entry[​](#field-entry "Direct link to Field entry")
+
+```json
+{
+  "id": {
+    "env": "DATABRICKS_WAREHOUSE_ID",
+    "description": "SQL Warehouse ID",
+    "examples": ["1234abcd5678efgh"],
+    "discovery": { "type": "kind", "resourceKind": "warehouse" }
+  }
+}
+
+```
+
+| Property       | Description                                                                                                                                                                      |
+| -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `env`          | Environment variable name written to `.env` and `app.yaml`. Must match `^[A-Z][A-Z0-9_]*$`.                                                                                      |
+| `description`  | Shown in interactive prompts and bundle variable descriptions.                                                                                                                   |
+| `examples`     | Sample values shown in field descriptions.                                                                                                                                       |
+| `localOnly`    | When `true`, the field is generated for local `.env` only — the Databricks Apps platform auto-injects it at deploy time, so it is excluded from `app.yaml` and `databricks.yml`. |
+| `bundleIgnore` | Excluded from `databricks.yml` variables (still written to `.env`).                                                                                                              |
+| `value`        | Static default value.                                                                                                                                                            |
+| `resolve`      | CLI-side resolver name, formatted `<resource_type>:<field>` (e.g. `postgres:host`). The CLI populates the value from API calls during init.                                      |
+| `discovery`    | Describes how the CLI lists candidate values — see below.                                                                                                                        |
+
+### Configuration-dependent resources[​](#configuration-dependent-resources "Direct link to Configuration-dependent resources")
+
+The manifest distinguishes `required` from `optional` for static analysis. When a resource only becomes required based on the plugin's runtime config, list it under `optional` in the manifest and override at runtime via a static `getResourceRequirements(config)` method on the plugin class. See [Creating custom plugins](./docs/plugins/custom-plugins.md#config-dependent-resources).
+
+## Resource discovery[​](#resource-discovery "Direct link to Resource discovery")
+
+Discovery describes how the CLI offers candidate values for a field during interactive init. There are two variants under `discovery`, discriminated by `type`:
+
+### `kind` variant (preferred)[​](#kind-variant-preferred "Direct link to kind-variant-preferred")
+
+```json
+{
+  "discovery": {
+    "type": "kind",
+    "resourceKind": "warehouse"
+  }
+}
+
+```
+
+The `kind` variant references a well-known Databricks resource kind for which AppKit owns the listing command and response shape. This is the preferred form for first-party Databricks resources — plugin authors declare *what* to list, and AppKit owns *how* to list it.
+
+Supported `resourceKind` values:
+
+| `resourceKind`      | Listed via                                    |
+| ------------------- | --------------------------------------------- |
+| `warehouse`         | `databricks warehouses list`                  |
+| `genie_space`       | `databricks genie list-spaces`                |
+| `volume`            | `databricks volumes list {catalog} {schema}`  |
+| `postgres_project`  | `databricks postgres list-projects`           |
+| `postgres_branch`   | `databricks postgres list-branches {project}` |
+| `postgres_database` | `databricks postgres list-databases {branch}` |
+
+Supported options on the `kind` variant:
+
+| Property    | Description                                                                                                                                         |
+| ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `select`    | Field name in the parsed CLI response used as the selected value (e.g. `"id"`, `"name"`, `"full_name"`). Defaults to the kind's natural identifier. |
+| `display`   | Field name shown to the user during selection. Defaults to `select`.                                                                                |
+| `dependsOn` | Name of a sibling field within the same resource that must resolve first (see [Field dependencies](#field-dependencies)).                           |
+| `shortcut`  | Single-value fast-path command that returns exactly one value, skipping interactive selection.                                                      |
+
+### `cli` variant (escape hatch)[​](#cli-variant-escape-hatch "Direct link to cli-variant-escape-hatch")
+
+For resources outside the `kind` map, fall back to the `cli` variant:
+
+```json
+{
+  "discovery": {
+    "type": "cli",
+    "cliCommand": "databricks custom-resource list --profile <PROFILE> --output json",
+    "selectField": ".id",
+    "displayField": ".name"
+  }
+}
+
+```
+
+| Property       | Description                                                                                                                                                                                                                                                                       |
+| -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `cliCommand`   | Full Databricks CLI command. **Must include the literal `<PROFILE>` placeholder** — the runner substitutes the user's CLI profile. Shell metacharacters (`;`, `\|`, `&`, `` ` ``, `$`, newlines) are rejected — executors pass arguments via argv, never `shell-exec` the string. |
+| `selectField`  | jq-style path to the field used as the selected value (e.g. `.id`, `.name`).                                                                                                                                                                                                      |
+| `displayField` | jq-style path to the field shown to the user. Defaults to `selectField`.                                                                                                                                                                                                          |
+| `dependsOn`    | Sibling field that must resolve first.                                                                                                                                                                                                                                            |
+| `shortcut`     | Single-value fast-path command. Same metacharacter restriction as `cliCommand`.                                                                                                                                                                                                   |
+
+The `cli` variant is intentionally minimal and may tighten in future versions. **Prefer the `kind` variant** for any resource AppKit knows about; it gives you a single source of truth for command + unwrap rules and guarantees forward-compat as AppKit refines the discovery contract.
+
+### Field dependencies[​](#field-dependencies "Direct link to Field dependencies")
+
+When listing one resource depends on another (e.g. listing volumes requires a catalog and schema; listing Postgres branches requires a project), use `dependsOn` to declare ordering:
+
+```json
+{
+  "fields": {
+    "project": {
+      "discovery": { "type": "kind", "resourceKind": "postgres_project", "select": "name" }
+    },
+    "branch": {
+      "discovery": {
+        "type": "kind",
+        "resourceKind": "postgres_branch",
+        "select": "name",
+        "dependsOn": "project"
+      }
+    }
+  }
+}
+
+```
+
+`dependsOn` references a sibling field name within the same resource. The CLI prompts in dependency order and substitutes the resolved value into the parent command (e.g. `{project}` in `databricks postgres list-branches {project}`).
+
+The schema validates the dependency graph at parse time:
+
+* Dangling references (`dependsOn` pointing at a non-existent sibling) are rejected.
+* Cycles are rejected with the chain listed (`a → b → a`).
+
+### Transient prompts (`parents`)[​](#transient-prompts-parents "Direct link to transient-prompts-parents")
+
+Some `kind`-variant commands need values that are **not** sibling fields on the resource — they are query inputs the runner collects once and discards. AppKit declares these on the `kind` itself via a `parents` array on `RESOURCE_KIND_COMMANDS`.
+
+The only kind that uses `parents` today is `volume`:
+
+```text
+volume → parents: ["catalog", "schema"]
+
+```
+
+Before invoking `databricks volumes list {catalog} {schema} --profile <PROFILE> --output json`, the runner prompts the user for each `parents` entry as free text and substitutes the value into the matching `{name}` placeholder. Unlike `dependsOn`, the collected values are **not** persisted as resource fields — they exist only for the duration of the listing call.
+
+Plugin authors do not declare `parents` in their manifest; it is part of the AppKit-owned `kind` contract and surfaces in the published JSON Schema alongside each kind's command template.
+
+## Scaffolding rules[​](#scaffolding-rules "Direct link to Scaffolding rules")
+
+`scaffolding.rules` is the plugin-level handoff to scaffolding agents (LLM-driven runners, custom CLI workflows, the `databricks-apps` skill). It carries up to three short directive lists — `must`, `should`, `never` — that the agent honors when invoking `databricks apps init` with this plugin selected.
+
+```json
+{
+  "scaffolding": {
+    "rules": {
+      "should": [
+        "After init, run any database migrations for your chosen ORM before first request",
+        "After init, verify Lakebase connectivity with 'psql $PGHOST -c \"select 1\"'"
+      ]
+    }
+  }
+}
+
+```
+
+| Bucket   | Semantics                                             |
+| -------- | ----------------------------------------------------- |
+| `must`   | The agent must perform the action.                    |
+| `should` | Recommended action — agent applies unless overridden. |
+| `never`  | The agent must not perform the action.                |
+
+### Authoring contract[​](#authoring-contract "Direct link to Authoring contract")
+
+* Each entry is a single short directive, **capped at 120 characters** by the schema. Long prose fails validation; split it into discrete actionable items.
+* The schema enforces both **per-bucket dedup** (no two entries with the same text inside one of `must` / `should` / `never`) and **cross-bucket dedup** (one entry cannot belong to two buckets at once).
+* Use the `Before init` / `After init` prefix convention when ordering matters so consumers can sequence directives consistently.
+
+### Substitutability gate[​](#substitutability-gate "Direct link to Substitutability gate")
+
+A rule belongs in the manifest **only if it cannot be expressed as structured data** somewhere else — a resource permission, a `discovery` descriptor, a `dependsOn` chain, a `requiredByTemplate` flag, a config field, or the field's `env` / `value` / `resolve` slot.
+
+Examples of what **does** survive the gate:
+
+* `"After init, run any database migrations for your chosen ORM before first request"` — runtime sequencing, not derivable from any resource shape.
+* `"After init, configure the 'spaces' map in plugin config with alias-to-Space-ID mappings"` — config-population guidance the schema cannot encode.
+
+Examples of what does **not** survive (and should be modeled instead):
+
+* "Plugin X requires `READ_VOLUME` on its volume" → already encoded in the resource's `permission` field.
+* "The runner must list Postgres branches after a project is chosen" → already encoded via `dependsOn`.
+* "Prompt the user for catalog and schema before listing volumes" → already encoded via `RESOURCE_KIND_COMMANDS.volume.parents`.
+
+If you find yourself writing prose that the schema could capture, extend the schema instead.
+
+The rules block is propagated unchanged from the plugin manifest into the synced template manifest. See [Templates — `scaffolding.rules` propagation](./docs/development/templates.md#scaffoldingrules-propagation) for how the CLI merges plugin-level rules with the template-level rules block.
+
+## Optional fields[​](#optional-fields "Direct link to Optional fields")
+
+| Field            | Description                                                                                                                             |
+| ---------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
+| `author`         | Author name or organization.                                                                                                            |
+| `version`        | Plugin version, semver format (`X.Y.Z` or `X.Y.Z-prerelease`).                                                                          |
+| `repository`     | URL to the plugin source.                                                                                                               |
+| `keywords`       | Discovery keywords.                                                                                                                     |
+| `license`        | SPDX identifier.                                                                                                                        |
+| `onSetupMessage` | One-shot message displayed after init. Use for short hints; prefer `scaffolding.rules` for actionable directives an agent must enforce. |
+| `hidden`         | When `true`, the plugin is excluded from the synced template manifest.                                                                  |
+| `stability`      | `"beta"` or `"ga"`. Beta plugins may break across minor releases — see [Plugin stability tiers](./docs/plugins/stability.md).     |
+| `config.schema`  | JSON Schema for the plugin's runtime config (used by the type generator and for validation).                                            |
+
+## See also[​](#see-also "Direct link to See also")
+
+* [Creating custom plugins](./docs/plugins/custom-plugins.md) — building a plugin from scratch.
+* [Plugin management](./docs/plugins/plugin-management.md) — `appkit plugin sync`, `create`, `validate`, `add-resource`.
+* [Templates](./docs/development/templates.md) — how the synced template manifest drives `databricks apps init`.
+* [`PluginManifest` API reference](./docs/api/appkit/Interface.PluginManifest.md) — TypeScript type.

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.295.0 or higher): install and configure it according to the [official tutorial](https://docs.databricks.com/aws/en/dev-tools/cli/tutorial).
+* Databricks CLI (v1.0.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 install
+databricks aitools install
 
 ```
 

package/llms.txt

@@ -52,6 +52,7 @@ npx @databricks/appkit docs <query>
 - [Genie plugin](./docs/plugins/genie.md): Integrates Databricks AI/BI Genie spaces into your AppKit application, enabling natural language data queries via a conversational interface.
 - [Jobs plugin](./docs/plugins/jobs.md): Trigger and monitor Databricks Lakeflow Jobs from your AppKit application.
 - [Lakebase plugin](./docs/plugins/lakebase.md): Provides a PostgreSQL connection pool for Databricks Lakebase Autoscaling with automatic OAuth token refresh.
+- [Plugin manifest](./docs/plugins/manifest.md): Every plugin ships a manifest.json next to its source code. The manifest declares plugin metadata, the Databricks resources the plugin needs, and any structured rules a scaffolding agent must honor when running databricks apps init. It is consumed at three stages:
 - [Model Serving plugin](./docs/plugins/model-serving.md): Provides an authenticated proxy to Databricks Model Serving endpoints, with invoke and streaming support.
 - [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.
@@ -76,7 +77,7 @@ npx @databricks/appkit docs <query>
 - [Class: TunnelError](./docs/api/appkit/Class.TunnelError.md): Error thrown when remote tunnel operations fail.
 - [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
+- [Enumeration: ResourceType](./docs/api/appkit/Enumeration.ResourceType.md): Resource types from resourceTypeSchema.options
 - [Function: agentIdFromMarkdownPath()](./docs/api/appkit/Function.agentIdFromMarkdownPath.md): Derives the logical agent id from a markdown path. When the file is named
 - [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.
@@ -141,7 +142,6 @@ npx @databricks/appkit docs <query>
 - [Interface: RequestedClaims](./docs/api/appkit/Interface.RequestedClaims.md): Optional claims for fine-grained Unity Catalog table permissions
 - [Interface: RequestedResource](./docs/api/appkit/Interface.RequestedResource.md): Resource to request permissions for in Unity Catalog
 - [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: RunAgentInput](./docs/api/appkit/Interface.RunAgentInput.md): Properties
 - [Interface: RunAgentResult](./docs/api/appkit/Interface.RunAgentResult.md): Properties
@@ -174,6 +174,7 @@ npx @databricks/appkit docs <query>
 - [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: Plugins](./docs/api/appkit/TypeAlias.Plugins.md): Plugin map passed to the function form of AgentDefinition.tools.
 - [Type Alias: ResolvedToolEntry](./docs/api/appkit/TypeAlias.ResolvedToolEntry.md): Internal tool-index entry after a tool record has been resolved to a dispatchable form.
+- [Type Alias: ResourceFieldEntry](./docs/api/appkit/TypeAlias.ResourceFieldEntry.md)
 - [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: ToolRegistry](./docs/api/appkit/TypeAlias.ToolRegistry.md)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@databricks/appkit",
   "type": "module",
-  "version": "0.37.0",
+  "version": "0.38.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "bin": {
@@ -41,6 +41,7 @@
     "clean": "rm -rf dist tmp",
     "dist": "tsx ../../tools/dist-appkit.ts",
     "tarball": "rm -rf tmp && pnpm dist && npm pack ./tmp --pack-destination ./tmp",
+    "tarball:prerelease": "rm -rf tmp && SHORTSHA=$(git rev-parse --short HEAD) && pnpm dist --prerelease $SHORTSHA && npm pack ./tmp --pack-destination ./tmp",
     "typecheck": "tsc --noEmit",
     "postinstall": "node scripts/postinstall.js"
   },
@@ -76,8 +77,7 @@
     "vite": "npm:rolldown-vite@7.1.14",
     "ws": "8.18.3",
     "zod": "4.3.6",
-    "ajv": "8.17.1",
-    "ajv-formats": "3.0.1",
+    "@standard-schema/spec": "1.1.0",
     "@clack/prompts": "1.0.1",
     "commander": "12.1.0"
   },