@electric-ax/agents-server 0.4.16 → 0.4.18

package/dist/index.cjs

@@ -78,6 +78,7 @@ const entityTypes = (0, drizzle_orm_pg_core.pgTable)(`entity_types`, {
 	creationSchema: (0, drizzle_orm_pg_core.jsonb)(`creation_schema`),
 	inboxSchemas: (0, drizzle_orm_pg_core.jsonb)(`inbox_schemas`),
 	stateSchemas: (0, drizzle_orm_pg_core.jsonb)(`state_schemas`),
+	slashCommands: (0, drizzle_orm_pg_core.jsonb)(`slash_commands`),
 	serveEndpoint: (0, drizzle_orm_pg_core.text)(`serve_endpoint`),
 	defaultDispatchPolicy: (0, drizzle_orm_pg_core.jsonb)(`default_dispatch_policy`),
 	revision: (0, drizzle_orm_pg_core.integer)(`revision`).notNull().default(1),
@@ -849,6 +850,7 @@ var PostgresRegistry = class {
 			creationSchema: et.creation_schema ?? null,
 			inboxSchemas: et.inbox_schemas ?? null,
 			stateSchemas: et.state_schemas ?? null,
+			slashCommands: et.slash_commands ?? null,
 			serveEndpoint: et.serve_endpoint ?? null,
 			defaultDispatchPolicy: et.default_dispatch_policy ?? null,
 			revision: et.revision,
@@ -861,6 +863,7 @@ var PostgresRegistry = class {
 				creationSchema: et.creation_schema ?? null,
 				inboxSchemas: et.inbox_schemas ?? null,
 				stateSchemas: et.state_schemas ?? null,
+				slashCommands: et.slash_commands ?? null,
 				serveEndpoint: et.serve_endpoint ?? null,
 				defaultDispatchPolicy: et.default_dispatch_policy ?? null,
 				revision: et.revision,
@@ -878,6 +881,7 @@ var PostgresRegistry = class {
 			creationSchema: et.creation_schema ?? null,
 			inboxSchemas: et.inbox_schemas ?? null,
 			stateSchemas: et.state_schemas ?? null,
+			slashCommands: et.slash_commands ?? null,
 			serveEndpoint: et.serve_endpoint ?? null,
 			defaultDispatchPolicy: et.default_dispatch_policy ?? null,
 			revision: et.revision,
@@ -904,6 +908,7 @@ var PostgresRegistry = class {
 			creationSchema: et.creation_schema ?? null,
 			inboxSchemas: et.inbox_schemas ?? null,
 			stateSchemas: et.state_schemas ?? null,
+			slashCommands: et.slash_commands ?? null,
 			serveEndpoint: et.serve_endpoint ?? null,
 			defaultDispatchPolicy: et.default_dispatch_policy ?? null,
 			revision: et.revision,
@@ -1494,6 +1499,7 @@ var PostgresRegistry = class {
 			creation_schema: row.creationSchema,
 			inbox_schemas: row.inboxSchemas,
 			state_schemas: row.stateSchemas,
+			slash_commands: row.slashCommands ?? void 0,
 			serve_endpoint: row.serveEndpoint ?? void 0,
 			default_dispatch_policy: row.defaultDispatchPolicy ?? void 0,
 			revision: row.revision,
@@ -3387,6 +3393,7 @@ var EntityManager = class {
 		this.validateSchema(req.creation_schema);
 		this.validateSchemaMap(req.inbox_schemas);
 		this.validateSchemaMap(req.state_schemas);
+		this.validateSlashCommands(req.slash_commands);
 		const defaultDispatchPolicy = req.default_dispatch_policy ? this.validateDispatchPolicy(req.default_dispatch_policy, { label: `default_dispatch_policy` }) : void 0;
 		const existing = await this.registry.getEntityType(req.name);
 		const now = new Date().toISOString();
@@ -3396,6 +3403,7 @@ var EntityManager = class {
 			creation_schema: req.creation_schema,
 			inbox_schemas: req.inbox_schemas,
 			state_schemas: req.state_schemas,
+			slash_commands: req.slash_commands,
 			serve_endpoint: req.serve_endpoint,
 			default_dispatch_policy: defaultDispatchPolicy,
 			revision: existing ? existing.revision + 1 : 1,
@@ -3557,6 +3565,18 @@ var EntityManager = class {
 			}
 		});
 		const initialEvents = [createdEvent];
+		const slashCommandTimestamp = new Date().toISOString();
+		for (const command of entityType.slash_commands ?? []) {
+			const slashCommandEvent = __electric_ax_agents_runtime.entityStateSchema.slashCommands.insert({
+				key: command.name,
+				value: {
+					...command,
+					source: `static`,
+					updated_at: slashCommandTimestamp
+				}
+			});
+			initialEvents.push(slashCommandEvent);
+		}
 		if (req.initialMessage !== void 0) {
 			const msgNow = new Date().toISOString();
 			const inboxEvent = __electric_ax_agents_runtime.entityStateSchema.inbox.insert({
@@ -3564,6 +3584,7 @@ var EntityManager = class {
 				value: {
 					from: req.created_by ?? req.parent ?? `spawn`,
 					payload: req.initialMessage,
+					message_type: req.initialMessageType,
 					timestamp: msgNow
 				}
 			});
@@ -3643,9 +3664,10 @@ var EntityManager = class {
 		const workLocks = new Set();
 		const writeEntityLocks = new Set();
 		const writeStreamLocks = new Set();
+		const usePointerPath = opts.forkPointer !== void 0 || opts.anchor !== void 0;
 		try {
 			let sourceTree;
-			if (opts.forkPointer) {
+			if (usePointerPath) {
 				const rootEntity = await this.registry.getEntity(rootUrl);
 				if (!rootEntity) throw new ElectricAgentsError(ErrCodeNotFound, `Entity not found`, 404);
 				if (isTerminalEntityStatus(rootEntity.status)) throw new ElectricAgentsError(ErrCodeNotRunning, `Cannot fork terminal entity "${rootEntity.url}"`, 409);
@@ -3654,10 +3676,13 @@ var EntityManager = class {
 			const sourceRoot = sourceTree[0];
 			if (sourceRoot.parent) throw new ElectricAgentsError(ErrCodeInvalidRequest, `Only top-level entities can be forked`, 400);
 			let preFilteredRoot;
-			if (opts.forkPointer) {
+			let effectiveForkPointer = opts.forkPointer;
+			if (usePointerPath) {
 				const sourceEvents = await this.streamClient.readJson(sourceRoot.streams.main);
 				const flat = sourceEvents.flatMap((item) => Array.isArray(item) ? item : [item]);
-				const target = this.resolveForkPointerTarget(flat, opts.forkPointer, sourceRoot.streams.main);
+				if (!effectiveForkPointer && opts.anchor === `latest_completed_run`) effectiveForkPointer = this.resolveLatestCompletedRunPointer(flat, sourceRoot.streams.main);
+				if (!effectiveForkPointer) throw new ElectricAgentsError(ErrCodeInvalidRequest, `Internal: pointer-path fork with no resolved pointer`, 500);
+				const target = this.resolveForkPointerTarget(flat, effectiveForkPointer, sourceRoot.streams.main);
 				const filteredEvents = flat.slice(0, target);
 				const rootManifests = this.reduceStateRows(filteredEvents, `manifest`);
 				const sharedStateIds = new Set();
@@ -3670,7 +3695,7 @@ var EntityManager = class {
 				};
 			}
 			const effectiveSubtree = preFilteredRoot ? this.computeEffectiveSubtree(sourceTree, sourceRoot.url, preFilteredRoot.manifests) : sourceTree;
-			if (opts.forkPointer) {
+			if (usePointerPath) {
 				const descendants = effectiveSubtree.filter((entity) => entity.url !== sourceRoot.url);
 				if (descendants.length > 0) await this.waitForGivenEntitiesIdle(descendants, opts, workLocks);
 			}
@@ -3695,6 +3720,14 @@ var EntityManager = class {
 			const sharedStateIdMap = await this.buildForkSharedStateIdMap(snapshot.sharedStateIds, suffix);
 			const stringMap = this.buildForkStringMap(entityUrlMap, sharedStateIdMap);
 			const entityPlans = this.buildForkEntityPlans(effectiveSubtree, entityUrlMap, stringMap, opts.createdBy);
+			const rootPlanForOverrides = entityPlans.find((plan) => plan.source.url === rootUrl);
+			if (rootPlanForOverrides) {
+				if (opts.parent !== void 0) rootPlanForOverrides.fork.parent = opts.parent;
+				if (opts.tags !== void 0) rootPlanForOverrides.fork.tags = {
+					...rootPlanForOverrides.fork.tags ?? {},
+					...opts.tags
+				};
+			}
 			this.addForkLocks(this.forkWriteLockedEntities, effectiveSubtree.map((entity) => entity.url), writeEntityLocks);
 			this.addForkLocks(this.forkWriteLockedStreams, [...snapshot.sharedStateIds].map((id) => (0, __electric_ax_agents_runtime.getSharedStateStreamPath)(id)), writeStreamLocks);
 			const createdStreams = [];
@@ -3703,7 +3736,7 @@ var EntityManager = class {
 			try {
 				for (const plan of entityPlans) {
 					const isRoot = plan.source.url === rootUrl;
-					await this.streamClient.fork(plan.fork.streams.main, plan.source.streams.main, isRoot && opts.forkPointer ? { forkPointer: opts.forkPointer } : void 0);
+					await this.streamClient.fork(plan.fork.streams.main, plan.source.streams.main, isRoot && effectiveForkPointer ? { forkPointer: effectiveForkPointer } : void 0);
 					createdStreams.push(plan.fork.streams.main);
 				}
 				for (const [sourceId, forkId] of sharedStateIdMap) {
@@ -3730,6 +3763,20 @@ var EntityManager = class {
 					await this.registry.createEntity(plan.fork);
 					createdEntities.push(plan.fork.url);
 				}
+				if (opts.wake !== void 0) {
+					const rootPlan = entityPlans.find((plan) => plan.source.url === rootUrl);
+					if (rootPlan) await this.wakeRegistry.register({
+						tenantId: this.tenantId,
+						subscriberUrl: opts.wake.subscriberUrl,
+						sourceUrl: rootPlan.fork.url,
+						condition: opts.wake.condition,
+						debounceMs: opts.wake.debounceMs,
+						timeoutMs: opts.wake.timeoutMs,
+						oneShot: false,
+						includeResponse: opts.wake.includeResponse,
+						manifestKey: opts.wake.manifestKey
+					});
+				}
 				for (const plan of entityPlans) {
 					const manifests = activeManifestsByEntity.get(plan.fork.url) ?? new Map();
 					await this.materializeForkManifestSideEffects(plan.fork.url, manifests);
@@ -3890,6 +3937,45 @@ var EntityManager = class {
 		return positionAtAnchor + pointer.subOffset;
 	}
 	/**
+	* Find an `EventPointer` that addresses the most recent `runs` row on
+	* the source's `main` stream with `status === 'completed'`. Mirrors the
+	* eligibility rule the per-row "Fork from here" UI applies — only
+	* completed runs are valid fork anchors; `started`/`failed` rows are
+	* skipped.
+	*
+	* The pointer is computed in the same coordinate system the runtime
+	* mints pointers in (see entity-stream-db's onBeforeBatch): for a row
+	* R in log entry E, the pointer is `{ offset: P, subOffset: K }` where
+	* `P` is the END offset of the log entry preceding E (or `null` for
+	* stream start) and `K` is R's 1-indexed position within E.
+	*/
+	resolveLatestCompletedRunPointer(events, streamPath) {
+		let priorEntryOffset = null;
+		let currentEntryOffset = null;
+		let positionInEntry = 0;
+		let latest = null;
+		for (const event of events) {
+			const headers = isRecord(event.headers) ? event.headers : void 0;
+			const eventOffset = typeof headers?.offset === `string` ? headers.offset : null;
+			if (eventOffset !== currentEntryOffset) {
+				priorEntryOffset = currentEntryOffset;
+				currentEntryOffset = eventOffset;
+				positionInEntry = 0;
+			}
+			positionInEntry++;
+			if (event.type !== `run`) continue;
+			if (headers?.operation === `delete`) continue;
+			if (!isRecord(event.value)) continue;
+			if (event.value.status !== `completed`) continue;
+			latest = {
+				offset: priorEntryOffset,
+				subOffset: positionInEntry
+			};
+		}
+		if (!latest) throw new ElectricAgentsError(ErrCodeInvalidRequest, `Source ${streamPath} has no completed run to fork from`, 400);
+		return latest;
+	}
+	/**
 	* Compute the subset of `sourceTree` that survives the manifest filter
 	* applied at the root. After filtering the root's manifest at the fork
 	* pointer, only children whose manifest entries landed at or before the
@@ -5009,7 +5095,9 @@ var EntityManager = class {
 			creation_schema: existing.creation_schema,
 			inbox_schemas: mergedInbox,
 			state_schemas: mergedState,
+			slash_commands: existing.slash_commands,
 			serve_endpoint: existing.serve_endpoint,
+			default_dispatch_policy: existing.default_dispatch_policy,
 			revision: nextRevision,
 			created_at: existing.created_at,
 			updated_at: now
@@ -5063,11 +5151,19 @@ var EntityManager = class {
 			throw new ElectricAgentsError(ErrCodeInvalidRequest, error instanceof Error ? error.message : `Invalid tags`, 400);
 		}
 	}
+	validateSlashCommands(input) {
+		const validationError = (0, __electric_ax_agents_runtime.validateSlashCommandDefinitions)(input);
+		if (!validationError) return;
+		throw new ElectricAgentsError(ErrCodeSchemaValidationFailed, validationError.message, 422, validationError.details);
+	}
 	async validateSendRequest(entityUrl, req) {
 		const entity = await this.registry.getEntity(entityUrl);
 		if (!entity) throw new ElectricAgentsError(ErrCodeNotFound, `Entity not found`, 404);
 		if (rejectsNormalWrites(entity.status)) throw new ElectricAgentsError(ErrCodeNotRunning, `Entity is not accepting writes`, 409);
-		if (req.type && entity.type) {
+		if (req.type === __electric_ax_agents_runtime.COMPOSER_INPUT_MESSAGE_TYPE) {
+			const valErr = (0, __electric_ax_agents_runtime.validateComposerInputPayload)(req.payload);
+			if (valErr) throw new ElectricAgentsError(ErrCodeSchemaValidationFailed, valErr.message, 422, valErr.details);
+		} else if (req.type && entity.type) {
 			const { inboxSchemas } = await this.getEffectiveSchemas(entity);
 			if (inboxSchemas) {
 				const schema = inboxSchemas[req.type];
@@ -7140,7 +7236,7 @@ function buildElectricProxyTarget(options) {
 			permissionBypass: options.permissionBypass
 		}));
 	} else if (table === `entity_types`) {
-		target.searchParams.set(`columns`, `"tenant_id","name","description","creation_schema","inbox_schemas","state_schemas","serve_endpoint","default_dispatch_policy","revision","created_at","updated_at"`);
+		target.searchParams.set(`columns`, `"tenant_id","name","description","creation_schema","inbox_schemas","state_schemas","slash_commands","serve_endpoint","default_dispatch_policy","revision","created_at","updated_at"`);
 		applyShapeWhere(target, buildSpawnableEntityTypesWhere({
 			tenantId: options.tenantId,
 			principalUrl: options.principalUrl ?? ``,
@@ -7948,6 +8044,7 @@ const spawnBodySchema = __sinclair_typebox.Type.Object({
 	sandbox: __sinclair_typebox.Type.Optional(sandboxChoiceSchema),
 	initialMessage: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Unknown()),
 	grants: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Array(entityPermissionGrantInputSchema)),
+	initialMessageType: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.String()),
 	wake: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Object({
 		subscriberUrl: __sinclair_typebox.Type.String(),
 		condition: wakeConditionSchema,
@@ -7985,6 +8082,14 @@ function agentUrlPath(value) {
 		return value;
 	}
 }
+async function hasValidAgentWriteToken(request, ctx, fromAgent) {
+	const agentUrl = agentUrlPath(fromAgent);
+	const token = writeTokenFromRequest(request);
+	if (!token) return false;
+	const agentEntity = await ctx.entityManager.registry.getEntity(agentUrl);
+	if (!agentEntity) return false;
+	return ctx.entityManager.isValidWriteToken(agentEntity, token);
+}
 const inboxMessageBodySchema = __sinclair_typebox.Type.Object({
 	payload: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Unknown()),
 	position: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.String()),
@@ -8006,7 +8111,19 @@ const forkBodySchema = __sinclair_typebox.Type.Object({
 	fork_pointer: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Object({
 		offset: __sinclair_typebox.Type.Union([__sinclair_typebox.Type.String(), __sinclair_typebox.Type.Null()]),
 		sub_offset: __sinclair_typebox.Type.Number()
-	}))
+	})),
+	anchor: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Literal(`latest_completed_run`)),
+	parent: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.String()),
+	wake: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Object({
+		subscriberUrl: __sinclair_typebox.Type.String(),
+		condition: wakeConditionSchema,
+		debounceMs: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Number()),
+		timeoutMs: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Number()),
+		includeResponse: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Boolean()),
+		manifestKey: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.String())
+	})),
+	initialMessage: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Unknown()),
+	tags: __sinclair_typebox.Type.Optional(stringRecordSchema$1)
 });
 const setTagBodySchema = __sinclair_typebox.Type.Object({ value: __sinclair_typebox.Type.String() });
 const entitySignalSchema = __sinclair_typebox.Type.Union([
@@ -8393,8 +8510,18 @@ async function forkEntity(request, ctx) {
 	const principalMutationError = rejectPrincipalEntityMutation(request, `forked`);
 	if (principalMutationError) return principalMutationError;
 	const parsed = routeBody(request);
+	if (parsed.fork_pointer && parsed.anchor) return apiError(400, ErrCodeInvalidRequest, `fork_pointer and anchor are mutually exclusive`);
 	const { entityUrl, entity } = requireExistingEntityRoute(request);
 	await assertDispatchPolicyAllowed(ctx, entity.dispatch_policy);
+	if (parsed.parent !== void 0) {
+		const parent = await ctx.entityManager.registry.getEntity(parsed.parent);
+		if (!parent) return apiError(404, ErrCodeNotFound, `Parent entity not found`);
+		if (!await canAccessEntity(ctx, parent, `spawn`, request)) return apiError(401, ErrCodeUnauthorized, `Principal is not allowed to spawn children from ${parent.url}`);
+	}
+	if (parsed.wake !== void 0) {
+		if (parsed.parent === void 0) return apiError(400, ErrCodeInvalidRequest, `wake requires parent (the fork's wake fires to its parent)`);
+		if (parsed.wake.subscriberUrl !== parsed.parent) return apiError(401, ErrCodeUnauthorized, `wake.subscriberUrl must match parent`);
+	}
 	const result = await ctx.entityManager.forkSubtree(entityUrl, {
 		rootInstanceId: parsed.instance_id,
 		waitTimeoutMs: parsed.waitTimeoutMs,
@@ -8402,9 +8529,17 @@ async function forkEntity(request, ctx) {
 		...parsed.fork_pointer && { forkPointer: {
 			offset: parsed.fork_pointer.offset,
 			subOffset: parsed.fork_pointer.sub_offset
-		} }
+		} },
+		...parsed.anchor && { anchor: parsed.anchor },
+		...parsed.parent !== void 0 && { parent: parsed.parent },
+		...parsed.wake !== void 0 && { wake: parsed.wake },
+		...parsed.tags !== void 0 && { tags: parsed.tags }
 	});
 	for (const forkedEntity of result.entities) await linkEntityDispatchSubscription(ctx, forkedEntity);
+	if (parsed.initialMessage !== void 0) await ctx.entityManager.send(result.root.url, {
+		from: parsed.parent ?? ctx.principal.url,
+		payload: parsed.initialMessage
+	});
 	return (0, itty_router.json)({
 		root: toPublicEntity(result.root),
 		entities: result.entities.map((entity$1) => toPublicEntity(entity$1))
@@ -8417,7 +8552,10 @@ async function sendEntity(request, ctx) {
 	if (parsed.from_principal !== void 0 && parsed.from_principal !== principal.url) return apiError(400, ErrCodeInvalidRequest, `Request from_principal must match Electric-Principal`);
 	if (parsed.from_agent !== void 0) {
 		const principalAgentUrl = agentUrlForPrincipal(principal);
-		if (agentUrlPath(parsed.from_agent) !== principalAgentUrl) return apiError(400, ErrCodeInvalidRequest, `Request from_agent must match authenticated agent principal`);
+		const fromAgentUrl = agentUrlPath(parsed.from_agent);
+		const matchesPrincipalAgent = fromAgentUrl === principalAgentUrl;
+		const hasAgentWriteToken = await hasValidAgentWriteToken(request, ctx, parsed.from_agent);
+		if (!matchesPrincipalAgent && !hasAgentWriteToken) return apiError(400, ErrCodeInvalidRequest, `Request from_agent must match authenticated agent principal`);
 	}
 	await ctx.entityManager.ensurePrincipal(principal);
 	const { entityUrl, entity } = requireExistingEntityRoute(request);
@@ -8503,6 +8641,7 @@ async function spawnEntity(request, ctx) {
 		dispatch_policy: dispatchPolicy,
 		sandbox: parsed.sandbox,
 		initialMessage: void 0,
+		initialMessageType: void 0,
 		wake: parsed.wake,
 		created_by: principal.url
 	});
@@ -8521,7 +8660,8 @@ async function spawnEntity(request, ctx) {
 	if (linkBeforeInitialMessage) await linkEntityDispatchSubscription(ctx, entity);
 	if (parsed.initialMessage !== void 0) await ctx.entityManager.send(entity.url, {
 		from: principal.url,
-		payload: parsed.initialMessage
+		payload: parsed.initialMessage,
+		type: parsed.initialMessageType
 	});
 	if (!linkBeforeInitialMessage) await linkEntityDispatchSubscription(ctx, entity);
 	return (0, itty_router.json)({
@@ -8568,6 +8708,21 @@ async function signalEntity(request, ctx) {
 //#region src/routing/entity-types-router.ts
 const jsonObjectSchema = __sinclair_typebox.Type.Record(__sinclair_typebox.Type.String(), __sinclair_typebox.Type.Unknown());
 const schemaMapSchema = __sinclair_typebox.Type.Record(__sinclair_typebox.Type.String(), jsonObjectSchema);
+const slashCommandArgumentSchema = __sinclair_typebox.Type.Object({
+	name: __sinclair_typebox.Type.String(),
+	type: __sinclair_typebox.Type.Union([
+		__sinclair_typebox.Type.Literal(`string`),
+		__sinclair_typebox.Type.Literal(`number`),
+		__sinclair_typebox.Type.Literal(`boolean`)
+	]),
+	required: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Boolean()),
+	description: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.String())
+}, { additionalProperties: false });
+const slashCommandSchema = __sinclair_typebox.Type.Object({
+	name: __sinclair_typebox.Type.String(),
+	description: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.String()),
+	arguments: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Array(slashCommandArgumentSchema))
+}, { additionalProperties: false });
 const typePermissionGrantInputSchema = __sinclair_typebox.Type.Object({
 	subject_kind: __sinclair_typebox.Type.Union([__sinclair_typebox.Type.Literal(`principal`), __sinclair_typebox.Type.Literal(`principal_kind`)]),
 	subject_value: __sinclair_typebox.Type.String(),
@@ -8580,6 +8735,7 @@ const registerEntityTypeBodySchema = __sinclair_typebox.Type.Object({
 	creation_schema: __sinclair_typebox.Type.Optional(jsonObjectSchema),
 	inbox_schemas: __sinclair_typebox.Type.Optional(schemaMapSchema),
 	state_schemas: __sinclair_typebox.Type.Optional(schemaMapSchema),
+	slash_commands: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Array(slashCommandSchema)),
 	serve_endpoint: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.String()),
 	default_dispatch_policy: __sinclair_typebox.Type.Optional(dispatchPolicySchema),
 	permission_grants: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Array(typePermissionGrantInputSchema))
@@ -8721,6 +8877,7 @@ function normalizeEntityTypeRequest(parsed) {
 		creation_schema: parsed.creation_schema,
 		inbox_schemas: parsed.inbox_schemas,
 		state_schemas: parsed.state_schemas,
+		slash_commands: parsed.slash_commands,
 		serve_endpoint: serveEndpoint,
 		default_dispatch_policy: parsed.default_dispatch_policy ?? (serveEndpoint ? { targets: [{
 			type: `webhook`,