@electric-ax/agents-server 0.4.16 → 0.4.18

package/dist/index.js

@@ -8,7 +8,7 @@ import postgres from "postgres";
 import { and, desc, eq, inArray, lt, ne, sql } from "drizzle-orm";
 import { bigint, bigserial, boolean, check, index, integer, jsonb, pgTable, primaryKey, serial, text, timestamp, unique } from "drizzle-orm/pg-core";
 import { createHash, createPrivateKey, createPublicKey, generateKeyPairSync, randomUUID, sign } from "node:crypto";
-import { appendPathToUrl, assertTags, buildEventSourceManifestEntry, buildTagsIndex, entityStateSchema, eventSourceSubscriptionManifestKey, getCronStreamPath, getCronStreamPathFromSpec, getEntitiesStreamPath, getNextCronFireAt, getSharedStateStreamPath, getWebhookStreamPath, hashString, manifestChildKey, manifestSharedStateKey, manifestSourceKey, normalizeTags, parseCronStreamPath, resolveCronScheduleSpec, resolveEventSourceSubscription, sourceRefForTags, verifyWebhookSignature } from "@electric-ax/agents-runtime";
+import { COMPOSER_INPUT_MESSAGE_TYPE, appendPathToUrl, assertTags, buildEventSourceManifestEntry, buildTagsIndex, entityStateSchema, eventSourceSubscriptionManifestKey, getCronStreamPath, getCronStreamPathFromSpec, getEntitiesStreamPath, getNextCronFireAt, getSharedStateStreamPath, getWebhookStreamPath, hashString, manifestChildKey, manifestSharedStateKey, manifestSourceKey, normalizeTags, parseCronStreamPath, resolveCronScheduleSpec, resolveEventSourceSubscription, sourceRefForTags, validateComposerInputPayload, validateSlashCommandDefinitions, verifyWebhookSignature } from "@electric-ax/agents-runtime";
 import { DurableStream, DurableStreamError, FetchError, IdempotentProducer } from "@durable-streams/client";
 import { ShapeStream, isChangeMessage, isControlMessage } from "@electric-sql/client";
 import pino from "pino";
@@ -49,6 +49,7 @@ const entityTypes = pgTable(`entity_types`, {
 	creationSchema: jsonb(`creation_schema`),
 	inboxSchemas: jsonb(`inbox_schemas`),
 	stateSchemas: jsonb(`state_schemas`),
+	slashCommands: jsonb(`slash_commands`),
 	serveEndpoint: text(`serve_endpoint`),
 	defaultDispatchPolicy: jsonb(`default_dispatch_policy`),
 	revision: integer(`revision`).notNull().default(1),
@@ -820,6 +821,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,
@@ -832,6 +834,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,
@@ -849,6 +852,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,
@@ -875,6 +879,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,
@@ -1465,6 +1470,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,
@@ -3358,6 +3364,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();
@@ -3367,6 +3374,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,
@@ -3528,6 +3536,18 @@ var EntityManager = class {
 			}
 		});
 		const initialEvents = [createdEvent];
+		const slashCommandTimestamp = new Date().toISOString();
+		for (const command of entityType.slash_commands ?? []) {
+			const slashCommandEvent = 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 = entityStateSchema.inbox.insert({
@@ -3535,6 +3555,7 @@ var EntityManager = class {
 				value: {
 					from: req.created_by ?? req.parent ?? `spawn`,
 					payload: req.initialMessage,
+					message_type: req.initialMessageType,
 					timestamp: msgNow
 				}
 			});
@@ -3614,9 +3635,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);
@@ -3625,10 +3647,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();
@@ -3641,7 +3666,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);
 			}
@@ -3666,6 +3691,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) => getSharedStateStreamPath(id)), writeStreamLocks);
 			const createdStreams = [];
@@ -3674,7 +3707,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) {
@@ -3701,6 +3734,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);
@@ -3861,6 +3908,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
@@ -4980,7 +5066,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
@@ -5034,11 +5122,19 @@ var EntityManager = class {
 			throw new ElectricAgentsError(ErrCodeInvalidRequest, error instanceof Error ? error.message : `Invalid tags`, 400);
 		}
 	}
+	validateSlashCommands(input) {
+		const validationError = 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 === COMPOSER_INPUT_MESSAGE_TYPE) {
+			const valErr = 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];
@@ -7111,7 +7207,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 ?? ``,
@@ -7919,6 +8015,7 @@ const spawnBodySchema = Type.Object({
 	sandbox: Type.Optional(sandboxChoiceSchema),
 	initialMessage: Type.Optional(Type.Unknown()),
 	grants: Type.Optional(Type.Array(entityPermissionGrantInputSchema)),
+	initialMessageType: Type.Optional(Type.String()),
 	wake: Type.Optional(Type.Object({
 		subscriberUrl: Type.String(),
 		condition: wakeConditionSchema,
@@ -7956,6 +8053,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 = Type.Object({
 	payload: Type.Optional(Type.Unknown()),
 	position: Type.Optional(Type.String()),
@@ -7977,7 +8082,19 @@ const forkBodySchema = Type.Object({
 	fork_pointer: Type.Optional(Type.Object({
 		offset: Type.Union([Type.String(), Type.Null()]),
 		sub_offset: Type.Number()
-	}))
+	})),
+	anchor: Type.Optional(Type.Literal(`latest_completed_run`)),
+	parent: Type.Optional(Type.String()),
+	wake: Type.Optional(Type.Object({
+		subscriberUrl: Type.String(),
+		condition: wakeConditionSchema,
+		debounceMs: Type.Optional(Type.Number()),
+		timeoutMs: Type.Optional(Type.Number()),
+		includeResponse: Type.Optional(Type.Boolean()),
+		manifestKey: Type.Optional(Type.String())
+	})),
+	initialMessage: Type.Optional(Type.Unknown()),
+	tags: Type.Optional(stringRecordSchema$1)
 });
 const setTagBodySchema = Type.Object({ value: Type.String() });
 const entitySignalSchema = Type.Union([
@@ -8364,8 +8481,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,
@@ -8373,9 +8500,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 json({
 		root: toPublicEntity(result.root),
 		entities: result.entities.map((entity$1) => toPublicEntity(entity$1))
@@ -8388,7 +8523,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);
@@ -8474,6 +8612,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
 	});
@@ -8492,7 +8631,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 json({
@@ -8539,6 +8679,21 @@ async function signalEntity(request, ctx) {
 //#region src/routing/entity-types-router.ts
 const jsonObjectSchema = Type.Record(Type.String(), Type.Unknown());
 const schemaMapSchema = Type.Record(Type.String(), jsonObjectSchema);
+const slashCommandArgumentSchema = Type.Object({
+	name: Type.String(),
+	type: Type.Union([
+		Type.Literal(`string`),
+		Type.Literal(`number`),
+		Type.Literal(`boolean`)
+	]),
+	required: Type.Optional(Type.Boolean()),
+	description: Type.Optional(Type.String())
+}, { additionalProperties: false });
+const slashCommandSchema = Type.Object({
+	name: Type.String(),
+	description: Type.Optional(Type.String()),
+	arguments: Type.Optional(Type.Array(slashCommandArgumentSchema))
+}, { additionalProperties: false });
 const typePermissionGrantInputSchema = Type.Object({
 	subject_kind: Type.Union([Type.Literal(`principal`), Type.Literal(`principal_kind`)]),
 	subject_value: Type.String(),
@@ -8551,6 +8706,7 @@ const registerEntityTypeBodySchema = Type.Object({
 	creation_schema: Type.Optional(jsonObjectSchema),
 	inbox_schemas: Type.Optional(schemaMapSchema),
 	state_schemas: Type.Optional(schemaMapSchema),
+	slash_commands: Type.Optional(Type.Array(slashCommandSchema)),
 	serve_endpoint: Type.Optional(Type.String()),
 	default_dispatch_policy: Type.Optional(dispatchPolicySchema),
 	permission_grants: Type.Optional(Type.Array(typePermissionGrantInputSchema))
@@ -8692,6 +8848,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`,

package/drizzle/0014_entity_type_slash_commands.sql

@@ -0,0 +1 @@
+ALTER TABLE "entity_types" ADD COLUMN "slash_commands" jsonb;

package/drizzle/meta/_journal.json

@@ -99,6 +99,13 @@
       "when": 1780588695000,
       "tag": "0013_worker_user_manage_permission",
       "breakpoints": true
+    },
+    {
+      "idx": 14,
+      "version": "7",
+      "when": 1780600000000,
+      "tag": "0014_entity_type_slash_commands",
+      "breakpoints": true
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@electric-ax/agents-server",
-  "version": "0.4.16",
+  "version": "0.4.18",
   "description": "Electric Agents entity runtime server",
   "author": "Durable Stream contributors",
   "bin": {
@@ -54,7 +54,7 @@
     "pino-pretty": "^13.0.0",
     "postgres": "^3.4.0",
     "undici": "^7.24.7",
-    "@electric-ax/agents-runtime": "0.3.9"
+    "@electric-ax/agents-runtime": "0.3.11"
   },
   "devDependencies": {
     "@types/node": "^22.19.15",
@@ -65,9 +65,9 @@
     "tsx": "^4.19.0",
     "typescript": "^5.0.0",
     "vitest": "^4.1.0",
-    "@electric-ax/agents": "0.4.13",
-    "@electric-ax/agents-server-conformance-tests": "0.1.11",
-    "@electric-ax/agents-server-ui": "0.4.16"
+    "@electric-ax/agents-server-ui": "0.4.18",
+    "@electric-ax/agents": "0.4.15",
+    "@electric-ax/agents-server-conformance-tests": "0.1.11"
   },
   "files": [
     "dist",

package/src/db/schema.ts

@@ -24,6 +24,7 @@ export const entityTypes = pgTable(
     creationSchema: jsonb(`creation_schema`),
     inboxSchemas: jsonb(`inbox_schemas`),
     stateSchemas: jsonb(`state_schemas`),
+    slashCommands: jsonb(`slash_commands`),
     serveEndpoint: text(`serve_endpoint`),
     defaultDispatchPolicy: jsonb(`default_dispatch_policy`),
     revision: integer(`revision`).notNull().default(1),

package/src/electric-agents-types.ts

@@ -4,6 +4,7 @@
 
 import type {
   PullWakeRunnerHealth,
+  SlashCommandDefinition,
   WebhookNotification,
 } from '@electric-ax/agents-runtime'
 import type { Principal } from './principal.js'
@@ -499,6 +500,7 @@ export interface ElectricAgentsEntityType {
   creation_schema?: Record<string, unknown>
   inbox_schemas?: Record<string, Record<string, unknown>>
   state_schemas?: Record<string, Record<string, unknown>>
+  slash_commands?: Array<SlashCommandDefinition>
   serve_endpoint?: string
   default_dispatch_policy?: DispatchPolicy
   revision: number
@@ -512,6 +514,7 @@ export interface RegisterEntityTypeRequest {
   creation_schema?: Record<string, unknown>
   inbox_schemas?: Record<string, Record<string, unknown>>
   state_schemas?: Record<string, Record<string, unknown>>
+  slash_commands?: Array<SlashCommandDefinition>
   serve_endpoint?: string
   default_dispatch_policy?: DispatchPolicy
   permission_grants?: Array<EntityTypePermissionGrantInput>
@@ -530,6 +533,7 @@ export interface TypedSpawnRequest {
    */
   sandbox?: SandboxChoice
   initialMessage?: unknown
+  initialMessageType?: string
   created_by?: string
   wake?: {
     subscriberUrl: string