@agentic-kit/db-tools 0.2.0

package/tools/create-api-key.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApiKeyTool = void 0;
+exports.toEnvVar = toEnvVar;
+exports.isStepUpError = isStepUpError;
+exports.describeScope = describeScope;
+const sdk_1 = require("@constructive-io/sdk");
+const zod_1 = require("zod");
+const context_1 = require("../context");
+const host_1 = require("../host");
+const CreateApiKeyZod = zod_1.z.object({
+    key_name: zod_1.z
+        .string()
+        .describe('Name for the API key (e.g. "deploy bot"). The .env variable name derives from it (UPPER_SNAKE + _API_KEY).'),
+    principal_name: zod_1.z
+        .string()
+        .describe('Machine identity (principal) that owns the key. Defaults to key_name. An existing principal with this name is reused for unscoped keys.')
+        .optional(),
+    entity_ids: zod_1.z
+        .array(zod_1.z.string())
+        .describe('Entity row UUIDs to scope the principal to. Omit for a personal (unscoped) key that acts as the signed-in app user.')
+        .optional(),
+    read_only: zod_1.z
+        .boolean()
+        .describe('Restrict the principal and key to read-only operations.')
+        .optional(),
+    expires_in_days: zod_1.z
+        .number()
+        .int()
+        .positive()
+        .describe('Key lifetime in days. Default 90.')
+        .optional(),
+});
+function fail(message, extra) {
+    return {
+        content: [{ type: 'text', text: message }],
+        details: { success: false, message, ...extra },
+    };
+}
+function toEnvVar(keyName) {
+    const base = keyName
+        .trim()
+        .toUpperCase()
+        .replace(/[^A-Z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '');
+    return base.endsWith('_API_KEY') ? base : `${base}_API_KEY`;
+}
+function isStepUpError(messages) {
+    return messages.some((m) => /step[\s_-]?up/i.test(m));
+}
+function describeScope(entityIds, readOnly) {
+    const parts = [];
+    parts.push(entityIds?.length
+        ? `scoped to ${entityIds.length} entit${entityIds.length === 1 ? 'y' : 'ies'}`
+        : 'unscoped (acts as the signed-in app user)');
+    if (readOnly)
+        parts.push('read-only');
+    return parts.join(', ');
+}
+async function rawGraphql(endpoint, token, query, variables) {
+    const res = await fetch(endpoint, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...(token ? { Authorization: `Bearer ${token}` } : {}),
+        },
+        body: JSON.stringify({ query, variables }),
+    });
+    return (await res.json());
+}
+async function createPrincipalInputFields(endpoint) {
+    const probe = await rawGraphql(endpoint, undefined, '{ __type(name: "CreatePrincipalInput") { inputFields { name } } }');
+    const type = probe.data?.__type;
+    return new Set((type?.inputFields ?? []).map((f) => f.name));
+}
+exports.createApiKeyTool = {
+    name: 'create_api_key',
+    label: 'Create API key',
+    description: 'Mint an API key for the project database, owned by a machine principal. Optionally scope it to specific entity rows and/or read-only. The human confirms the mint, completes MFA step-up in the app when required, and receives the key via .env + a one-time reveal — the plaintext key never appears in this conversation. Requires the user to be signed in to their app in the Preview.',
+    promptSnippet: 'create_api_key: mint an entity-scoped API key for the project database. Gated; the plaintext goes to .env + a one-time reveal, never into the chat — reference it as its env var.',
+    parameters: CreateApiKeyZod,
+    async execute(params, ctx) {
+        const keyName = params.key_name?.trim();
+        if (!keyName)
+            return fail('create_api_key requires "key_name".');
+        const resolved = await (0, context_1.resolveProjectContext)(ctx.cwd, { plane: 'data' });
+        if (!resolved.context)
+            return fail(resolved.reason);
+        const { databaseId, databaseName, apiEndpoint } = resolved.context;
+        if (!databaseName) {
+            return fail('Cannot resolve the app auth endpoint (DATABASE_NAME missing from .env). Re-provision the database, then retry.');
+        }
+        const host = (0, host_1.getHost)();
+        if (!host.deliverSecret) {
+            return fail('This host cannot deliver secrets (no .env write + reveal flow), so no key was minted. Create the key from a host that supports secret delivery.');
+        }
+        const token = await (0, context_1.resolveDataToken)(resolved.context);
+        if (!token.token) {
+            return fail(token.reason ?? 'Sign in to the app database to create an API key.', {
+                needsAuth: true,
+            });
+        }
+        const authEndpoint = (0, context_1.deriveSubdomainEndpoint)(apiEndpoint, `auth-${databaseName}`);
+        if (!authEndpoint)
+            return fail('Cannot derive the app auth endpoint.');
+        const scoped = Boolean(params.entity_ids?.length) || params.read_only === true;
+        try {
+            if (scoped) {
+                const fields = await createPrincipalInputFields(authEndpoint);
+                const missing = [
+                    ...(params.entity_ids?.length && !fields.has('entityIds') ? ['entityIds'] : []),
+                    ...(params.read_only === true && !fields.has('isReadOnly') ? ['isReadOnly'] : []),
+                ];
+                if (missing.length) {
+                    return fail(`This deployment does not support scoping a principal at create time (no ${missing.join(', ')} on createPrincipal). No key was minted. If an unscoped key that acts as the signed-in user is acceptable, ask for one explicitly.`);
+                }
+            }
+            const dbAuth = sdk_1.auth.createClient({
+                endpoint: authEndpoint,
+                headers: { Authorization: `Bearer ${token.token}` },
+            });
+            const principalName = params.principal_name?.trim() || keyName;
+            const existing = await dbAuth.principal
+                .findFirst({
+                where: { name: { equalTo: principalName } },
+                select: { id: true, name: true, userId: true, isReadOnly: true },
+            })
+                .unwrap();
+            // createApiKey (like createPrincipal.result) takes the principal's
+            // identity userId; principal_entity.principalId references the row id.
+            let principalId = existing.principal?.userId;
+            if (existing.principal && scoped) {
+                return fail(`Principal "${principalName}" already exists, and its scope cannot be verified against the requested one. No key was minted. Use a new principal_name for a scoped key, or mint an unscoped key on the existing principal explicitly.`);
+            }
+            if (existing.principal) {
+                const scopeRow = await dbAuth.principalEntity
+                    .findFirst({
+                    where: { principalId: { equalTo: existing.principal.id } },
+                    select: { id: true },
+                })
+                    .unwrap();
+                if (scopeRow.principalEntity || existing.principal?.isReadOnly) {
+                    return fail(`Principal "${principalName}" already exists with a narrower scope (entity-scoped or read-only), so a key minted under it would not act as the signed-in user. No key was minted. Use a new principal_name for an unscoped key.`);
+                }
+            }
+            if (!principalId) {
+                // The SDK's PrincipalModel.create sends a nested {principal} input, but
+                // the live CreatePrincipalInput is flat and its payload only exposes
+                // `result: UUID` — raw GraphQL is the only working surface.
+                const created = await rawGraphql(authEndpoint, token.token, 'mutation ($input: CreatePrincipalInput!) { createPrincipal(input: $input) { result } }', {
+                    input: {
+                        name: principalName,
+                        ...(params.entity_ids?.length && { entityIds: params.entity_ids }),
+                        ...(params.read_only !== undefined && { isReadOnly: params.read_only }),
+                    },
+                });
+                if (created.errors?.length) {
+                    return fail(`createPrincipal failed: ${created.errors.map((e) => e.message).join('; ')}`);
+                }
+                const payload = created.data?.createPrincipal;
+                principalId = payload?.result;
+                if (!principalId)
+                    return fail('createPrincipal returned no principal id.');
+            }
+            const mint = () => dbAuth.mutation
+                .createApiKey({
+                input: {
+                    principalId: principalId,
+                    keyName,
+                    ...(params.read_only && { accessLevel: 'read_only' }),
+                    expiresIn: { days: params.expires_in_days ?? 90 },
+                },
+            }, { select: { result: { select: { apiKey: true, keyId: true, expiresAt: true } } } })
+                .execute();
+            let minted = await mint();
+            if (!minted.ok && isStepUpError(minted.errors.map((e) => e.message))) {
+                if (!host.requestStepUp) {
+                    return fail('Creating this key requires MFA step-up, and this host has no step-up flow. Complete step-up in the app (verify your password), then retry.');
+                }
+                const verified = await host.requestStepUp({ databaseId, databaseName, apiEndpoint });
+                if (!verified)
+                    return fail('Step-up verification was not completed. No key was minted.');
+                minted = await mint();
+            }
+            if (!minted.ok) {
+                return fail(`createApiKey failed: ${minted.errors.map((e) => e.message).join('; ')}`);
+            }
+            const record = minted.data?.createApiKey?.result;
+            if (!record?.apiKey || !record.keyId)
+                return fail('createApiKey returned no key.');
+            const envVar = toEnvVar(keyName);
+            await host.deliverSecret({
+                databaseId,
+                cwd: ctx.cwd,
+                envVar,
+                plaintext: record.apiKey,
+                keyId: record.keyId,
+                expiresAt: record.expiresAt ?? undefined,
+            });
+            const scope = describeScope(params.entity_ids, params.read_only === true);
+            const message = `Created API key "${keyName}" (keyId: ${record.keyId}) for principal "${principalName}" — ${scope}. The key was written to .env as ${envVar} and revealed once to the user; it is not in this conversation. Reference it as ${envVar}.${record.expiresAt ? ` Expires ${record.expiresAt}.` : ''}`;
+            return {
+                content: [{ type: 'text', text: message }],
+                details: {
+                    success: true,
+                    message,
+                    keyId: record.keyId,
+                    envVar,
+                    expiresAt: record.expiresAt ?? undefined,
+                    principalId,
+                    principalName,
+                    scope,
+                },
+            };
+        }
+        catch (err) {
+            return fail(err instanceof Error ? err.message : 'Failed to create the API key.');
+        }
+    },
+};

package/tools/describe-schema.d.ts

@@ -0,0 +1,19 @@
+import { type HarnessTool } from '@agentic-kit/harness';
+import { z } from 'zod';
+declare const ParamZod: z.ZodObject<{}, z.core.$strip>;
+type SchemaField = {
+    name: string;
+    type: string;
+    isRequired: boolean;
+    defaultValue: string | null;
+};
+type SchemaTable = {
+    name: string;
+    fields: SchemaField[];
+    policies: string[];
+};
+export type DescribeSchemaDetails = {
+    tables: SchemaTable[];
+};
+export declare const describeSchemaTool: HarnessTool<typeof ParamZod, DescribeSchemaDetails>;
+export {};

package/tools/describe-schema.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeSchemaTool = void 0;
+const harness_1 = require("@agentic-kit/harness");
+const zod_1 = require("zod");
+const context_1 = require("../context");
+const ParamZod = zod_1.z.object({});
+function toDefaultValueString(value) {
+    if (value == null)
+        return null;
+    if (typeof value === 'string')
+        return value;
+    return JSON.stringify(value);
+}
+function formatText(details) {
+    const lines = [];
+    if (details.tables.length === 0) {
+        lines.push('No application tables yet.');
+    }
+    else {
+        lines.push(`Tables (${details.tables.length}):`);
+        for (const table of details.tables) {
+            lines.push(`  ${table.name}`);
+            for (const field of table.fields) {
+                const req = field.isRequired ? ' required' : '';
+                const def = field.defaultValue != null ? ` default=${field.defaultValue}` : '';
+                lines.push(`    - ${field.name}: ${field.type}${req}${def}`);
+            }
+            if (table.policies.length > 0) {
+                lines.push(`    policies: ${table.policies.join(', ')}`);
+            }
+        }
+    }
+    return lines.join('\n');
+}
+exports.describeSchemaTool = {
+    name: 'describe_schema',
+    label: 'Describe schema',
+    description: 'Inspect the current Constructive database schema for this project: application tables with their fields (name, type, required, default). Read-only.',
+    promptSnippet: 'describe_schema: list the project database tables and their fields. Read-only — call before modifying schema.',
+    parameters: ParamZod,
+    async execute(_params, ctx) {
+        const resolved = await (0, context_1.resolveProjectContext)(ctx.cwd);
+        if (!resolved.context) {
+            return {
+                content: [{ type: 'text', text: resolved.reason }],
+                details: { tables: [] },
+            };
+        }
+        const { api, databaseId } = resolved.context;
+        const tablesResult = await api.table
+            .findMany({
+            select: { id: true, name: true, category: true },
+            where: {
+                databaseId: { equalTo: databaseId },
+                or: [{ category: { equalTo: 'APP' } }, { name: { equalTo: 'users' } }],
+            },
+            orderBy: ['NAME_ASC'],
+        })
+            .execute();
+        if (!tablesResult.ok) {
+            const message = tablesResult.errors.map((e) => e.message).join('; ');
+            return {
+                content: [{ type: 'text', text: `Failed to read schema: ${message}` }],
+                details: { tables: [] },
+            };
+        }
+        const tableNodes = tablesResult.data.tables?.nodes ?? [];
+        const tableIds = tableNodes.map((t) => t.id);
+        const fieldsByTable = new Map();
+        const policiesByTable = new Map();
+        if (tableIds.length > 0) {
+            const [fieldsResult, policiesResult] = await Promise.all([
+                api.field
+                    .findMany({
+                    select: {
+                        name: true,
+                        type: true,
+                        isRequired: true,
+                        defaultValue: true,
+                        tableId: true,
+                    },
+                    where: { tableId: { in: tableIds } },
+                })
+                    .execute(),
+                api.policy
+                    .findMany({
+                    select: { tableId: true, policyType: true },
+                    where: { tableId: { in: tableIds } },
+                })
+                    .execute(),
+            ]);
+            if (!fieldsResult.ok) {
+                const message = fieldsResult.errors.map((e) => e.message).join('; ');
+                return {
+                    content: [{ type: 'text', text: `Failed to read fields: ${message}` }],
+                    details: { tables: [] },
+                };
+            }
+            for (const field of fieldsResult.data.fields?.nodes ?? []) {
+                const list = fieldsByTable.get(field.tableId) ?? [];
+                list.push({
+                    name: field.name,
+                    type: (0, harness_1.fieldTypeToTypeName)(field.type),
+                    isRequired: Boolean(field.isRequired),
+                    defaultValue: toDefaultValueString(field.defaultValue),
+                });
+                fieldsByTable.set(field.tableId, list);
+            }
+            // One policy spans CRUD as several rows; collapse to distinct types per table.
+            if (policiesResult.ok) {
+                for (const policy of policiesResult.data.policies?.nodes ?? []) {
+                    if ((0, harness_1.isInternalPolicy)(policy.policyType))
+                        continue;
+                    const list = policiesByTable.get(policy.tableId) ?? [];
+                    if (!list.includes(policy.policyType))
+                        list.push(policy.policyType);
+                    policiesByTable.set(policy.tableId, list);
+                }
+            }
+        }
+        const tables = tableNodes.map((table) => ({
+            name: table.name,
+            fields: fieldsByTable.get(table.id) ?? [],
+            policies: policiesByTable.get(table.id) ?? [],
+        }));
+        const details = { tables };
+        return {
+            content: [{ type: 'text', text: formatText(details) }],
+            details,
+        };
+    },
+};

package/tools/manage-entity-types.d.ts

@@ -0,0 +1,40 @@
+import type { HarnessTool } from '@agentic-kit/harness';
+import { z } from 'zod';
+declare const ManageEntityTypesZod: z.ZodObject<{
+    action: z.ZodEnum<{
+        create: "create";
+        delete: "delete";
+        list: "list";
+    }>;
+    name: z.ZodOptional<z.ZodString>;
+    entity_type_id: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    prefix: z.ZodOptional<z.ZodString>;
+    parent_entity: z.ZodOptional<z.ZodString>;
+    is_visible: z.ZodOptional<z.ZodBoolean>;
+    has_invites: z.ZodOptional<z.ZodBoolean>;
+    has_profiles: z.ZodOptional<z.ZodBoolean>;
+    has_limits: z.ZodOptional<z.ZodBoolean>;
+    has_levels: z.ZodOptional<z.ZodBoolean>;
+    has_storage: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type EntityTypeSummary = {
+    id: string;
+    name: string | null;
+    description: string | null;
+    prefix: string | null;
+    parentEntity: string | null;
+    isVisible: boolean | null;
+    entityTableName: string | null;
+    installedModules: string[] | null;
+};
+export type ManageEntityTypesDetails = {
+    success: boolean;
+    message: string;
+    entityTypes?: EntityTypeSummary[];
+};
+export declare function defaultPrefix(name: string): string;
+type Params = z.infer<typeof ManageEntityTypesZod>;
+export declare function validateManageEntityTypes(params: Params): string | null;
+export declare const manageEntityTypesTool: HarnessTool<typeof ManageEntityTypesZod, ManageEntityTypesDetails>;
+export {};

package/tools/manage-entity-types.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manageEntityTypesTool = void 0;
+exports.defaultPrefix = defaultPrefix;
+exports.validateManageEntityTypes = validateManageEntityTypes;
+const zod_1 = require("zod");
+const context_1 = require("../context");
+const ManageEntityTypesZod = zod_1.z.object({
+    action: zod_1.z
+        .enum(['list', 'create', 'delete'])
+        .describe('list: show the entity types provisioned in this database. create: provision a new entity type (creates its entity table + membership wiring). delete: remove the provision registration. Registrations are immutable once provisioned — there is no update; to change one, delete it and create a new one.'),
+    name: zod_1.z.string().describe('Entity type name. Required for create.').optional(),
+    entity_type_id: zod_1.z
+        .string()
+        .describe('Entity type provision id. Required for delete — get it from action "list".')
+        .optional(),
+    description: zod_1.z
+        .string()
+        .describe('Human-readable description of the entity type. Create only.')
+        .optional(),
+    prefix: zod_1.z
+        .string()
+        .describe('Table-name prefix for the provisioned tables (e.g. "org" → org table, org_memberships). Create only; defaults to the snake_case of name.')
+        .optional(),
+    parent_entity: zod_1.z
+        .string()
+        .describe('Parent entity table name, for hierarchical types (e.g. a "team" under an "org"). Create only; the backend defaults it to the root entity (org).')
+        .optional(),
+    is_visible: zod_1.z
+        .boolean()
+        .describe('Whether the type shows up in end-user entity listings. Create only.')
+        .optional(),
+    has_invites: zod_1.z
+        .boolean()
+        .describe('Provision an invites module ({prefix}_invites + claimed invites). Create only.')
+        .optional(),
+    has_profiles: zod_1.z
+        .boolean()
+        .describe('Provision a profiles table for members of this type. Create only.')
+        .optional(),
+    has_limits: zod_1.z
+        .boolean()
+        .describe('Provision usage-limits tracking for this type. Create only.')
+        .optional(),
+    has_levels: zod_1.z
+        .boolean()
+        .describe('Provision levels/achievements support for this type. Create only.')
+        .optional(),
+    has_storage: zod_1.z
+        .boolean()
+        .describe('Provision a storage module (files + buckets tables) for this type. Create only.')
+        .optional(),
+});
+const SUMMARY_SELECT = {
+    id: true,
+    name: true,
+    description: true,
+    prefix: true,
+    parentEntity: true,
+    isVisible: true,
+    outEntityTableName: true,
+    outInstalledModules: true,
+};
+function toSummary(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        description: row.description,
+        prefix: row.prefix,
+        parentEntity: row.parentEntity,
+        isVisible: row.isVisible,
+        entityTableName: row.outEntityTableName,
+        installedModules: row.outInstalledModules,
+    };
+}
+function formatSummary(s) {
+    const parts = [
+        `- ${s.name ?? '?'} (id: ${s.id})`,
+        `  table: ${s.entityTableName ?? '?'}, prefix: ${s.prefix ?? '?'}`,
+    ];
+    if (s.parentEntity)
+        parts.push(`  parent: ${s.parentEntity}`);
+    if (s.description)
+        parts.push(`  description: ${s.description}`);
+    if (s.installedModules?.length)
+        parts.push(`  modules: ${s.installedModules.join(', ')}`);
+    return parts.join('\n');
+}
+function defaultPrefix(name) {
+    return name
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '');
+}
+function validateManageEntityTypes(params) {
+    switch (params.action) {
+        case 'create':
+            if (!params.name?.trim())
+                return 'create requires "name".';
+            if (params.entity_type_id)
+                return 'create does not take "entity_type_id" — it mints a new one.';
+            return null;
+        case 'delete':
+            if (!params.entity_type_id)
+                return 'delete requires "entity_type_id" (use action "list" to find it).';
+            return null;
+        default:
+            return null;
+    }
+}
+exports.manageEntityTypesTool = {
+    name: 'manage_entity_types',
+    label: 'Manage entity types',
+    description: 'List, create, or delete entity types in the project database. An entity type (e.g. organization, team, project) provisions its own entity table plus membership wiring, and is the unit that API keys can be scoped to. Registrations are immutable once provisioned — to change one, delete it and create a new one. Deleting removes the registration; the already-provisioned entity table stays in the API schema.',
+    promptSnippet: 'manage_entity_types: list/create/delete entity types (orgs, teams, …) in the project database. list is free; create/delete are gated.',
+    parameters: ManageEntityTypesZod,
+    async execute(params, ctx) {
+        const resolved = await (0, context_1.resolveProjectContext)(ctx.cwd);
+        if (!resolved.context) {
+            return {
+                content: [{ type: 'text', text: resolved.reason }],
+                details: { success: false, message: resolved.reason },
+            };
+        }
+        const invalid = validateManageEntityTypes(params);
+        if (invalid) {
+            return {
+                content: [{ type: 'text', text: invalid }],
+                details: { success: false, message: invalid },
+            };
+        }
+        const { modules, databaseId } = resolved.context;
+        try {
+            switch (params.action) {
+                case 'list': {
+                    const result = await modules.entityTypeProvision
+                        .findMany({
+                        where: { databaseId: { equalTo: databaseId } },
+                        select: SUMMARY_SELECT,
+                    })
+                        .unwrap();
+                    const entityTypes = result.entityTypeProvisions.nodes.map((row) => toSummary(row));
+                    const message = entityTypes.length === 0
+                        ? 'No entity types are provisioned in this database yet.'
+                        : `${entityTypes.length} entity type${entityTypes.length === 1 ? '' : 's'}:\n${entityTypes.map(formatSummary).join('\n')}`;
+                    return {
+                        content: [{ type: 'text', text: message }],
+                        details: { success: true, message, entityTypes },
+                    };
+                }
+                case 'create': {
+                    const name = params.name.trim();
+                    const result = await modules.entityTypeProvision
+                        .create({
+                        data: {
+                            databaseId,
+                            name,
+                            prefix: params.prefix?.trim() || defaultPrefix(name),
+                            ...(params.description !== undefined && { description: params.description }),
+                            ...(params.parent_entity !== undefined && { parentEntity: params.parent_entity }),
+                            ...(params.is_visible !== undefined && { isVisible: params.is_visible }),
+                            ...(params.has_invites !== undefined && { hasInvites: params.has_invites }),
+                            ...(params.has_profiles !== undefined && { hasProfiles: params.has_profiles }),
+                            ...(params.has_limits !== undefined && { hasLimits: params.has_limits }),
+                            ...(params.has_levels !== undefined && { hasLevels: params.has_levels }),
+                            ...(params.has_storage && {
+                                storage: [{}],
+                            }),
+                        },
+                        select: SUMMARY_SELECT,
+                    })
+                        .unwrap();
+                    const row = result.createEntityTypeProvision?.entityTypeProvision;
+                    if (!row)
+                        throw new Error('createEntityTypeProvision returned no row.');
+                    const summary = toSummary(row);
+                    const message = `Created entity type "${summary.name}" (id: ${summary.id}) — entity table "${summary.entityTableName}"${summary.installedModules?.length ? `, modules: ${summary.installedModules.join(', ')}` : ''}. Run run_codegen to pull it into the typed SDK.`;
+                    return {
+                        content: [{ type: 'text', text: message }],
+                        details: { success: true, message, entityTypes: [summary] },
+                    };
+                }
+                case 'delete': {
+                    const result = await modules.entityTypeProvision
+                        .delete({
+                        where: { id: params.entity_type_id },
+                        select: { id: true, name: true, outEntityTableName: true },
+                    })
+                        .unwrap();
+                    const row = result.deleteEntityTypeProvision?.entityTypeProvision;
+                    const name = row?.name ?? params.entity_type_id;
+                    const message = `Deleted entity type registration "${name}". Note: the provisioned entity table${row?.outEntityTableName ? ` "${row.outEntityTableName}"` : ''} remains in the API schema with its data.`;
+                    return {
+                        content: [{ type: 'text', text: message }],
+                        details: { success: true, message },
+                    };
+                }
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Failed to manage entity types';
+            return { content: [{ type: 'text', text: message }], details: { success: false, message } };
+        }
+    },
+};

package/tools/mutations.d.ts

@@ -0,0 +1,35 @@
+import { type HarnessTool } from '@agentic-kit/harness';
+import { z } from 'zod';
+export type MutationDetails = {
+    success: boolean;
+    message: string;
+};
+declare const DeleteTableZod: z.ZodObject<{
+    table_name: z.ZodString;
+}, z.core.$strip>;
+export declare const deleteTableTool: HarnessTool<typeof DeleteTableZod, MutationDetails>;
+declare const CreateFieldZod: z.ZodObject<{
+    table_name: z.ZodString;
+    field_name: z.ZodString;
+    type: z.ZodString;
+    is_required: z.ZodOptional<z.ZodBoolean>;
+    default_value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+    is_unique: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const createFieldTool: HarnessTool<typeof CreateFieldZod, MutationDetails>;
+declare const UpdateFieldZod: z.ZodObject<{
+    table_name: z.ZodString;
+    field_name: z.ZodString;
+    new_name: z.ZodOptional<z.ZodString>;
+    new_type: z.ZodOptional<z.ZodString>;
+    is_required: z.ZodOptional<z.ZodBoolean>;
+    default_value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+    is_unique: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const updateFieldTool: HarnessTool<typeof UpdateFieldZod, MutationDetails>;
+declare const DeleteFieldZod: z.ZodObject<{
+    table_name: z.ZodString;
+    field_name: z.ZodString;
+}, z.core.$strip>;
+export declare const deleteFieldTool: HarnessTool<typeof DeleteFieldZod, MutationDetails>;
+export {};