@segmentstream-cloud/ontology 0.9.0 → 0.11.0

package/dist/action.d.ts

@@ -17,6 +17,17 @@ export interface ActionContext<Input, Prepared = undefined> extends PrepareConte
 }
 /** What `prepare` may fail with: the action errors, and connection calls that failed. */
 export type PrepareError = ActionError | ConnectionError;
+/**
+ * How an action behaves, as MCP tool annotations tell agents. Clients such as Claude ask the user
+ * before they run a destructive tool. Without hints an action is taken as destructive and not
+ * idempotent.
+ */
+export interface ActionHints {
+    /** Whether the action may overwrite or remove what someone decided. Default true. */
+    readonly destructive?: boolean;
+    /** Whether running it again with the same input changes nothing more. Default false. */
+    readonly idempotent?: boolean;
+}
 /** A described, typed, permissioned Effect function: the only way to change records. */
 export interface Action<Input extends Schema.Top = Schema.Top, Result = unknown> {
     readonly [ActionTypeId]: typeof ActionTypeId;
@@ -27,6 +38,8 @@ export interface Action<Input extends Schema.Top = Schema.Top, Result = unknown>
      * is not set, the action requires `<entity>:<action name>`, for example `lead:changeStatus`.
      */
     readonly permission: string | undefined;
+    /** How the action behaves, as `action({ hints })` set it; see {@link ActionHints}. */
+    readonly hints: ActionHints | undefined;
     /** The connections `prepare` may call; empty for an action without `prepare`. */
     readonly connections: ReadonlyArray<AnyConnectionHandle>;
     /**
@@ -64,6 +77,12 @@ interface ActionOptions<Input extends Schema.Top> {
      * Roles grant it in their `permissions`.
      */
     readonly permission?: string;
+    /**
+     * How the action behaves, for the agents that run it over MCP. Set `destructive: false` for an
+     * action that only adds or that history makes easy to reverse, and `idempotent: true` for one
+     * that a repeated call leaves as it was.
+     */
+    readonly hints?: ActionHints;
 }
 export interface ActionConfig<Input extends Schema.Top, Result> extends ActionOptions<Input> {
     /**

package/dist/action.js

@@ -11,6 +11,7 @@ export function action(config) {
         description: config.description,
         input: config.input,
         permission: config.permission,
+        hints: config.hints,
         connections: config.connections ?? [],
         ...(config.prepare === undefined ? {} : { prepare: config.prepare }),
         // A prepare-only action answers with what prepare returned; it writes nothing.

package/dist/analyze.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { type Action } from "./action.js";
+import { type Action, type ActionHints } from "./action.js";
 import { type AnyConnectionHandle } from "./connection.js";
 import type { Diagnostic } from "./diagnostics.js";
 import { type AnyEntity } from "./entity.js";
@@ -67,6 +67,8 @@ export interface ResolvedAction {
     readonly input: JsonSchemaObject | undefined;
     /** The keys of the connections the action's `prepare` calls, in declaration order. */
     readonly connections: ReadonlyArray<string>;
+    /** The hints the action declares, or `undefined` when it declares none. */
+    readonly hints: ActionHints | undefined;
 }
 /** A connection the ontology declares. */
 export interface ResolvedConnection {

package/dist/analyze.js

@@ -1,9 +1,11 @@
 import { checkWarehouseSource } from "./warehouse-backed.js";
 import { Schema } from "effect";
+import { BLOB_UPLOAD_ANNOTATION } from "./blob.js";
+import { BLOB_CONTENT_TYPES, MAX_BLOB_BYTES } from "./blob.js";
 import { isAction } from "./action.js";
 import { CONNECTION_KEY, isConnection } from "./connection.js";
 import { isEntity } from "./entity.js";
-import { LEGACY_MEMBER_NAME, ENTITY_ID, GENERATED_ACTIONS, GENERATED_UPSERT_PREFIX, HISTORY_SUFFIX, MEMBER_ROLE, RESERVED_ENTITY_NAMES, RESERVED_MEMBER_NAMES, RESERVED_RELATIONSHIP_NAMES, SNAKE_CASE_NAME, SYSTEM_PROPERTIES, isSystemProperty, } from "./names.js";
+import { LEGACY_MEMBER_NAME, ENTITY_ID, GENERATED_ACTIONS, GENERATED_UPSERT_PREFIX, HISTORY_SUFFIX, MCP_READ_TOOLS, MCP_TOOL_NAME_MAX_LENGTH, MEMBER_ROLE, mcpToolName, RESERVED_ENTITY_NAMES, RESERVED_MEMBER_NAMES, RESERVED_RELATIONSHIP_NAMES, SNAKE_CASE_NAME, SYSTEM_PROPERTIES, isSystemProperty, } from "./names.js";
 import { REFERENCE_ANNOTATION, propertyDefinition, referenceTarget, } from "./property.js";
 import { generatedActionPermissions, parsePermission, permissionOf, READ_VERB, rolesGranting, WILDCARD, } from "./permissions.js";
 import { ON_DELETE, isRelationship } from "./relationship.js";
@@ -56,6 +58,7 @@ export function analyze(config, options = {}) {
     const resolved = entities.map((candidate) => resolveEntity(candidate, scope));
     checkEntityIdentities(resolved, report);
     checkMemberNames(resolved, report);
+    checkToolNames(resolved, report);
     checkWarehouseSource(resolved, report);
     checkConnectionsUsed(resolved, connections, config.connections ?? [], report);
     if (options.checkPermissions !== false) {
@@ -63,6 +66,58 @@ export function analyze(config, options = {}) {
     }
     return { entities: resolved, roles, signIn, connections, diagnostics };
 }
+/**
+ * The operations of a stored entity that become MCP tools, each with the path a problem is reported
+ * at: the reads, the generated actions and the authored actions.
+ */
+function toolOperations(candidate) {
+    const { permissions } = candidate;
+    const generated = [
+        ...(permissions.create !== undefined ? ["create", "update", "delete"] : []),
+        ...(permissions.create !== undefined
+            ? candidate.properties
+                .filter(({ definition }) => definition.unique)
+                .map(({ name }) => `${GENERATED_UPSERT_PREFIX}${name}`)
+            : []),
+        ...(permissions.link !== undefined ? ["link", "unlink"] : []),
+    ];
+    return [
+        ...[...MCP_READ_TOOLS, ...generated].map((operation) => ({ operation, path: candidate.name })),
+        // An authored action with a generated action's name is already refused as a reserved name.
+        ...candidate.actions
+            .filter(({ name }) => !GENERATED_ACTIONS.includes(name) && !GENERATED_UPSERT.test(name))
+            .map(({ name }) => ({ operation: name, path: `${candidate.name}.actions.${name}` })),
+    ];
+}
+/**
+ * Every MCP tool needs a name of its own, at most 64 characters long. A tool's name joins the
+ * entity's and the operation's with an underscore, so entity `pilot` with an action `request_find`
+ * would take the name of entity `pilot_request`'s `find`.
+ */
+function checkToolNames(entities, report) {
+    const owners = new Map();
+    const seen = new Set();
+    for (const candidate of entities) {
+        // A second entity with the same name is already refused as a duplicate.
+        if (candidate.entity.definition.source !== undefined || seen.has(candidate.name)) {
+            continue;
+        }
+        seen.add(candidate.name);
+        for (const { operation, path } of toolOperations(candidate)) {
+            const name = mcpToolName(candidate.name, operation);
+            const owner = owners.get(name);
+            if (owner !== undefined) {
+                report("invalid-tool-name", path, `its MCP tool ${name} is already the tool of ${owner}; rename one of them.`);
+                continue;
+            }
+            owners.set(name, `${candidate.name}'s ${operation}`);
+            if (name.length > MCP_TOOL_NAME_MAX_LENGTH) {
+                report("invalid-tool-name", path, `its MCP tool ${name} is ${name.length} characters long; agents accept at most ` +
+                    `${MCP_TOOL_NAME_MAX_LENGTH}. Shorten the entity or the action name.`);
+            }
+        }
+    }
+}
 /** The handles `defineOntology({ connections })` lists, each with a valid key and a description. */
 function collectConnections(config, report) {
     const declared = config.connections;
@@ -340,6 +395,19 @@ function resolveProperties(candidate, scope) {
     return properties;
 }
 function checkProperty(path, schema, definition, report) {
+    if (definition.type === "blob") {
+        if (definition.unique || "default" in definition) {
+            report("invalid-property", path, "Blob properties cannot be unique or have a default.");
+        }
+        if (!definition.accept?.length ||
+            definition.accept.some((type) => !BLOB_CONTENT_TYPES.includes(type)) ||
+            new Set(definition.accept).size !== definition.accept.length ||
+            !Number.isInteger(definition.maxBytes) ||
+            definition.maxBytes < 1 ||
+            definition.maxBytes > MAX_BLOB_BYTES) {
+            report("invalid-constraint", path, "Use supported content types and a limit from 1 byte to 25 MiB.");
+        }
+    }
     if (definition.type === "select") {
         checkSelectOptions(path, definition, report);
     }
@@ -531,10 +599,37 @@ function resolveActions(candidate, scope) {
             permission: resolvePermission(path, permissionOf(candidate.name, name), action, scope),
             input: resolveInput(path, action.input, scope),
             connections: resolveActionConnections(path, action, scope),
+            hints: resolveHints(path, action, report),
         });
     }
     return actions;
 }
+const HINT_NAMES = ["destructive", "idempotent"];
+/** The action's `hints`: an object of booleans, `destructive` and `idempotent`. */
+function resolveHints(path, action, report) {
+    const declared = action.hints;
+    if (declared === undefined) {
+        return undefined;
+    }
+    const at = `${path}.hints`;
+    if (!isPlainObject(declared)) {
+        report("invalid-action", at, "hints is an object such as { destructive: false }.");
+        return undefined;
+    }
+    const hints = {};
+    for (const [key, value] of Object.entries(declared)) {
+        if (!HINT_NAMES.includes(key)) {
+            report("invalid-action", `${at}.${key}`, `is not a hint; use ${HINT_NAMES.join(" or ")}.`);
+        }
+        else if (typeof value !== "boolean") {
+            report("invalid-action", `${at}.${key}`, "is true or false.");
+        }
+        else {
+            hints[key] = value;
+        }
+    }
+    return hints;
+}
 /** The action's own `permission`, which names an entity and a verb without wildcards. */
 function resolvePermission(path, fallback, action, scope) {
     const declared = action.permission;
@@ -563,7 +658,7 @@ function resolveInput(path, input, scope) {
     }
     try {
         const document = Schema.toJsonSchemaDocument(input, {
-            includeAnnotationKey: (key) => key === REFERENCE_ANNOTATION,
+            includeAnnotationKey: (key) => key === REFERENCE_ANNOTATION || key === BLOB_UPLOAD_ANNOTATION,
             onExcessProperty: "error",
         });
         const schema = document.schema;

package/dist/bin/migrate.js

@@ -2,7 +2,7 @@ import * as PgClient from "@effect/sql-pg/PgClient";
 import { Cause, Effect, Redacted } from "effect";
 import { SqlClient } from "effect/unstable/sql";
 import { isSqlError } from "effect/unstable/sql/SqlError";
-import { applyMigration, readCatalog } from "../migrate/apply.js";
+import { applyMigration, readCatalog, readRuntimeTables, } from "../migrate/apply.js";
 import { MigrationRefused } from "../migrate/errors.js";
 import { isNoopMigration } from "../migrate/model.js";
 import { planMigration } from "../migrate/plan.js";
@@ -88,7 +88,8 @@ function migrateDatabase(input) {
     return Effect.gen(function* () {
         const sql = yield* SqlClient.SqlClient;
         const current = yield* readCatalog({ sql });
-        const plan = planMigration({ current, target });
+        const existingTables = yield* readRuntimeTables({ sql });
+        const plan = planMigration({ current, target, existingTables });
         output.stdout(formatPlan(plan, { sql: input.planOnly }));
         if (plan.refusals.length > 0) {
             output.stderr(formatRefusals(plan.refusals));

package/dist/blob.d.ts

@@ -0,0 +1,39 @@
+import { Schema } from "effect";
+/** Metadata of an immutable file revision. Provider keys and grants never appear in records. */
+export declare const BlobValue: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly filename: Schema.String;
+    readonly contentType: Schema.String;
+    readonly size: Schema.Int;
+    readonly createdAt: Schema.String;
+}>;
+export type BlobValue = typeof BlobValue.Type;
+/** An opaque completed-upload ticket. Only the action runtime may resolve and consume it. */
+declare function uploadCodec(entity?: string, property?: string): Schema.decodeTo<Schema.Struct<{
+    readonly uploadId: Schema.String;
+}>, Schema.Struct<{
+    readonly upload_id: Schema.String;
+}>, never, never>;
+export declare const BlobUpload: Schema.Struct<{
+    readonly uploadId: Schema.String;
+}>;
+export type BlobUpload = typeof BlobUpload.Type;
+export declare const BLOB_UPLOAD_ANNOTATION = "x-ontology-upload";
+export declare const MAX_BLOB_BYTES: number;
+export declare const BLOB_CONTENT_TYPES: readonly ["application/pdf", "image/jpeg", "image/png", "text/plain"];
+type SchemaValue<S> = S extends {
+    readonly Type: infer T;
+} ? T : S extends Schema.optionalKey<infer Inner> ? Inner["Type"] : never;
+type BlobPropertyKey<P> = {
+    [K in keyof P]: NonNullable<SchemaValue<P[K]>> extends BlobValue ? K : never;
+}[keyof P] & string;
+/** Internal wire codec for session tickets and generated action inputs. */
+export declare function uploadInput(entity?: string, property?: string): ReturnType<typeof uploadCodec>;
+/** Declares which blob field an authored action's upload input may write. */
+export declare const uploads: {
+    for<const P extends Readonly<Record<string, unknown>>>(entity: {
+        readonly name: string;
+        readonly properties: P;
+    }, property: BlobPropertyKey<P>): typeof BlobUpload;
+};
+export {};

package/dist/blob.js

@@ -0,0 +1,49 @@
+import { Schema, SchemaTransformation } from "effect";
+import { nameToWire } from "./authoring-names.js";
+/** Metadata of an immutable file revision. Provider keys and grants never appear in records. */
+export const BlobValue = Schema.Struct({
+    id: Schema.String.check(Schema.isUUID()),
+    filename: Schema.String,
+    contentType: Schema.String,
+    size: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    createdAt: Schema.String,
+});
+/** An opaque completed-upload ticket. Only the action runtime may resolve and consume it. */
+function uploadCodec(entity, property) {
+    const id = Schema.String.check(Schema.isUUID());
+    return Schema.Struct({ upload_id: id })
+        .annotate({
+        ...(entity && property
+            ? {
+                description: `A completed upload for ${entity}.${property}.`,
+                "x-ontology-upload": { entity, property },
+            }
+            : {}),
+    })
+        .pipe(Schema.decodeTo(Schema.Struct({ uploadId: id }), SchemaTransformation.transform({
+        decode: (value) => ({ uploadId: value.upload_id }),
+        encode: (value) => ({ upload_id: value.uploadId }),
+    })));
+}
+export const BlobUpload = Schema.Struct({ uploadId: Schema.String.check(Schema.isUUID()) });
+export const BLOB_UPLOAD_ANNOTATION = "x-ontology-upload";
+export const MAX_BLOB_BYTES = 25 * 1024 * 1024;
+export const BLOB_CONTENT_TYPES = [
+    "application/pdf",
+    "image/jpeg",
+    "image/png",
+    "text/plain",
+];
+/** Internal wire codec for session tickets and generated action inputs. */
+export function uploadInput(entity, property) {
+    return uploadCodec(entity, property);
+}
+/** Declares which blob field an authored action's upload input may write. */
+export const uploads = {
+    for(entity, property) {
+        return BlobUpload.annotate({
+            description: `A completed upload for ${entity.name}.${property}.`,
+            "x-ontology-upload": { entity: nameToWire(entity.name), property: nameToWire(property) },
+        });
+    },
+};

package/dist/diagnostics.d.ts

@@ -1,10 +1,10 @@
 import { Schema } from "effect";
-export declare const DIAGNOSTIC_CODES: readonly ["invalid-source", "missing-column", "invalid-column", "invalid-scope", "source-with-actions", "source-with-index", "invalid-measure", "unknown-measure", "circular-measure", "invalid-join", "missing-join", "invalid-entity", "invalid-property", "invalid-relationship", "invalid-actions", "invalid-action", "invalid-action-input", "invalid-role", "invalid-name", "reserved-name", "duplicate-name", "invalid-entity-id", "duplicate-entity-id", "missing-label", "missing-description", "invalid-title", "invalid-options", "invalid-default", "invalid-constraint", "unknown-relationship-target", "inverse-collision", "invalid-on-delete", "invalid-phrase", "invalid-index", "unknown-reference", "invalid-renamed-from", "invalid-guide", "managed-without-effect", "missing-permissions", "invalid-permission", "unknown-permission", "removed-allow", "unreachable-action", "wildcard-permission", "invalid-sign-in", "invalid-connection", "unknown-connection", "unused-connection", "invalid-prepare"];
+export declare const DIAGNOSTIC_CODES: readonly ["invalid-source", "missing-column", "invalid-column", "invalid-scope", "source-with-actions", "source-with-index", "invalid-measure", "unknown-measure", "circular-measure", "invalid-join", "missing-join", "invalid-entity", "invalid-property", "invalid-relationship", "invalid-actions", "invalid-action", "invalid-action-input", "invalid-role", "invalid-name", "reserved-name", "duplicate-name", "invalid-entity-id", "duplicate-entity-id", "missing-label", "missing-description", "invalid-title", "invalid-options", "invalid-default", "invalid-constraint", "unknown-relationship-target", "inverse-collision", "invalid-on-delete", "invalid-phrase", "invalid-index", "unknown-reference", "invalid-renamed-from", "invalid-guide", "managed-without-effect", "missing-permissions", "invalid-permission", "unknown-permission", "removed-allow", "unreachable-action", "wildcard-permission", "invalid-sign-in", "invalid-connection", "unknown-connection", "unused-connection", "invalid-prepare", "invalid-tool-name"];
 export type DiagnosticCode = (typeof DIAGNOSTIC_CODES)[number];
 /** A problem `check` found in an ontology definition. */
 export declare const Diagnostic: Schema.Struct<{
     readonly severity: Schema.Literals<readonly ["error", "warning"]>;
-    readonly code: Schema.Literals<readonly ["invalid-source", "missing-column", "invalid-column", "invalid-scope", "source-with-actions", "source-with-index", "invalid-measure", "unknown-measure", "circular-measure", "invalid-join", "missing-join", "invalid-entity", "invalid-property", "invalid-relationship", "invalid-actions", "invalid-action", "invalid-action-input", "invalid-role", "invalid-name", "reserved-name", "duplicate-name", "invalid-entity-id", "duplicate-entity-id", "missing-label", "missing-description", "invalid-title", "invalid-options", "invalid-default", "invalid-constraint", "unknown-relationship-target", "inverse-collision", "invalid-on-delete", "invalid-phrase", "invalid-index", "unknown-reference", "invalid-renamed-from", "invalid-guide", "managed-without-effect", "missing-permissions", "invalid-permission", "unknown-permission", "removed-allow", "unreachable-action", "wildcard-permission", "invalid-sign-in", "invalid-connection", "unknown-connection", "unused-connection", "invalid-prepare"]>;
+    readonly code: Schema.Literals<readonly ["invalid-source", "missing-column", "invalid-column", "invalid-scope", "source-with-actions", "source-with-index", "invalid-measure", "unknown-measure", "circular-measure", "invalid-join", "missing-join", "invalid-entity", "invalid-property", "invalid-relationship", "invalid-actions", "invalid-action", "invalid-action-input", "invalid-role", "invalid-name", "reserved-name", "duplicate-name", "invalid-entity-id", "duplicate-entity-id", "missing-label", "missing-description", "invalid-title", "invalid-options", "invalid-default", "invalid-constraint", "unknown-relationship-target", "inverse-collision", "invalid-on-delete", "invalid-phrase", "invalid-index", "unknown-reference", "invalid-renamed-from", "invalid-guide", "managed-without-effect", "missing-permissions", "invalid-permission", "unknown-permission", "removed-allow", "unreachable-action", "wildcard-permission", "invalid-sign-in", "invalid-connection", "unknown-connection", "unused-connection", "invalid-prepare", "invalid-tool-name"]>;
     /** Where the problem is, for example `lead.properties.status.options[1]`. */
     readonly path: Schema.String;
     readonly message: Schema.String;
@@ -14,7 +14,7 @@ declare const InvalidOntology_base: Schema.Class<InvalidOntology, Schema.TaggedS
     readonly message: Schema.String;
     readonly diagnostics: Schema.$Array<Schema.Struct<{
         readonly severity: Schema.Literals<readonly ["error", "warning"]>;
-        readonly code: Schema.Literals<readonly ["invalid-source", "missing-column", "invalid-column", "invalid-scope", "source-with-actions", "source-with-index", "invalid-measure", "unknown-measure", "circular-measure", "invalid-join", "missing-join", "invalid-entity", "invalid-property", "invalid-relationship", "invalid-actions", "invalid-action", "invalid-action-input", "invalid-role", "invalid-name", "reserved-name", "duplicate-name", "invalid-entity-id", "duplicate-entity-id", "missing-label", "missing-description", "invalid-title", "invalid-options", "invalid-default", "invalid-constraint", "unknown-relationship-target", "inverse-collision", "invalid-on-delete", "invalid-phrase", "invalid-index", "unknown-reference", "invalid-renamed-from", "invalid-guide", "managed-without-effect", "missing-permissions", "invalid-permission", "unknown-permission", "removed-allow", "unreachable-action", "wildcard-permission", "invalid-sign-in", "invalid-connection", "unknown-connection", "unused-connection", "invalid-prepare"]>;
+        readonly code: Schema.Literals<readonly ["invalid-source", "missing-column", "invalid-column", "invalid-scope", "source-with-actions", "source-with-index", "invalid-measure", "unknown-measure", "circular-measure", "invalid-join", "missing-join", "invalid-entity", "invalid-property", "invalid-relationship", "invalid-actions", "invalid-action", "invalid-action-input", "invalid-role", "invalid-name", "reserved-name", "duplicate-name", "invalid-entity-id", "duplicate-entity-id", "missing-label", "missing-description", "invalid-title", "invalid-options", "invalid-default", "invalid-constraint", "unknown-relationship-target", "inverse-collision", "invalid-on-delete", "invalid-phrase", "invalid-index", "unknown-reference", "invalid-renamed-from", "invalid-guide", "managed-without-effect", "missing-permissions", "invalid-permission", "unknown-permission", "removed-allow", "unreachable-action", "wildcard-permission", "invalid-sign-in", "invalid-connection", "unknown-connection", "unused-connection", "invalid-prepare", "invalid-tool-name"]>;
         /** Where the problem is, for example `lead.properties.status.options[1]`. */
         readonly path: Schema.String;
         readonly message: Schema.String;

package/dist/diagnostics.js

@@ -49,6 +49,7 @@ export const DIAGNOSTIC_CODES = [
     "unknown-connection",
     "unused-connection",
     "invalid-prepare",
+    "invalid-tool-name",
 ];
 /** A problem `check` found in an ontology definition. */
 export const Diagnostic = Schema.Struct({

package/dist/entity.d.ts

@@ -1,3 +1,4 @@
+import type { BlobUpload, BlobValue } from "./blob.js";
 import { Effect, type Schema } from "effect";
 import type { Measures } from "./measure.js";
 import type { WarehouseSource } from "./source.js";
@@ -39,6 +40,7 @@ type IsOptional<S> = S extends {
 type ValueOf<S> = S extends {
     readonly Type: infer T;
 } ? IsOptional<S> extends true ? T | null : T : never;
+type WriteValueOf<S> = NonNullable<ValueOf<S>> extends BlobValue ? BlobUpload | (null extends ValueOf<S> ? null : never) : ValueOf<S>;
 type RequiredOnCreate<S> = IsOptional<S> extends true ? false : S extends {
     readonly "~ontology.defaulted": true;
 } ? false : true;
@@ -68,9 +70,9 @@ export type EntityRecord<P, R> = Simplify<SystemFields & {
  * relationships take ids by relationship name (`{ lead: lead.id }`), `rel.many` a list of ids.
  */
 export type CreateValues<P, R> = Simplify<{
-    readonly [K in RequiredPropertyKeys<P>]: ValueOf<P[K]>;
+    readonly [K in RequiredPropertyKeys<P>]: WriteValueOf<P[K]>;
 } & {
-    readonly [K in Exclude<keyof P, RequiredPropertyKeys<P>>]?: ValueOf<P[K]>;
+    readonly [K in Exclude<keyof P, RequiredPropertyKeys<P>>]?: WriteValueOf<P[K]>;
 } & {
     readonly [K in RequiredOneKeys<R>]: string;
 } & {
@@ -80,7 +82,7 @@ export type CreateValues<P, R> = Simplify<{
 }>;
 /** Values for `update`. Handlers may write `managed` properties; the generated `update` may not. */
 export type UpdateValues<P, R> = Simplify<{
-    readonly [K in keyof P]?: ValueOf<P[K]>;
+    readonly [K in keyof P]?: WriteValueOf<P[K]>;
 } & {
     readonly [K in OneKeys<R>]?: R[K] extends OneRelationship<true> ? string | null : string;
 } & {

package/dist/index.d.ts

@@ -1,9 +1,10 @@
+export { BlobValue, BlobUpload, uploads, BLOB_CONTENT_TYPES, MAX_BLOB_BYTES } from "./blob.js";
 export { warehouse, compatibleWarehouseColumn, warehouseColumnType, validateWarehouseSource, } from "./source.js";
 export type { WarehouseSource } from "./source.js";
 export { m } from "./measure.js";
 export type { Measure, Measures, MeasureExpression, MeasureOptions } from "./measure.js";
 export { action, isAction } from "./action.js";
-export type { Action, ActionConfig, ActionConfigWithConnections, ActionContext, ActionEncodedInput, ActionInput, ActionResult, Actions, AnyAction, PrepareContext, PrepareError, } from "./action.js";
+export type { Action, ActionConfig, ActionConfigWithConnections, ActionContext, ActionEncodedInput, ActionHints, ActionInput, ActionResult, Actions, AnyAction, PrepareContext, PrepareError, } from "./action.js";
 export { CONNECTION_ERROR_REASONS, CONNECTION_KEY, CONNECTION_METHODS, connection, ConnectionError, Connections, ConnectionTransport, isConnection, MAXIMUM_CONNECTION_BODY_BYTES, } from "./connection.js";
 export type { AnyConnectionHandle, Connection, ConnectionCall, ConnectionClient, ConnectionErrorReason, ConnectionHandle, ConnectionHeaders, ConnectionMethod, ConnectionOptions, ConnectionReply, ConnectionRequest, ConnectionRequestOptions, ConnectionResponse, ConnectionsOf, ConnectionStub, StubRequest, StubResponse, } from "./connection.js";
 export type { EntityPermissions, JsonSchemaObject, MemberOptions, OntologyConfig, ResolvedAction, ResolvedConnection, ResolvedEntity, ResolvedIndex, ResolvedProperty, ResolvedRelationship, } from "./analyze.js";
@@ -21,7 +22,7 @@ export type { Ontology } from "./ontology.js";
 export { DEFAULT_MEMBER_PERMISSIONS, generatedActionPermissions, grants, isAllowed, parsePermission, permissionsOf, READ_VERB, rolesGranting, WILDCARD, } from "./permissions.js";
 export type { ParsedPermission, PermissionHolder, RolePermissions } from "./permissions.js";
 export { p, PROPERTY_TYPES, propertyDefinition } from "./property.js";
-export type { AnyProperty, NumberOptions, Property, PropertyDefinition, PropertyOf, PropertyOptions, PropertyType, ReferenceOptions, SelectOption, SelectOptionInput, TextOptions, } from "./property.js";
+export type { AnyProperty, NumberOptions, Property, PropertyDefinition, PropertyOf, PropertyOptions, BlobOptions, PropertyType, ReferenceOptions, SelectOption, SelectOptionInput, TextOptions, } from "./property.js";
 export { ON_DELETE, rel } from "./relationship.js";
 export type { AnyRelationship, EntityTarget, LazyEntity, ManyOptions, ManyRelationship, OnDelete, OneOptions, OneRelationship, Phrase, } from "./relationship.js";
 export { renderCatalog } from "./render.js";
@@ -54,8 +55,12 @@ export type { ConnectionAudit, ConnectionTransportFactory, LocalConnection, Loca
 export { configFromEnv, ENVIRONMENT_VARIABLES, NEON_AUTH_ENVIRONMENT_VARIABLES, OntologyServiceConfigError, } from "./service/config.js";
 export type { ActionCommitted, AfterCommitHook, NeonAuthEnvironment, OntologyEnvironment, OntologyServiceConfig, } from "./service/config.js";
 export { NotInvited, OntologyBackend } from "./service/runtime-contract.js";
-export type { GeneratedActionsProvider, IdentityProvider, OntologyServiceRuntime, RunActionInput, SignInIdentity, } from "./service/runtime-contract.js";
+export type { GeneratedActionsProvider, IdentityProvider, OAuthClient, OAuthClientAuthMethod, OAuthGrant, OAuthRequest, OAuthStore, OAuthToken, OAuthTokenKind, OntologyServiceRuntime, RunActionInput, SignInIdentity, UsedOAuthToken, } from "./service/runtime-contract.js";
 export { createOntologyService, ONTOLOGY_HASH_HEADER, REQUEST_ID_HEADER, } from "./service/service.js";
+export { MCP_PATH, MCP_PROTOCOL_VERSIONS } from "./service/mcp/server.js";
+export { MCP_TOOL_NAME_MAX_LENGTH, mcpToolName } from "./names.js";
 export type { OntologyService } from "./service/service.js";
-export { applyMigration, CatalogInvalid, CatalogMismatch, isNoopMigration, migrate, MIGRATION_REFUSAL_CODES, MIGRATION_STEP_CLASSIFICATIONS, MIGRATION_STEP_KINDS, MigrationFailed, MigrationPlan, MigrationRefusal, MigrationRefused, MigrationStep, OntologyStorage, planMigration, readCatalog, } from "./migrate/index.js";
+export { applyMigration, CatalogInvalid, CatalogMismatch, isNoopMigration, migrate, MIGRATION_REFUSAL_CODES, MIGRATION_STEP_CLASSIFICATIONS, MIGRATION_STEP_KINDS, MigrationFailed, MigrationPlan, MigrationRefusal, MigrationRefused, MigrationStep, OntologyStorage, planMigration, readCatalog, readRuntimeTables, } from "./migrate/index.js";
 export type { ApplyMigrationError, ApplyMigrationOptions, CatalogInput, MigrateInput, MigrationOptions, MigrationRefusalCode, MigrationResult, MigrationStepClassification, MigrationStepKind, PlanMigrationInput, } from "./migrate/index.js";
+export type { BlobStorageBinding } from "./storage/provider.js";
+export { runBlobStorageMaintenance } from "./storage/operator.js";

package/dist/index.js

@@ -1,3 +1,4 @@
+export { BlobValue, BlobUpload, uploads, BLOB_CONTENT_TYPES, MAX_BLOB_BYTES } from "./blob.js";
 export { warehouse, compatibleWarehouseColumn, warehouseColumnType, validateWarehouseSource, } from "./source.js";
 export { m } from "./measure.js";
 export { action, isAction } from "./action.js";
@@ -33,5 +34,9 @@ export { deployedConnections, LocalConnectionContextError, localConnections, OID
 export { configFromEnv, ENVIRONMENT_VARIABLES, NEON_AUTH_ENVIRONMENT_VARIABLES, OntologyServiceConfigError, } from "./service/config.js";
 export { NotInvited, OntologyBackend } from "./service/runtime-contract.js";
 export { createOntologyService, ONTOLOGY_HASH_HEADER, REQUEST_ID_HEADER, } from "./service/service.js";
+// The MCP server the service serves beside the HTTP API.
+export { MCP_PATH, MCP_PROTOCOL_VERSIONS } from "./service/mcp/server.js";
+export { MCP_TOOL_NAME_MAX_LENGTH, mcpToolName } from "./names.js";
 // Migrations: the planner, the applier and the physical mapping they share with the runtime.
-export { applyMigration, CatalogInvalid, CatalogMismatch, isNoopMigration, migrate, MIGRATION_REFUSAL_CODES, MIGRATION_STEP_CLASSIFICATIONS, MIGRATION_STEP_KINDS, MigrationFailed, MigrationPlan, MigrationRefusal, MigrationRefused, MigrationStep, OntologyStorage, planMigration, readCatalog, } from "./migrate/index.js";
+export { applyMigration, CatalogInvalid, CatalogMismatch, isNoopMigration, migrate, MIGRATION_REFUSAL_CODES, MIGRATION_STEP_CLASSIFICATIONS, MIGRATION_STEP_KINDS, MigrationFailed, MigrationPlan, MigrationRefusal, MigrationRefused, MigrationStep, OntologyStorage, planMigration, readCatalog, readRuntimeTables, } from "./migrate/index.js";
+export { runBlobStorageMaintenance } from "./storage/operator.js";