@agentic-kit/pi 0.17.1 → 0.18.0

package/esm/tools/add-relation-schema.d.ts

@@ -1,30 +0,0 @@
-import type { BlueprintDefinition } from '@agentic-kit/harness';
-import { z } from 'zod';
-export declare const DeleteAction: z.ZodEnum<{
-    c: "c";
-    r: "r";
-    n: "n";
-    a: "a";
-    d: "d";
-}>;
-export declare const AddRelationZod: z.ZodObject<{
-    relation_type: z.ZodOptional<z.ZodEnum<{
-        belongs_to: "belongs_to";
-        many_to_many: "many_to_many";
-    }>>;
-    source_table: z.ZodString;
-    target_table: z.ZodString;
-    field_name: z.ZodOptional<z.ZodString>;
-    junction_table_name: z.ZodOptional<z.ZodString>;
-    delete_action: z.ZodOptional<z.ZodEnum<{
-        c: "c";
-        r: "r";
-        n: "n";
-        a: "a";
-        d: "d";
-    }>>;
-    is_required: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare const AddRelationSchema: import("typebox/type").TSchema;
-export type AddRelationParams = z.infer<typeof AddRelationZod>;
-export declare function buildRelation(params: AddRelationParams): BlueprintDefinition['relations'];

package/esm/tools/add-relation-schema.js

@@ -1,58 +0,0 @@
-import { z } from 'zod';
-import { toolSchema } from '../tool-schema';
-// delete_action is intentionally always sent: the backend REJECTS a
-// RelationBelongsTo whose delete_action is absent ("PROVISION_RELATION:
-// delete_action is required"). We default it to 'a' (NO ACTION) so the model
-// never has to supply it.
-export const DeleteAction = z
-    .enum(['c', 'r', 'n', 'a', 'd'])
-    .describe('FK delete action: c=CASCADE, r=RESTRICT, n=SET NULL, a=NO ACTION (default), d=SET DEFAULT');
-export const AddRelationZod = z.object({
-    relation_type: z
-        .enum(['belongs_to', 'many_to_many'])
-        .describe('belongs_to adds an FK column on the source table; many_to_many adds a junction table. Defaults to belongs_to.')
-        .optional(),
-    source_table: z.string().describe('Existing source table name (snake_case).'),
-    target_table: z.string().describe('Existing target table name (snake_case).'),
-    field_name: z
-        .string()
-        .describe('belongs_to only: FK column name to add on the source table, e.g. "author_id".')
-        .optional(),
-    junction_table_name: z
-        .string()
-        .describe('many_to_many only: name of the junction table to create, e.g. "post_tags".')
-        .optional(),
-    delete_action: DeleteAction.optional(),
-    is_required: z
-        .boolean()
-        .describe('belongs_to only: make the FK NOT NULL. Defaults to false — a NOT NULL FK fails if the source table already has rows.')
-        .optional(),
-});
-export const AddRelationSchema = toolSchema(AddRelationZod);
-// Build a relation-only blueprint definition (no tables): the spike proved
-// constructBlueprint applies relations to PRE-EXISTING tables without recreating
-// them, as long as delete_action is supplied.
-export function buildRelation(params) {
-    const deleteAction = params.delete_action ?? 'a';
-    if ((params.relation_type ?? 'belongs_to') === 'many_to_many') {
-        return [
-            {
-                $type: 'RelationManyToMany',
-                source_table: params.source_table,
-                target_table: params.target_table,
-                junction_table_name: params.junction_table_name,
-                delete_action: deleteAction,
-            },
-        ];
-    }
-    return [
-        {
-            $type: 'RelationBelongsTo',
-            source_table: params.source_table,
-            target_table: params.target_table,
-            field_name: params.field_name,
-            delete_action: deleteAction,
-            is_required: params.is_required ?? false,
-        },
-    ];
-}

package/esm/tools/add-relation.d.ts

@@ -1,10 +0,0 @@
-import type { ToolDefinition } from '@earendil-works/pi-coding-agent';
-import { AddRelationSchema } from './add-relation-schema';
-export type AddRelationDetails = {
-    success: boolean;
-    message: string;
-    sourceTable?: string;
-    targetTable?: string;
-    fieldName?: string;
-};
-export declare const addRelationTool: ToolDefinition<typeof AddRelationSchema, AddRelationDetails>;

package/esm/tools/add-relation.js

@@ -1,91 +0,0 @@
-import { expandBlueprintDefaults } from '@agentic-kit/harness';
-import { resolveProjectContext } from '../context';
-import { resolveSchema, resolveTable } from '../schema-resolve';
-import { AddRelationSchema, buildRelation } from './add-relation-schema';
-function fail(message) {
-    return { content: [{ type: 'text', text: message }], details: { success: false, message } };
-}
-export const addRelationTool = {
-    name: 'add_relation',
-    label: 'Add relation',
-    description: 'Add a relation between two EXISTING tables without recreating them: belongs_to adds a foreign-key column on the source table; many_to_many creates a junction table. Use this for relations discovered after the tables were provisioned. For brand-new related tables, prefer a single provision_blueprint call.',
-    promptSnippet: 'add_relation: link two existing tables (belongs_to FK column, or many_to_many junction). Gated.',
-    parameters: AddRelationSchema,
-    async execute(_id, params, _signal, _onUpdate, ctx) {
-        const type = params.relation_type ?? 'belongs_to';
-        if (type === 'belongs_to' && !params.field_name) {
-            return fail('field_name is required for a belongs_to relation (the FK column name on the source table).');
-        }
-        if (type === 'many_to_many' && !params.junction_table_name) {
-            return fail('junction_table_name is required for a many_to_many relation.');
-        }
-        const resolved = await resolveProjectContext(ctx.cwd);
-        if (!resolved.context)
-            return fail(resolved.reason);
-        const { modules, databaseId, schemaId, ownerId } = resolved.context;
-        if (!ownerId)
-            return fail('Not authenticated (missing OWNER_ID in .env).');
-        // Validate both tables exist before constructing — a clearer error than the
-        // backend's, and avoids a no-op blueprint.
-        let schema;
-        try {
-            schema = await resolveSchema(resolved.context);
-            resolveTable(schema, params.source_table);
-            resolveTable(schema, params.target_table);
-        }
-        catch (err) {
-            return fail(err instanceof Error ? err.message : 'Failed to resolve schema.');
-        }
-        const definition = expandBlueprintDefaults({ tables: [], relations: buildRelation(params) });
-        const uniqueName = `add_relation_${Date.now()}`;
-        try {
-            const created = await modules.blueprint
-                .create({
-                data: {
-                    ownerId,
-                    databaseId,
-                    name: uniqueName,
-                    displayName: `${params.source_table} → ${params.target_table}`,
-                    description: `Add ${type} relation`,
-                    definition,
-                },
-                select: { id: true },
-            })
-                .unwrap();
-            const blueprintId = created.createBlueprint?.blueprint?.id;
-            if (!blueprintId)
-                throw new Error('Failed to create relation blueprint');
-            const constructResult = await modules.mutation
-                .constructBlueprint({ input: { blueprintId, schemaId } }, { select: { result: true } })
-                .unwrap();
-            if (!constructResult.constructBlueprint?.result) {
-                const constructions = await modules.blueprintConstruction
-                    .findMany({
-                    where: { blueprintId: { equalTo: blueprintId } },
-                    orderBy: ['ID_DESC'],
-                    first: 1,
-                    select: { status: true, errorDetails: true },
-                })
-                    .unwrap();
-                const error = constructions?.blueprintConstructions?.nodes?.[0]?.errorDetails ?? 'Unknown error';
-                return fail(`Failed to add relation: ${typeof error === 'string' ? error : JSON.stringify(error)}`);
-            }
-        }
-        catch (err) {
-            return fail(`Failed to add relation: ${err instanceof Error ? err.message : String(err)}`);
-        }
-        const message = type === 'many_to_many'
-            ? `Created junction table "${params.junction_table_name}" linking ${params.source_table} ↔ ${params.target_table}.`
-            : `Added FK "${params.field_name}" on ${params.source_table} → ${params.target_table}.`;
-        return {
-            content: [{ type: 'text', text: message }],
-            details: {
-                success: true,
-                message,
-                sourceTable: params.source_table,
-                targetTable: params.target_table,
-                fieldName: params.field_name,
-            },
-        };
-    },
-};

package/esm/tools/create-api-key.d.ts

@@ -1,18 +0,0 @@
-import type { ToolDefinition } from '@earendil-works/pi-coding-agent';
-declare const CreateApiKeySchema: import("typebox/type").TSchema;
-export type CreateApiKeyDetails = {
-    success: boolean;
-    message: string;
-    keyId?: string;
-    envVar?: string;
-    expiresAt?: string;
-    principalId?: string;
-    principalName?: string;
-    scope?: string;
-    needsAuth?: boolean;
-};
-export declare function toEnvVar(keyName: string): string;
-export declare function isStepUpError(messages: string[]): boolean;
-export declare function describeScope(entityIds: string[] | undefined, readOnly: boolean): string;
-export declare const createApiKeyTool: ToolDefinition<typeof CreateApiKeySchema, CreateApiKeyDetails>;
-export {};

package/esm/tools/create-api-key.js

@@ -1,216 +0,0 @@
-import { auth } from '@constructive-io/sdk';
-import { z } from 'zod';
-import { deriveSubdomainEndpoint, resolveDataToken, resolveProjectContext } from '../context';
-import { getHost } from '../host';
-import { toolSchema } from '../tool-schema';
-const CreateApiKeyZod = z.object({
-    key_name: 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: 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: z
-        .array(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: z
-        .boolean()
-        .describe('Restrict the principal and key to read-only operations.')
-        .optional(),
-    expires_in_days: z
-        .number()
-        .int()
-        .positive()
-        .describe('Key lifetime in days. Default 90.')
-        .optional(),
-});
-const CreateApiKeySchema = toolSchema(CreateApiKeyZod);
-function fail(message, extra) {
-    return {
-        content: [{ type: 'text', text: message }],
-        details: { success: false, message, ...extra },
-    };
-}
-export function toEnvVar(keyName) {
-    const base = keyName
-        .trim()
-        .toUpperCase()
-        .replace(/[^A-Z0-9]+/g, '_')
-        .replace(/^_+|_+$/g, '');
-    return base.endsWith('_API_KEY') ? base : `${base}_API_KEY`;
-}
-export function isStepUpError(messages) {
-    return messages.some((m) => /step[\s_-]?up/i.test(m));
-}
-export 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));
-}
-export const 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: CreateApiKeySchema,
-    async execute(_id, params, _signal, _onUpdate, ctx) {
-        const keyName = params.key_name?.trim();
-        if (!keyName)
-            return fail('create_api_key requires "key_name".');
-        const resolved = await 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 = 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 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 = 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 = 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/esm/tools/describe-schema.d.ts

@@ -1,18 +0,0 @@
-import type { ToolDefinition } from '@earendil-works/pi-coding-agent';
-declare const ParamSchema: import("typebox/type").TSchema;
-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: ToolDefinition<typeof ParamSchema, DescribeSchemaDetails>;
-export {};

package/esm/tools/describe-schema.js

@@ -1,132 +0,0 @@
-import { fieldTypeToTypeName, isInternalPolicy } from '@agentic-kit/harness';
-import { z } from 'zod';
-import { resolveProjectContext } from '../context';
-import { toolSchema } from '../tool-schema';
-const ParamZod = z.object({});
-const ParamSchema = toolSchema(ParamZod);
-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');
-}
-export const 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: ParamSchema,
-    async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
-        const resolved = await 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: 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 (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/esm/tools/manage-entity-types.d.ts

@@ -1,41 +0,0 @@
-import type { ToolDefinition } from '@earendil-works/pi-coding-agent';
-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>;
-declare const ManageEntityTypesSchema: import("typebox/type").TSchema;
-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: ToolDefinition<typeof ManageEntityTypesSchema, ManageEntityTypesDetails>;
-export {};