@inkeep/agents-core 0.47.4 → 0.48.0

package/dist/utils/slack-link-token.d.ts

@@ -0,0 +1,57 @@
+import { JwtVerifyResult } from "./jwt-helpers.js";
+import { z } from "zod";
+
+//#region src/utils/slack-link-token.d.ts
+
+/**
+ * Zod schema for validating Slack link token JWT payload.
+ * This is a stateless token used for the Slack-to-Inkeep account linking flow.
+ * When a user runs `/inkeep link` in Slack, this JWT is generated and embedded
+ * in a URL that the user visits to complete the linking.
+ */
+declare const SlackLinkTokenPayloadSchema: z.ZodObject<{
+  iss: z.ZodLiteral<"inkeep-auth">;
+  aud: z.ZodLiteral<"slack-link">;
+  sub: z.ZodString;
+  iat: z.ZodNumber;
+  exp: z.ZodNumber;
+  jti: z.ZodOptional<z.ZodString>;
+  tokenUse: z.ZodLiteral<"slackLinkCode">;
+  tenantId: z.ZodString;
+  slack: z.ZodObject<{
+    teamId: z.ZodString;
+    userId: z.ZodString;
+    enterpriseId: z.ZodOptional<z.ZodString>;
+    username: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type SlackLinkTokenPayload = z.infer<typeof SlackLinkTokenPayloadSchema>;
+/**
+ * Parameters for generating a Slack link token
+ */
+interface SignSlackLinkTokenParams {
+  tenantId: string;
+  slackTeamId: string;
+  slackUserId: string;
+  slackEnterpriseId?: string;
+  slackUsername?: string;
+}
+/**
+ * Result of verifying a Slack link token
+ */
+type VerifySlackLinkTokenResult = JwtVerifyResult<SlackLinkTokenPayload>;
+/**
+ * Sign a Slack link JWT token for the device authorization flow.
+ * Token expires in 10 minutes.
+ *
+ * This token is generated when a user runs `/inkeep link` in Slack
+ * and is verified when they visit the dashboard link page.
+ */
+declare function signSlackLinkToken(params: SignSlackLinkTokenParams): Promise<string>;
+/**
+ * Verify and decode a Slack link JWT token.
+ * Validates signature, expiration, issuer, audience, and schema.
+ */
+declare function verifySlackLinkToken(token: string): Promise<VerifySlackLinkTokenResult>;
+//#endregion
+export { SignSlackLinkTokenParams, SlackLinkTokenPayload, SlackLinkTokenPayloadSchema, VerifySlackLinkTokenResult, signSlackLinkToken, verifySlackLinkToken };

package/dist/utils/slack-link-token.js

@@ -0,0 +1,112 @@
+import { getLogger } from "./logger.js";
+import { signJwt, verifyJwt } from "./jwt-helpers.js";
+import { z } from "zod";
+
+//#region src/utils/slack-link-token.ts
+const logger = getLogger("slack-link-token");
+const ISSUER = "inkeep-auth";
+const AUDIENCE = "slack-link";
+const TOKEN_USE = "slackLinkCode";
+const TOKEN_TTL = "10m";
+/**
+* Zod schema for validating Slack link token JWT payload.
+* This is a stateless token used for the Slack-to-Inkeep account linking flow.
+* When a user runs `/inkeep link` in Slack, this JWT is generated and embedded
+* in a URL that the user visits to complete the linking.
+*/
+const SlackLinkTokenPayloadSchema = z.object({
+	iss: z.literal(ISSUER),
+	aud: z.literal(AUDIENCE),
+	sub: z.string().min(1),
+	iat: z.number(),
+	exp: z.number(),
+	jti: z.string().optional(),
+	tokenUse: z.literal(TOKEN_USE),
+	tenantId: z.string().min(1),
+	slack: z.object({
+		teamId: z.string().min(1),
+		userId: z.string().min(1),
+		enterpriseId: z.string().min(1).optional(),
+		username: z.string().optional()
+	})
+});
+/**
+* Sign a Slack link JWT token for the device authorization flow.
+* Token expires in 10 minutes.
+*
+* This token is generated when a user runs `/inkeep link` in Slack
+* and is verified when they visit the dashboard link page.
+*/
+async function signSlackLinkToken(params) {
+	try {
+		const token = await signJwt({
+			issuer: ISSUER,
+			subject: `slack:${params.slackTeamId}:${params.slackUserId}`,
+			audience: AUDIENCE,
+			expiresIn: TOKEN_TTL,
+			claims: {
+				tokenUse: TOKEN_USE,
+				tenantId: params.tenantId,
+				slack: {
+					teamId: params.slackTeamId,
+					userId: params.slackUserId,
+					...params.slackEnterpriseId && { enterpriseId: params.slackEnterpriseId },
+					...params.slackUsername && { username: params.slackUsername }
+				}
+			}
+		});
+		logger.debug({
+			tenantId: params.tenantId,
+			slackTeamId: params.slackTeamId,
+			slackUserId: params.slackUserId
+		}, "Generated Slack link token");
+		return token;
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		logger.error({
+			error,
+			errorMessage
+		}, "Failed to generate Slack link token");
+		throw new Error(`Failed to generate Slack link token: ${errorMessage}`);
+	}
+}
+/**
+* Verify and decode a Slack link JWT token.
+* Validates signature, expiration, issuer, audience, and schema.
+*/
+async function verifySlackLinkToken(token) {
+	const result = await verifyJwt(token, {
+		issuer: ISSUER,
+		audience: AUDIENCE
+	});
+	if (!result.valid || !result.payload) {
+		logger.warn({ error: result.error }, "Slack link token verification failed");
+		return {
+			valid: false,
+			error: result.error
+		};
+	}
+	const parseResult = SlackLinkTokenPayloadSchema.safeParse(result.payload);
+	if (!parseResult.success) {
+		logger.warn({
+			payload: result.payload,
+			issues: parseResult.error.issues
+		}, "Invalid Slack link token: schema validation failed");
+		return {
+			valid: false,
+			error: `Invalid token schema: ${parseResult.error.issues.map((e) => e.message).join(", ")}`
+		};
+	}
+	logger.debug({
+		tenantId: parseResult.data.tenantId,
+		slackTeamId: parseResult.data.slack.teamId,
+		slackUserId: parseResult.data.slack.userId
+	}, "Successfully verified Slack link token");
+	return {
+		valid: true,
+		payload: parseResult.data
+	};
+}
+
+//#endregion
+export { SlackLinkTokenPayloadSchema, signSlackLinkToken, verifySlackLinkToken };

package/dist/utils/slack-user-token.d.ts

@@ -0,0 +1,65 @@
+import { JwtVerifyResult } from "./jwt-helpers.js";
+import { z } from "zod";
+
+//#region src/utils/slack-user-token.d.ts
+
+/**
+ * Zod schema for validating Slack user access token JWT payload.
+ * This is the canonical schema from the work_apps_slack spec.
+ */
+declare const SlackAccessTokenPayloadSchema: z.ZodObject<{
+  iss: z.ZodLiteral<"inkeep-auth">;
+  aud: z.ZodLiteral<"inkeep-api">;
+  sub: z.ZodString;
+  iat: z.ZodNumber;
+  exp: z.ZodNumber;
+  jti: z.ZodOptional<z.ZodString>;
+  tokenUse: z.ZodLiteral<"slackUser">;
+  act: z.ZodObject<{
+    sub: z.ZodLiteral<"inkeep-work-app-slack">;
+  }, z.core.$strip>;
+  tenantId: z.ZodString;
+  slack: z.ZodObject<{
+    teamId: z.ZodString;
+    userId: z.ZodString;
+    enterpriseId: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type SlackAccessTokenPayload = z.infer<typeof SlackAccessTokenPayloadSchema>;
+/**
+ * Parameters for generating a Slack user token
+ */
+interface SignSlackUserTokenParams {
+  inkeepUserId: string;
+  tenantId: string;
+  slackTeamId: string;
+  slackUserId: string;
+  slackEnterpriseId?: string;
+  slackEmail?: string;
+}
+/**
+ * Result of verifying a Slack user token
+ */
+type VerifySlackUserTokenResult = JwtVerifyResult<SlackAccessTokenPayload>;
+/**
+ * Sign a Slack user JWT token for calling Manage/Run APIs.
+ * Token expires in 5 minutes.
+ *
+ * This token is used when Slack runtime logic needs to call:
+ * - Manage API (list projects, list agents)
+ * - Run API (POST /run/api/chat)
+ */
+declare function signSlackUserToken(params: SignSlackUserTokenParams): Promise<string>;
+/**
+ * Verify and decode a Slack user JWT token.
+ * Validates signature, expiration, issuer, audience, and schema.
+ */
+declare function verifySlackUserToken(token: string): Promise<VerifySlackUserTokenResult>;
+/**
+ * Check if a token looks like a Slack user JWT (quick check before full verification).
+ * Returns true if the token has the expected issuer and tokenUse.
+ */
+declare function isSlackUserToken(token: string): boolean;
+//#endregion
+export { SignSlackUserTokenParams, SlackAccessTokenPayload, SlackAccessTokenPayloadSchema, VerifySlackUserTokenResult, isSlackUserToken, signSlackUserToken, verifySlackUserToken };

package/dist/utils/slack-user-token.js

@@ -0,0 +1,129 @@
+import { getLogger } from "./logger.js";
+import { signJwt, verifyJwt } from "./jwt-helpers.js";
+import { z } from "zod";
+
+//#region src/utils/slack-user-token.ts
+const logger = getLogger("slack-user-token");
+const ISSUER = "inkeep-auth";
+const AUDIENCE = "inkeep-api";
+const TOKEN_USE = "slackUser";
+const ACTOR_SUB = "inkeep-work-app-slack";
+const TOKEN_TTL = "5m";
+/**
+* Zod schema for validating Slack user access token JWT payload.
+* This is the canonical schema from the work_apps_slack spec.
+*/
+const SlackAccessTokenPayloadSchema = z.object({
+	iss: z.literal(ISSUER),
+	aud: z.literal(AUDIENCE),
+	sub: z.string().min(1),
+	iat: z.number(),
+	exp: z.number(),
+	jti: z.string().optional(),
+	tokenUse: z.literal(TOKEN_USE),
+	act: z.object({ sub: z.literal(ACTOR_SUB) }),
+	tenantId: z.string().min(1),
+	slack: z.object({
+		teamId: z.string().min(1),
+		userId: z.string().min(1),
+		enterpriseId: z.string().min(1).optional(),
+		email: z.string().email().optional()
+	})
+});
+/**
+* Sign a Slack user JWT token for calling Manage/Run APIs.
+* Token expires in 5 minutes.
+*
+* This token is used when Slack runtime logic needs to call:
+* - Manage API (list projects, list agents)
+* - Run API (POST /run/api/chat)
+*/
+async function signSlackUserToken(params) {
+	try {
+		const token = await signJwt({
+			issuer: ISSUER,
+			subject: params.inkeepUserId,
+			audience: AUDIENCE,
+			expiresIn: TOKEN_TTL,
+			claims: {
+				tokenUse: TOKEN_USE,
+				act: { sub: ACTOR_SUB },
+				tenantId: params.tenantId,
+				slack: {
+					teamId: params.slackTeamId,
+					userId: params.slackUserId,
+					...params.slackEnterpriseId && { enterpriseId: params.slackEnterpriseId },
+					...params.slackEmail && { email: params.slackEmail }
+				}
+			}
+		});
+		logger.debug({
+			inkeepUserId: params.inkeepUserId,
+			tenantId: params.tenantId,
+			slackTeamId: params.slackTeamId,
+			slackUserId: params.slackUserId
+		}, "Generated Slack user token");
+		return token;
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		logger.error({
+			error,
+			errorMessage
+		}, "Failed to generate Slack user token");
+		throw new Error(`Failed to generate Slack user token: ${errorMessage}`);
+	}
+}
+/**
+* Verify and decode a Slack user JWT token.
+* Validates signature, expiration, issuer, audience, and schema.
+*/
+async function verifySlackUserToken(token) {
+	const result = await verifyJwt(token, {
+		issuer: ISSUER,
+		audience: AUDIENCE
+	});
+	if (!result.valid || !result.payload) {
+		logger.warn({ error: result.error }, "Slack user token verification failed");
+		return {
+			valid: false,
+			error: result.error
+		};
+	}
+	const parseResult = SlackAccessTokenPayloadSchema.safeParse(result.payload);
+	if (!parseResult.success) {
+		logger.warn({
+			payload: result.payload,
+			issues: parseResult.error.issues
+		}, "Invalid Slack user token: schema validation failed");
+		return {
+			valid: false,
+			error: `Invalid token schema: ${parseResult.error.issues.map((e) => e.message).join(", ")}`
+		};
+	}
+	logger.debug({
+		inkeepUserId: parseResult.data.sub,
+		tenantId: parseResult.data.tenantId,
+		slackTeamId: parseResult.data.slack.teamId
+	}, "Successfully verified Slack user token");
+	return {
+		valid: true,
+		payload: parseResult.data
+	};
+}
+/**
+* Check if a token looks like a Slack user JWT (quick check before full verification).
+* Returns true if the token has the expected issuer and tokenUse.
+*/
+function isSlackUserToken(token) {
+	try {
+		const parts = token.split(".");
+		if (parts.length !== 3) return false;
+		const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString());
+		return payload?.iss === ISSUER && payload?.tokenUse === TOKEN_USE;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+export { SlackAccessTokenPayloadSchema, isSlackUserToken, signSlackUserToken, verifySlackUserToken };

package/dist/utils/sse-parser.d.ts

@@ -0,0 +1,35 @@
+//#region src/utils/sse-parser.d.ts
+/**
+ * SSE (Server-Sent Events) Response Parser
+ *
+ * Shared utility for parsing SSE responses from the chat API.
+ * Used by EvaluationService, Slack integration, and other consumers.
+ *
+ * Handles multiple response formats:
+ * - OpenAI-compatible chat completion chunks
+ * - Vercel AI SDK data stream format (text-delta)
+ * - Error operations and events
+ */
+interface ParsedSSEResponse {
+  text: string;
+  error?: string;
+}
+/**
+ * Parse SSE (Server-Sent Events) response from chat API
+ * Handles text deltas, error operations, and other data operations
+ *
+ * Supports:
+ * - OpenAI-compatible format: `chat.completion.chunk` with `delta.content`
+ * - Vercel AI SDK format: `text-delta` with `delta`
+ * - Vercel AI SDK format: `text-start` and `text-end` markers (ignored)
+ * - Error operations: `data-operation` with `type: 'error'`
+ * - Direct error events: `type: 'error'`
+ *
+ * Ignores:
+ * - `data-operation` events (metadata, not content)
+ * - `text-start` and `text-end` markers
+ * - `[DONE]` markers
+ */
+declare function parseSSEResponse(sseText: string): ParsedSSEResponse;
+//#endregion
+export { ParsedSSEResponse, parseSSEResponse };

package/dist/utils/sse-parser.js

@@ -0,0 +1,71 @@
+//#region src/utils/sse-parser.ts
+/**
+* Parse SSE (Server-Sent Events) response from chat API
+* Handles text deltas, error operations, and other data operations
+*
+* Supports:
+* - OpenAI-compatible format: `chat.completion.chunk` with `delta.content`
+* - Vercel AI SDK format: `text-delta` with `delta`
+* - Vercel AI SDK format: `text-start` and `text-end` markers (ignored)
+* - Error operations: `data-operation` with `type: 'error'`
+* - Direct error events: `type: 'error'`
+*
+* Ignores:
+* - `data-operation` events (metadata, not content)
+* - `text-start` and `text-end` markers
+* - `[DONE]` markers
+*/
+function parseSSEResponse(sseText) {
+	let textContent = "";
+	let hasError = false;
+	let errorMessage = "";
+	const lines = sseText.split("\n").filter((line) => line.startsWith("data: "));
+	for (const line of lines) {
+		const jsonStr = line.slice(6).trim();
+		if (!jsonStr || jsonStr === "[DONE]") continue;
+		try {
+			const data = JSON.parse(jsonStr);
+			if (data.object === "chat.completion.chunk" && data.choices?.[0]?.delta) {
+				const delta = data.choices[0].delta;
+				if (delta.content && typeof delta.content === "string") try {
+					const parsedContent = JSON.parse(delta.content);
+					if (parsedContent.type === "data-operation") {
+						if (parsedContent.data?.type === "error") {
+							hasError = true;
+							errorMessage = parsedContent.data.message || "Unknown error occurred";
+						}
+						continue;
+					}
+					textContent += delta.content;
+				} catch {
+					textContent += delta.content;
+				}
+				continue;
+			}
+			if (data.type === "text-delta" && data.delta) {
+				textContent += data.delta;
+				continue;
+			}
+			if (data.type === "text-start" || data.type === "text-end") continue;
+			if (data.type === "data-operation") {
+				if (data.data?.type === "error") {
+					hasError = true;
+					errorMessage = data.data.message || "Unknown error occurred";
+				}
+				continue;
+			}
+			if (data.type === "error") {
+				hasError = true;
+				errorMessage = data.message || "Unknown error occurred";
+			}
+		} catch {}
+	}
+	if (hasError) return {
+		text: textContent.trim(),
+		error: errorMessage
+	};
+	return { text: textContent.trim() };
+}
+
+//#endregion
+export { parseSSEResponse };

package/dist/utils/tracer-factory.d.ts

@@ -2,9 +2,18 @@ import { Span, Tracer } from "@opentelemetry/api";
 
 //#region src/utils/tracer-factory.d.ts
 
+/**
+ * Unwraps nested error `.cause` chains to find the root cause error.
+ * Node.js `fetch()` wraps undici errors (e.g. HeadersTimeoutError) into
+ * a generic `TypeError: fetch failed` with the real error in `.cause`.
+ * This utility traverses the cause chain to surface the original error.
+ */
+declare function unwrapError(error: unknown): Error;
 /**
  * Helper function to handle span errors consistently
- * Records the exception, sets error status, and optionally logs
+ * Records the exception, sets error status, and optionally logs.
+ * Automatically unwraps `.cause` chains so spans show root cause errors
+ * instead of generic wrappers like "fetch failed".
  */
 declare function setSpanWithError(span: Span, error: Error, logger?: {
   error: (obj: any, msg?: string) => void;
@@ -15,4 +24,4 @@ declare function setSpanWithError(span: Span, error: Error, logger?: {
  */
 declare function getTracer(serviceName: string, serviceVersion?: string): Tracer;
 //#endregion
-export { getTracer, setSpanWithError };
+export { getTracer, setSpanWithError, unwrapError };

package/dist/utils/tracer-factory.js

@@ -32,16 +32,35 @@ const noopTracer = {
 	}
 };
 /**
+* Unwraps nested error `.cause` chains to find the root cause error.
+* Node.js `fetch()` wraps undici errors (e.g. HeadersTimeoutError) into
+* a generic `TypeError: fetch failed` with the real error in `.cause`.
+* This utility traverses the cause chain to surface the original error.
+*/
+function unwrapError(error) {
+	if (!(error instanceof Error)) return new Error(String(error));
+	let current = error;
+	const seen = /* @__PURE__ */ new Set();
+	while (current.cause instanceof Error && !seen.has(current.cause)) {
+		seen.add(current);
+		current = current.cause;
+	}
+	return current;
+}
+/**
 * Helper function to handle span errors consistently
-* Records the exception, sets error status, and optionally logs
+* Records the exception, sets error status, and optionally logs.
+* Automatically unwraps `.cause` chains so spans show root cause errors
+* instead of generic wrappers like "fetch failed".
 */
 function setSpanWithError(span, error, logger$1, logMessage) {
-	span.recordException(error);
+	const rootCause = unwrapError(error);
+	span.recordException(rootCause);
 	span.setStatus({
 		code: SpanStatusCode.ERROR,
-		message: error.message
+		message: rootCause.message
 	});
-	if (logger$1 && logMessage) logger$1.error({ error: error.message }, logMessage);
+	if (logger$1 && logMessage) logger$1.error({ error: rootCause.message }, logMessage);
 }
 /**
 * Get a tracer instance for the specified service
@@ -57,4 +76,4 @@ function getTracer(serviceName, serviceVersion) {
 }
 
 //#endregion
-export { getTracer, setSpanWithError };
+export { getTracer, setSpanWithError, unwrapError };

package/dist/utils/tracer.d.ts

@@ -1,7 +1,7 @@
-import { setSpanWithError } from "./tracer-factory.js";
+import { setSpanWithError, unwrapError } from "./tracer-factory.js";
 import * as _opentelemetry_api0 from "@opentelemetry/api";
 
 //#region src/utils/tracer.d.ts
 declare const tracer: _opentelemetry_api0.Tracer;
 //#endregion
-export { setSpanWithError, tracer };
+export { setSpanWithError, tracer, unwrapError };

package/dist/utils/tracer.js

@@ -1,7 +1,7 @@
-import { getTracer, setSpanWithError } from "./tracer-factory.js";
+import { getTracer, setSpanWithError, unwrapError } from "./tracer-factory.js";
 
 //#region src/utils/tracer.ts
 const tracer = getTracer("agents-core");
 
 //#endregion
-export { setSpanWithError, tracer };
+export { setSpanWithError, tracer, unwrapError };

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

@@ -1,6 +1,6 @@
 import { SignatureVerificationConfig, TriggerAuthHeaderInputSchema, TriggerAuthHeaderStoredSchema, TriggerAuthenticationStoredSchema } from "../validation/schemas.js";
-import { Context } from "hono";
 import { z } from "zod";
+import { Context } from "hono";
 
 //#region src/utils/trigger-auth.d.ts
 type TriggerAuthHeaderInput = z.infer<typeof TriggerAuthHeaderInputSchema>;

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

@@ -1,10 +1,10 @@
 import { z } from "@hono/zod-openapi";
-import * as drizzle_zod331 from "drizzle-zod";
+import * as drizzle_zod0 from "drizzle-zod";
 import { AnySQLiteTable } from "drizzle-orm/sqlite-core";
 
 //#region src/validation/drizzle-schema-helpers.d.ts
-declare function createSelectSchemaWithModifiers<T extends AnySQLiteTable>(table: T, overrides?: Partial<Record<keyof T['_']['columns'], (schema: z.ZodTypeAny) => z.ZodTypeAny>>): drizzle_zod331.BuildSchema<"select", T["_"]["columns"], drizzle_zod331.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_zod331.BuildSchema<"insert", T["_"]["columns"], drizzle_zod331.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_zod0.BuildSchema<"select", T["_"]["columns"], drizzle_zod0.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_zod0.BuildSchema<"insert", T["_"]["columns"], drizzle_zod0.BuildRefine<Pick<T["_"]["columns"], keyof T["$inferInsert"]>, undefined>, undefined>;
 declare const createSelectSchema: typeof createSelectSchemaWithModifiers;
 declare const createInsertSchema: typeof createInsertSchemaWithModifiers;
 /**

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

@@ -0,0 +1,34 @@
+import { JsonSchemaProperty } from "./json-schemas.js";
+import { z } from "@hono/zod-openapi";
+
+//#region src/validation/extend-schemas.d.ts
+declare const NameSchema: z.ZodString;
+declare const DescriptionSchema: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+/**
+ * Used in z.transform()
+ */
+declare function transformToJson<T extends string>(value: T, ctx: z.RefinementCtx<T>): any;
+declare const DataComponentExtendSchema: {
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  props: z.ZodObject<{
+    type: z.ZodLiteral<"object">;
+    properties: z.ZodRecord<z.ZodString, z.ZodType<JsonSchemaProperty, unknown, z.core.$ZodTypeInternals<JsonSchemaProperty, unknown>>>;
+    required: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+    additionalProperties: z.ZodOptional<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodString>;
+  }, z.core.$loose>;
+};
+declare const ArtifactComponentExtendSchema: {
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  props: z.ZodNullable<z.ZodObject<{
+    type: z.ZodLiteral<"object">;
+    properties: z.ZodRecord<z.ZodString, z.ZodType<JsonSchemaProperty, unknown, z.core.$ZodTypeInternals<JsonSchemaProperty, unknown>>>;
+    required: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
+    additionalProperties: z.ZodOptional<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodString>;
+  }, z.core.$loose>>;
+};
+//#endregion
+export { ArtifactComponentExtendSchema, DataComponentExtendSchema, DescriptionSchema, NameSchema, transformToJson };

package/dist/validation/extend-schemas.js

@@ -0,0 +1,33 @@
+import { JsonSchemaForLlmSchema } from "./json-schemas.js";
+import { z } from "@hono/zod-openapi";
+
+//#region src/validation/extend-schemas.ts
+const NameSchema = z.string().trim().nonempty("Name is required").max(256).openapi("NameSchema");
+const DescriptionSchema = z.string().trim().nullish().openapi("DescriptionSchema");
+/**
+* Used in z.transform()
+*/
+function transformToJson(value, ctx) {
+	try {
+		return JSON.parse(value);
+	} catch {
+		ctx.addIssue({
+			code: "custom",
+			message: "Invalid JSON syntax"
+		});
+		return z.NEVER;
+	}
+}
+const DataComponentExtendSchema = {
+	name: NameSchema,
+	description: DescriptionSchema,
+	props: JsonSchemaForLlmSchema
+};
+const ArtifactComponentExtendSchema = {
+	name: NameSchema,
+	description: DescriptionSchema,
+	props: JsonSchemaForLlmSchema.nullable()
+};
+
+//#endregion
+export { ArtifactComponentExtendSchema, DataComponentExtendSchema, DescriptionSchema, NameSchema, transformToJson };