@agentic-kit/pi 0.17.0 → 0.18.0

package/tools/add-records.js

@@ -1,127 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addRecordsTool = void 0;
-const generators_1 = require("@constructive-io/graphql-query/generators");
-const sdk_1 = require("@constructive-io/sdk");
-const zod_1 = require("zod");
-const context_1 = require("../context");
-const meta_1 = require("../records/meta");
-const tool_schema_1 = require("../tool-schema");
-function fail(message) {
-    return { content: [{ type: 'text', text: message }], details: { success: false, message } };
-}
-function needsAuth(message) {
-    return {
-        content: [{ type: 'text', text: message }],
-        details: { success: false, message, needsAuth: true },
-    };
-}
-// Mirror @constructive-io/data's prepareCreateInput (create semantics): drop
-// undefined/null/empty-string so server defaults apply; keep false/0/[]/objects.
-function stripForCreate(record) {
-    const out = {};
-    for (const [key, value] of Object.entries(record)) {
-        if (value === undefined || value === null || value === '')
-            continue;
-        out[key] = value;
-    }
-    return out;
-}
-const AddRecordsZod = zod_1.z.object({
-    table_name: zod_1.z
-        .string()
-        .describe('Name of the table to insert rows into (snake_case, singular or plural).'),
-    records: zod_1.z
-        .array(zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()))
-        .describe('Rows to insert. Each is an object of column → value (camelCase or snake_case column names).'),
-});
-const AddRecordsSchema = (0, tool_schema_1.toolSchema)(AddRecordsZod);
-exports.addRecordsTool = {
-    name: 'add_records',
-    label: 'Add records',
-    description: "Insert one or more rows into a table in the project's app database.",
-    promptSnippet: 'add_records: insert rows into an existing table. Gated.',
-    parameters: AddRecordsSchema,
-    async execute(_id, params, _signal, _onUpdate, ctx) {
-        const resolved = await (0, context_1.resolveProjectContext)(ctx.cwd);
-        if (!resolved.context)
-            return fail(resolved.reason);
-        const { dataEndpoint } = resolved.context;
-        if (!dataEndpoint) {
-            return fail('Cannot resolve the app data endpoint (DATABASE_NAME missing from .env). Re-provision the database, then retry.');
-        }
-        if (params.records.length === 0)
-            return fail('No records provided.');
-        const token = await (0, context_1.resolveDataToken)(resolved.context);
-        if (!token.token)
-            return needsAuth(token.reason ?? 'Sign in to the database to insert records.');
-        const adapter = new sdk_1.objects.FetchAdapter(dataEndpoint, {
-            Authorization: `Bearer ${token.token}`,
-        });
-        let tables;
-        try {
-            const meta = await adapter.execute(meta_1.META_QUERY);
-            if (!meta.ok) {
-                return fail(`Failed to read schema from the app database: ${meta.errors.map((e) => e.message).join('; ')}`);
-            }
-            tables = (meta.data._meta?.tables ?? []).filter((t) => Boolean(t));
-        }
-        catch (err) {
-            return fail(err instanceof Error ? err.message : 'Failed to query the app database schema.');
-        }
-        const rawTable = (0, meta_1.findMetaTable)(tables, params.table_name);
-        if (!rawTable) {
-            return fail(`Table "${params.table_name}" was not found in the app database.`);
-        }
-        const table = (0, meta_1.cleanTable)(rawTable);
-        const allTables = tables.map(meta_1.cleanTable);
-        const mutation = (0, generators_1.buildPostGraphileCreate)(table, allTables).toString();
-        const mutationName = (0, generators_1.toCreateMutationName)(table.name, table);
-        const singularName = (0, generators_1.toCamelCaseSingular)(table.name, table);
-        // Constructive app tables scope rows by entityId (the owning user's id). The
-        // create input requires it, but callers won't know it — backfill it with the
-        // signed-in user's id from the Preview session when the table has the column
-        // and the record omits it.
-        const hasEntityId = table.fields.some((f) => f.name === 'entityId');
-        const created = [];
-        const errors = [];
-        for (const record of params.records) {
-            const prepared = hasEntityId && token.userId && record.entityId == null && record.entity_id == null
-                ? { ...record, entityId: token.userId }
-                : record;
-            const variables = { input: { [singularName]: stripForCreate(prepared) } };
-            try {
-                const result = await adapter.execute(mutation, variables);
-                if (!result.ok) {
-                    errors.push(result.errors.map((e) => e.message).join('; '));
-                    continue;
-                }
-                const payload = result.data[mutationName];
-                const row = payload?.[singularName] ?? {};
-                created.push(row);
-            }
-            catch (err) {
-                errors.push(err instanceof Error ? err.message : 'Unknown error');
-            }
-        }
-        if (created.length === 0) {
-            return fail(`Failed to insert into "${params.table_name}": ${errors.join('; ') || 'unknown error'}`);
-        }
-        const columns = table.fields.map((f) => f.name);
-        const message = errors.length > 0
-            ? `Inserted ${created.length} of ${params.records.length} row(s) into ${params.table_name} (${errors.length} failed).`
-            : `Inserted ${created.length} row(s) into ${params.table_name}.`;
-        return {
-            content: [{ type: 'text', text: message }],
-            details: {
-                success: true,
-                message,
-                tableName: rawTable.name,
-                columns,
-                rows: created,
-                createdCount: created.length,
-                asOf: new Date().toISOString(),
-            },
-        };
-    },
-};

package/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/tools/add-relation-schema.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AddRelationSchema = exports.AddRelationZod = exports.DeleteAction = void 0;
-exports.buildRelation = buildRelation;
-const zod_1 = require("zod");
-const tool_schema_1 = require("../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.
-exports.DeleteAction = zod_1.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');
-exports.AddRelationZod = zod_1.z.object({
-    relation_type: zod_1.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: zod_1.z.string().describe('Existing source table name (snake_case).'),
-    target_table: zod_1.z.string().describe('Existing target table name (snake_case).'),
-    field_name: zod_1.z
-        .string()
-        .describe('belongs_to only: FK column name to add on the source table, e.g. "author_id".')
-        .optional(),
-    junction_table_name: zod_1.z
-        .string()
-        .describe('many_to_many only: name of the junction table to create, e.g. "post_tags".')
-        .optional(),
-    delete_action: exports.DeleteAction.optional(),
-    is_required: zod_1.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(),
-});
-exports.AddRelationSchema = (0, tool_schema_1.toolSchema)(exports.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.
-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/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/tools/add-relation.js

@@ -1,94 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addRelationTool = void 0;
-const harness_1 = require("@agentic-kit/harness");
-const context_1 = require("../context");
-const schema_resolve_1 = require("../schema-resolve");
-const add_relation_schema_1 = require("./add-relation-schema");
-function fail(message) {
-    return { content: [{ type: 'text', text: message }], details: { success: false, message } };
-}
-exports.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: add_relation_schema_1.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 (0, context_1.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 (0, schema_resolve_1.resolveSchema)(resolved.context);
-            (0, schema_resolve_1.resolveTable)(schema, params.source_table);
-            (0, schema_resolve_1.resolveTable)(schema, params.target_table);
-        }
-        catch (err) {
-            return fail(err instanceof Error ? err.message : 'Failed to resolve schema.');
-        }
-        const definition = (0, harness_1.expandBlueprintDefaults)({ tables: [], relations: (0, add_relation_schema_1.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/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/tools/create-api-key.js

@@ -1,222 +0,0 @@
-"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 tool_schema_1 = require("../tool-schema");
-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(),
-});
-const CreateApiKeySchema = (0, tool_schema_1.toolSchema)(CreateApiKeyZod);
-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: 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 (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

@@ -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 {};