@inkeep/agents-core 0.41.2 → 0.42.0

package/dist/utils/third-party-mcp-servers/composio-client.js

@@ -7,7 +7,7 @@ import { Composio } from "@composio/core";
 * Composio MCP Server Client
 * Handles all Composio-specific operations for MCP server integration
 */
-const logger = getLogger("composio-client");
+const logger$1 = getLogger("composio-client");
 const TOOLKIT_TO_CATEGORY = {
 	github: "development",
 	gitlab: "development",
@@ -88,14 +88,14 @@ function extractComposioServerId(mcpUrl) {
 async function deleteComposioConnectedAccount(accountId) {
 	const composioInstance = getComposioInstance();
 	if (!composioInstance) {
-		logger.info({}, "Composio not configured, skipping account deletion");
+		logger$1.info({}, "Composio not configured, skipping account deletion");
 		return false;
 	}
 	try {
 		await composioInstance.connectedAccounts.delete(accountId);
 		return true;
 	} catch (error) {
-		logger.warn({ error }, "Error deleting Composio connected account");
+		logger$1.warn({ error }, "Error deleting Composio connected account");
 		return false;
 	}
 }
@@ -106,7 +106,7 @@ async function deleteComposioConnectedAccount(accountId) {
 async function fetchComposioConnectedAccounts(derivedUserId) {
 	const composioInstance = getComposioInstance();
 	if (!composioInstance) {
-		logger.info({}, "Composio not configured, skipping connected accounts fetch");
+		logger$1.info({}, "Composio not configured, skipping connected accounts fetch");
 		return null;
 	}
 	try {
@@ -115,7 +115,7 @@ async function fetchComposioConnectedAccounts(derivedUserId) {
 			statuses: ["ACTIVE", "INITIATED"]
 		});
 	} catch (error) {
-		logger.error({ error }, "Error fetching Composio connected accounts");
+		logger$1.error({ error }, "Error fetching Composio connected accounts");
 		return null;
 	}
 }
@@ -127,18 +127,18 @@ async function fetchComposioConnectedAccounts(derivedUserId) {
 */
 async function isComposioMCPServerAuthenticated(tenantId, projectId, mcpServerUrl, credentialScope = "project", userId) {
 	if (!process.env.COMPOSIO_API_KEY) {
-		logger.info({}, "Composio API key not configured, skipping auth check");
+		logger$1.info({}, "Composio API key not configured, skipping auth check");
 		return false;
 	}
 	const serverId = extractComposioServerId(mcpServerUrl);
 	if (!serverId) {
-		logger.info({ mcpServerUrl }, "Could not extract Composio server ID from URL");
+		logger$1.info({ mcpServerUrl }, "Could not extract Composio server ID from URL");
 		return false;
 	}
 	const composioUserId = getComposioUserId(tenantId, projectId, credentialScope, userId);
 	const composioInstance = getComposioInstance();
 	if (!composioInstance) {
-		logger.info({}, "Composio not configured, skipping auth check");
+		logger$1.info({}, "Composio not configured, skipping auth check");
 		return false;
 	}
 	try {
@@ -149,7 +149,7 @@ async function isComposioMCPServerAuthenticated(tenantId, projectId, mcpServerUr
 		if (!connectedAccounts) return false;
 		return !!connectedAccounts.items.find((account) => account.authConfig.id === firstAuthConfigId && account.status === "ACTIVE");
 	} catch (error) {
-		logger.error({
+		logger$1.error({
 			error,
 			mcpServerUrl
 		}, "Error checking Composio authentication status");
@@ -184,7 +184,7 @@ function transformComposioServerData(composioMcpServer, isAuthenticated, url, th
 async function ensureComposioAccount(composioMcpServer, derivedUserId, initiatedAccounts) {
 	const firstAuthConfigId = composioMcpServer.authConfigIds[0];
 	if (!firstAuthConfigId) {
-		logger.error({ serverId: composioMcpServer.id }, "No auth config ID found for MCP server");
+		logger$1.error({ serverId: composioMcpServer.id }, "No auth config ID found for MCP server");
 		return null;
 	}
 	const existingInitiatedAccount = initiatedAccounts.find((account) => account.authConfig.id === firstAuthConfigId);
@@ -192,12 +192,12 @@ async function ensureComposioAccount(composioMcpServer, derivedUserId, initiated
 	try {
 		const composioInstance = getComposioInstance();
 		if (!composioInstance) {
-			logger.error({ serverId: composioMcpServer.id }, "Composio not configured");
+			logger$1.error({ serverId: composioMcpServer.id }, "Composio not configured");
 			return null;
 		}
 		return (await composioInstance.connectedAccounts.link(derivedUserId, firstAuthConfigId)).redirectUrl ?? null;
 	} catch (error) {
-		logger.error({
+		logger$1.error({
 			serverId: composioMcpServer.id,
 			error
 		}, "Error creating connected account for MCP server");
@@ -212,24 +212,24 @@ async function ensureComposioAccount(composioMcpServer, derivedUserId, initiated
 */
 async function getComposioOAuthRedirectUrl(tenantId, projectId, mcpServerUrl, credentialScope, userId) {
 	if (!process.env.COMPOSIO_API_KEY) {
-		logger.info({}, "Composio API key not configured");
+		logger$1.info({}, "Composio API key not configured");
 		return null;
 	}
 	const serverId = extractComposioServerId(mcpServerUrl);
 	if (!serverId) {
-		logger.info({ mcpServerUrl }, "Could not extract Composio server ID from URL");
+		logger$1.info({ mcpServerUrl }, "Could not extract Composio server ID from URL");
 		return null;
 	}
 	const composioInstance = getComposioInstance();
 	if (!composioInstance) {
-		logger.info({}, "Composio not configured");
+		logger$1.info({}, "Composio not configured");
 		return null;
 	}
 	const composioUserId = getComposioUserId(tenantId, projectId, credentialScope, userId);
 	try {
 		return await ensureComposioAccount(await composioInstance.mcp.get(serverId), composioUserId, (await fetchComposioConnectedAccounts(composioUserId))?.items.filter((account) => account.status === "INITIATED") ?? []);
 	} catch (error) {
-		logger.error({
+		logger$1.error({
 			error,
 			mcpServerUrl
 		}, "Failed to get Composio OAuth redirect URL");
@@ -256,12 +256,12 @@ async function transformComposioServer(composioMcpServer, authenticatedAuthConfi
 */
 async function fetchComposioServers() {
 	if (!process.env.COMPOSIO_API_KEY) {
-		logger.info({}, "COMPOSIO_API_KEY not configured, skipping Composio servers");
+		logger$1.info({}, "COMPOSIO_API_KEY not configured, skipping Composio servers");
 		return [];
 	}
 	const composioInstance = getComposioInstance();
 	if (!composioInstance) {
-		logger.info({}, "Composio not configured, returning empty list");
+		logger$1.info({}, "Composio not configured, returning empty list");
 		return [];
 	}
 	try {
@@ -272,7 +272,7 @@ async function fetchComposioServers() {
 			authConfigs: []
 		}))?.items.map((server) => transformComposioServerData(server, false, server.MCPUrl, void 0)) ?? [];
 	} catch (error) {
-		logger.error({ error }, "Failed to fetch Composio servers");
+		logger$1.error({ error }, "Failed to fetch Composio servers");
 		return [];
 	}
 }
@@ -283,19 +283,19 @@ async function fetchComposioServers() {
 */
 async function fetchSingleComposioServer(tenantId, projectId, mcpServerUrl, credentialScope = "project", userId) {
 	if (!process.env.COMPOSIO_API_KEY) {
-		logger.debug({}, "COMPOSIO_API_KEY not configured");
+		logger$1.debug({}, "COMPOSIO_API_KEY not configured");
 		return null;
 	}
 	const composioUserId = getComposioUserId(tenantId, projectId, credentialScope, userId);
 	const composioInstance = getComposioInstance();
 	if (!composioInstance) {
-		logger.info({}, "Composio not configured, returning null");
+		logger$1.info({}, "Composio not configured, returning null");
 		return null;
 	}
 	try {
 		const serverId = extractComposioServerId(mcpServerUrl);
 		if (!serverId) {
-			logger.error({ mcpServerUrl }, "Could not extract Composio server ID from URL");
+			logger$1.error({ mcpServerUrl }, "Could not extract Composio server ID from URL");
 			return null;
 		}
 		const composioMcpServer = await composioInstance.mcp.get(serverId);
@@ -307,7 +307,7 @@ async function fetchSingleComposioServer(tenantId, projectId, mcpServerUrl, cred
 		const initiatedAccounts = userConnectedAccounts?.items.filter((account) => account.status === "INITIATED");
 		return await transformComposioServer(composioMcpServer, new Set(activeAccounts?.map((account) => account.authConfig.id) ?? []), initiatedAccounts ?? [], composioUserId);
 	} catch (error) {
-		logger.error({
+		logger$1.error({
 			error,
 			mcpServerUrl
 		}, "Failed to fetch single Composio server");

package/dist/utils/trigger-auth.d.ts

@@ -0,0 +1,62 @@
+import { TriggerAuthHeaderInputSchema, TriggerAuthHeaderStoredSchema, TriggerAuthenticationStoredSchema } from "../validation/schemas.js";
+import { Context } from "hono";
+import { z } from "zod";
+
+//#region src/utils/trigger-auth.d.ts
+type TriggerAuthHeaderInput = z.infer<typeof TriggerAuthHeaderInputSchema>;
+type TriggerAuthHeaderStored = z.infer<typeof TriggerAuthHeaderStoredSchema>;
+type TriggerAuthenticationStored = z.infer<typeof TriggerAuthenticationStoredSchema>;
+interface TriggerAuthResult {
+  success: boolean;
+  status?: number;
+  message?: string;
+}
+interface HashedHeaderValue {
+  valueHash: string;
+  valuePrefix: string;
+}
+/**
+ * Hash a header value using scrypt for secure storage.
+ * Returns the hash and a prefix for display purposes.
+ *
+ * @param value - The plaintext header value to hash
+ * @returns Object containing valueHash (for storage) and valuePrefix (for display)
+ */
+declare function hashTriggerHeaderValue(value: string): Promise<HashedHeaderValue>;
+/**
+ * Validate a header value against its stored hash using timing-safe comparison.
+ *
+ * @param value - The plaintext header value from the incoming request
+ * @param storedHash - The hash stored in the database
+ * @returns True if the value matches the hash
+ */
+declare function validateTriggerHeaderValue(value: string, storedHash: string): Promise<boolean>;
+/**
+ * Transform authentication input (plaintext values) to stored format (hashed values).
+ * Used when creating or updating triggers.
+ *
+ * @param headers - Array of header inputs with plaintext values
+ * @returns Array of headers with hashed values for storage
+ */
+declare function hashAuthenticationHeaders(headers: TriggerAuthHeaderInput[]): Promise<TriggerAuthHeaderStored[]>;
+/**
+ * Verifies incoming webhook requests using the configured authentication headers.
+ * Each configured header must be present and match its expected value (via hash comparison).
+ *
+ * @param c - Hono context containing the request headers
+ * @param authentication - Trigger authentication configuration with hashed header values
+ * @returns TriggerAuthResult indicating success/failure with appropriate HTTP status
+ */
+declare function verifyTriggerAuth(c: Context, authentication?: TriggerAuthenticationStored | null): Promise<TriggerAuthResult>;
+/**
+ * Verifies webhook request integrity using HMAC-SHA256 signing secret.
+ * Reads signature from X-Signature-256 header and uses timing-safe comparison.
+ *
+ * @param c - Hono context containing the request headers and body
+ * @param signingSecret - HMAC-SHA256 signing secret
+ * @param body - Raw request body as string
+ * @returns TriggerAuthResult indicating success/failure
+ */
+declare function verifySigningSecret(c: Context, signingSecret: string | null | undefined, body: string): TriggerAuthResult;
+//#endregion
+export { HashedHeaderValue, TriggerAuthResult, hashAuthenticationHeaders, hashTriggerHeaderValue, validateTriggerHeaderValue, verifySigningSecret, verifyTriggerAuth };

package/dist/utils/trigger-auth.js

@@ -0,0 +1,125 @@
+import { createHmac, randomBytes, scrypt, timingSafeEqual } from "node:crypto";
+import { promisify } from "node:util";
+
+//#region src/utils/trigger-auth.ts
+const scryptAsync = promisify(scrypt);
+const SALT_LENGTH = 32;
+const KEY_LENGTH = 64;
+const VALUE_PREFIX_LENGTH = 8;
+/**
+* Hash a header value using scrypt for secure storage.
+* Returns the hash and a prefix for display purposes.
+*
+* @param value - The plaintext header value to hash
+* @returns Object containing valueHash (for storage) and valuePrefix (for display)
+*/
+async function hashTriggerHeaderValue(value) {
+	const salt = randomBytes(SALT_LENGTH);
+	const hashedBuffer = await scryptAsync(value, salt, KEY_LENGTH);
+	return {
+		valueHash: Buffer.concat([salt, hashedBuffer]).toString("base64"),
+		valuePrefix: value.substring(0, VALUE_PREFIX_LENGTH)
+	};
+}
+/**
+* Validate a header value against its stored hash using timing-safe comparison.
+*
+* @param value - The plaintext header value from the incoming request
+* @param storedHash - The hash stored in the database
+* @returns True if the value matches the hash
+*/
+async function validateTriggerHeaderValue(value, storedHash) {
+	try {
+		const combined = Buffer.from(storedHash, "base64");
+		const salt = combined.subarray(0, SALT_LENGTH);
+		return timingSafeEqual(combined.subarray(SALT_LENGTH), await scryptAsync(value, salt, KEY_LENGTH));
+	} catch {
+		return false;
+	}
+}
+/**
+* Transform authentication input (plaintext values) to stored format (hashed values).
+* Used when creating or updating triggers.
+*
+* @param headers - Array of header inputs with plaintext values
+* @returns Array of headers with hashed values for storage
+*/
+async function hashAuthenticationHeaders(headers) {
+	return Promise.all(headers.map(async (header) => {
+		const { valueHash, valuePrefix } = await hashTriggerHeaderValue(header.value);
+		return {
+			name: header.name,
+			valueHash,
+			valuePrefix
+		};
+	}));
+}
+/**
+* Verifies incoming webhook requests using the configured authentication headers.
+* Each configured header must be present and match its expected value (via hash comparison).
+*
+* @param c - Hono context containing the request headers
+* @param authentication - Trigger authentication configuration with hashed header values
+* @returns TriggerAuthResult indicating success/failure with appropriate HTTP status
+*/
+async function verifyTriggerAuth(c, authentication) {
+	if (!authentication || !authentication.headers || authentication.headers.length === 0) return { success: true };
+	for (const header of authentication.headers) {
+		const headerName = header.name.toLowerCase();
+		const actualValue = c.req.header(headerName);
+		if (!actualValue) return {
+			success: false,
+			status: 401,
+			message: `Missing authentication header: ${header.name}`
+		};
+		if (!await validateTriggerHeaderValue(actualValue, header.valueHash)) return {
+			success: false,
+			status: 403,
+			message: `Invalid value for header: ${header.name}`
+		};
+	}
+	return { success: true };
+}
+/**
+* Verifies webhook request integrity using HMAC-SHA256 signing secret.
+* Reads signature from X-Signature-256 header and uses timing-safe comparison.
+*
+* @param c - Hono context containing the request headers and body
+* @param signingSecret - HMAC-SHA256 signing secret
+* @param body - Raw request body as string
+* @returns TriggerAuthResult indicating success/failure
+*/
+function verifySigningSecret(c, signingSecret, body) {
+	if (!signingSecret) return { success: true };
+	const signature = c.req.header("x-signature-256");
+	if (!signature) return {
+		success: false,
+		status: 401,
+		message: "Missing X-Signature-256 header"
+	};
+	const expectedSignature = `sha256=${createHmac("sha256", signingSecret).update(body).digest("hex")}`;
+	try {
+		const signatureBuffer = Buffer.from(signature);
+		const expectedBuffer = Buffer.from(expectedSignature);
+		if (signatureBuffer.length !== expectedBuffer.length) return {
+			success: false,
+			status: 403,
+			message: "Invalid signature"
+		};
+		if (!timingSafeEqual(signatureBuffer, expectedBuffer)) return {
+			success: false,
+			status: 403,
+			message: "Invalid signature"
+		};
+		return { success: true };
+	} catch {
+		return {
+			success: false,
+			status: 403,
+			message: "Invalid signature format"
+		};
+	}
+}
+
+//#endregion
+export { hashAuthenticationHeaders, hashTriggerHeaderValue, validateTriggerHeaderValue, verifySigningSecret, verifyTriggerAuth };

package/dist/validation/agentFull.js

@@ -53,10 +53,8 @@ function validateAgentRelationships(agentData) {
 		if (subAgent.canTransferTo && Array.isArray(subAgent.canTransferTo)) {
 			for (const targetId of subAgent.canTransferTo) if (!availableAgentIds.has(targetId)) errors.push(`Agent '${subAgentId}' has transfer target '${targetId}' that doesn't exist in agent`);
 		}
-		if (subAgent.canDelegateTo && Array.isArray(subAgent.canDelegateTo)) for (const targetItem of subAgent.canDelegateTo) {
-			console.log("targetItem", targetItem);
-			if (typeof targetItem === "string") {
-				console.log("targetItem is string", targetItem);
+		if (subAgent.canDelegateTo && Array.isArray(subAgent.canDelegateTo)) {
+			for (const targetItem of subAgent.canDelegateTo) if (typeof targetItem === "string") {
 				if (!availableAgentIds.has(targetItem) && !availableExternalAgentIds.has(targetItem)) errors.push(`Agent '${subAgentId}' has delegation target '${targetItem}' that doesn't exist in agent`);
 			}
 		}

package/dist/validation/dolt-schemas.d.ts

@@ -0,0 +1,49 @@
+import { z } from "@hono/zod-openapi";
+
+//#region src/validation/dolt-schemas.d.ts
+declare const BranchNameSchema: z.ZodString;
+declare const CreateBranchRequestSchema: z.ZodObject<{
+  name: z.ZodString;
+  from: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const BranchInfoSchema: z.ZodObject<{
+  baseName: z.ZodString;
+  fullName: z.ZodString;
+  hash: z.ZodString;
+}, z.core.$strip>;
+declare const BranchResponseSchema: z.ZodObject<{
+  data: z.ZodObject<{
+    baseName: z.ZodString;
+    fullName: z.ZodString;
+    hash: z.ZodString;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+declare const BranchListResponseSchema: z.ZodObject<{
+  data: z.ZodArray<z.ZodObject<{
+    baseName: z.ZodString;
+    fullName: z.ZodString;
+    hash: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const BranchNameParamsSchema: z.ZodObject<{
+  tenantId: z.ZodString;
+  projectId: z.ZodString;
+  branchName: z.ZodString;
+}, z.core.$strip>;
+declare const ResolvedRefSchema: z.ZodObject<{
+  type: z.ZodEnum<{
+    tag: "tag";
+    commit: "commit";
+    branch: "branch";
+  }>;
+  name: z.ZodString;
+  hash: z.ZodString;
+}, z.core.$strip>;
+type ResolvedRef = z.infer<typeof ResolvedRefSchema>;
+type CreateBranchRequest = z.infer<typeof CreateBranchRequestSchema>;
+type BranchInfo = z.infer<typeof BranchInfoSchema>;
+type BranchResponse = z.infer<typeof BranchResponseSchema>;
+type BranchListResponse = z.infer<typeof BranchListResponseSchema>;
+type BranchNameParams = z.infer<typeof BranchNameParamsSchema>;
+//#endregion
+export { BranchInfo, BranchInfoSchema, BranchListResponse, BranchListResponseSchema, BranchNameParams, BranchNameParamsSchema, BranchNameSchema, BranchResponse, BranchResponseSchema, CreateBranchRequest, CreateBranchRequestSchema, ResolvedRef, ResolvedRefSchema };

package/dist/validation/dolt-schemas.js

@@ -0,0 +1,44 @@
+import { z } from "@hono/zod-openapi";
+
+//#region src/validation/dolt-schemas.ts
+const BranchNameSchema = z.string().min(1, "Branch name cannot be empty").max(255, "Branch name too long").regex(/^[a-zA-Z0-9\-_./]+$/, { message: "Branch name can only contain letters, numbers, hyphens, underscores, dots, and slashes" }).openapi({
+	example: "feature-x",
+	description: "Name of the branch"
+});
+const CreateBranchRequestSchema = z.object({
+	name: BranchNameSchema,
+	from: z.string().optional().describe("Branch or commit to create from. Defaults to tenant main branch.")
+}).openapi("CreateBranchRequest");
+const BranchInfoSchema = z.object({
+	baseName: z.string().describe("User-provided branch name"),
+	fullName: z.string().describe("Full namespaced branch name"),
+	hash: z.string().describe("Current commit hash of the branch")
+}).openapi("BranchInfo");
+const BranchResponseSchema = z.object({ data: BranchInfoSchema }).openapi("BranchResponse");
+const BranchListResponseSchema = z.object({ data: z.array(BranchInfoSchema) }).openapi("BranchListResponse");
+const BranchNameParamsSchema = z.object({
+	tenantId: z.string().openapi({ param: {
+		name: "tenantId",
+		in: "path"
+	} }),
+	projectId: z.string().openapi({ param: {
+		name: "projectId",
+		in: "path"
+	} }),
+	branchName: z.string().openapi({ param: {
+		name: "branchName",
+		in: "path"
+	} })
+}).openapi("BranchNameParams");
+const ResolvedRefSchema = z.object({
+	type: z.enum([
+		"commit",
+		"tag",
+		"branch"
+	]).describe("The type of ref"),
+	name: z.string().describe("The name of the ref (branch name, tag name, or commit hash)"),
+	hash: z.string().describe("The commit hash this ref resolves to")
+}).openapi("ResolvedRef");
+
+//#endregion
+export { BranchInfoSchema, BranchListResponseSchema, BranchNameParamsSchema, BranchNameSchema, BranchResponseSchema, CreateBranchRequestSchema, ResolvedRefSchema };

package/dist/validation/drizzle-schema-helpers.d.ts

@@ -1,5 +1,5 @@
 import { z } from "@hono/zod-openapi";
-import * as drizzle_zod141 from "drizzle-zod";
+import * as drizzle_zod231 from "drizzle-zod";
 import { AnySQLiteTable } from "drizzle-orm/sqlite-core";
 
 //#region src/validation/drizzle-schema-helpers.d.ts
@@ -22,8 +22,8 @@ declare const resourceIdSchema: z.ZodString;
 declare function createResourceIdSchema(description: string, options?: {
   example?: string;
 }): z.ZodString;
-declare function createSelectSchemaWithModifiers<T extends AnySQLiteTable>(table: T, overrides?: Partial<Record<keyof T['_']['columns'], (schema: z.ZodTypeAny) => z.ZodTypeAny>>): drizzle_zod141.BuildSchema<"select", T["_"]["columns"], drizzle_zod141.BuildRefine<T["_"]["columns"], undefined>, undefined>;
-declare function createInsertSchemaWithModifiers<T extends AnySQLiteTable>(table: T, overrides?: Partial<Record<keyof T['_']['columns'], (schema: z.ZodTypeAny) => z.ZodTypeAny>>): drizzle_zod141.BuildSchema<"insert", T["_"]["columns"], drizzle_zod141.BuildRefine<Pick<T["_"]["columns"], keyof T["$inferInsert"]>, undefined>, undefined>;
+declare function createSelectSchemaWithModifiers<T extends AnySQLiteTable>(table: T, overrides?: Partial<Record<keyof T['_']['columns'], (schema: z.ZodTypeAny) => z.ZodTypeAny>>): drizzle_zod231.BuildSchema<"select", T["_"]["columns"], drizzle_zod231.BuildRefine<T["_"]["columns"], undefined>, undefined>;
+declare function createInsertSchemaWithModifiers<T extends AnySQLiteTable>(table: T, overrides?: Partial<Record<keyof T['_']['columns'], (schema: z.ZodTypeAny) => z.ZodTypeAny>>): drizzle_zod231.BuildSchema<"insert", T["_"]["columns"], drizzle_zod231.BuildRefine<Pick<T["_"]["columns"], keyof T["$inferInsert"]>, undefined>, undefined>;
 declare const createSelectSchema: typeof createSelectSchemaWithModifiers;
 declare const createInsertSchema: typeof createInsertSchemaWithModifiers;
 /**
@@ -38,27 +38,5 @@ declare const createInsertSchema: typeof createInsertSchemaWithModifiers;
  * The schema shape itself is not modified, but the field schemas are registered.
  */
 declare function registerFieldSchemas<T extends z.ZodObject<any>>(schema: T): T;
-/**
- * Wrapper for .partial() that registers the resulting schema and its fields in the global registry.
- * This function ensures that field schemas are properly registered and configured with OpenAPI metadata.
- */
-declare function partialWithRegistry<T extends z.ZodObject<any>>(schema: T, metadata?: {
-  description?: string;
-  [key: string]: unknown;
-}): T;
-/**
- * Wrapper for .omit() that registers the resulting schema and its fields in the global registry
- */
-declare function omitWithRegistry<T extends z.ZodObject<any>>(schema: T, keys: z.ZodObject<any>['shape'], metadata?: {
-  description?: string;
-  [key: string]: unknown;
-}): T;
-/**
- * Wrapper for .extend() that registers the resulting schema and its fields in the global registry
- */
-declare function extendWithRegistry<T extends z.ZodObject<any>>(schema: T, shape: z.ZodRawShape, metadata?: {
-  description?: string;
-  [key: string]: unknown;
-}): T;
 //#endregion
-export { MAX_ID_LENGTH, MIN_ID_LENGTH, URL_SAFE_ID_PATTERN, createInsertSchema, createResourceIdSchema, createSelectSchema, extendWithRegistry, omitWithRegistry, partialWithRegistry, registerFieldSchemas, resourceIdSchema };
+export { MAX_ID_LENGTH, MIN_ID_LENGTH, URL_SAFE_ID_PATTERN, createInsertSchema, createResourceIdSchema, createSelectSchema, registerFieldSchemas, resourceIdSchema };