@electric-ax/agents-server 0.4.16 → 0.4.18

package/src/entity-manager.ts

@@ -1,6 +1,7 @@
 import { createHash, randomUUID } from 'node:crypto'
 import fastq from 'fastq'
 import {
+  COMPOSER_INPUT_MESSAGE_TYPE,
   assertTags,
   entityStateSchema,
   getCronStreamPath,
@@ -11,6 +12,8 @@ import {
   manifestSharedStateKey,
   manifestSourceKey,
   resolveCronScheduleSpec,
+  validateComposerInputPayload,
+  validateSlashCommandDefinitions,
 } from '@electric-ax/agents-runtime'
 import type { EventPointer } from '@electric-ax/agents-runtime'
 import {
@@ -172,6 +175,38 @@ type ForkSubtreeOptions = {
    * `main` stream; shared-state streams clone at HEAD regardless.
    */
   forkPointer?: EventPointer
+  /**
+   * Named server-resolved anchor. Resolves to a concrete `forkPointer`
+   * by reading the source root's `main` history. Mutually exclusive with
+   * `forkPointer`. Use this when the caller doesn't have access to the
+   * source's per-row pointer side-table (e.g. an agent forking a session
+   * via a tool).
+   *
+   * - `latest_completed_run` — the most recent `runs` row on the source
+   *   with `status === 'completed'`. Errors if no such row exists. This
+   *   is the eligibility rule the per-row "Fork from here" UI uses.
+   */
+  anchor?: `latest_completed_run`
+  /**
+   * Optional parent URL for the new root fork entity. When set, the
+   * new fork is a CHILD of this URL — its `parent` field is overridden
+   * (rather than inherited from the source, which is `null` for the
+   * only allowed source: a top-level entity). Pairs with `wake` to give
+   * the parent reply-delivery the same way spawn does.
+   */
+  parent?: string
+  /**
+   * Optional wake subscription registered on the new root fork at fork
+   * time. Same shape and semantics as `spawn`'s `wake` (see
+   * `TypedSpawnRequest.wake`). Typically set by the agent `fork` tool
+   * to wire reply delivery via the parent's manifest-anchored wake.
+   */
+  wake?: TypedSpawnRequest[`wake`]
+  /**
+   * Optional tags stamped onto the new root fork entity in addition
+   * to those copied from the source. Mirrors `spawn`'s `tags`.
+   */
+  tags?: Record<string, string>
 }
 
 type ForkEntityPlan = {
@@ -430,6 +465,7 @@ export class EntityManager {
     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`,
@@ -444,6 +480,7 @@ export class EntityManager {
       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,
@@ -735,6 +772,19 @@ export class EntityManager {
       createdEvent as Record<string, unknown>,
     ]
 
+    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,
+        },
+      } as any)
+      initialEvents.push(slashCommandEvent as Record<string, unknown>)
+    }
+
     if (req.initialMessage !== undefined) {
       const msgNow = new Date().toISOString()
       const inboxEvent = entityStateSchema.inbox.insert({
@@ -742,6 +792,7 @@ export class EntityManager {
         value: {
           from: req.created_by ?? req.parent ?? `spawn`,
           payload: req.initialMessage,
+          message_type: req.initialMessageType,
           timestamp: msgNow,
         },
       } as any)
@@ -890,6 +941,13 @@ export class EntityManager {
     const writeEntityLocks = new Set<string>()
     const writeStreamLocks = new Set<string>()
 
+    // Anchor-forks resolve to a concrete pointer server-side by reading the
+    // source's `main` history. Below this point the resolved pointer (or
+    // an explicit one from `opts.forkPointer`) drives the same code path —
+    // anchor handling collapses entirely into the pointer-fork flow.
+    const usePointerPath =
+      opts.forkPointer !== undefined || opts.anchor !== undefined
+
     try {
       // For pointer-forks we read the source root HISTORICALLY at a
       // frozen offset, so concurrent activity on the root past the
@@ -901,7 +959,7 @@ export class EntityManager {
       // those are HEAD-cloned and need a stable snapshot. For HEAD-forks
       // the old all-idle requirement still applies.
       let sourceTree: Array<ElectricAgentsEntity>
-      if (opts.forkPointer) {
+      if (usePointerPath) {
         const rootEntity = await this.registry.getEntity(rootUrl)
         if (!rootEntity) {
           throw new ElectricAgentsError(
@@ -930,11 +988,11 @@ export class EntityManager {
         )
       }
 
-      // When forking at a pointer, pre-read the root's main, validate the
-      // pointer against the source's true history, and materialise the
-      // root-at-pointer snapshot fragments. The pointer only applies to
-      // the root's `main` stream. Descendants kept by the manifest filter
-      // are forked at HEAD.
+      // When forking at a pointer (or anchor), pre-read the root's main,
+      // validate the pointer against the source's true history, and
+      // materialise the root-at-pointer snapshot fragments. The pointer
+      // only applies to the root's `main` stream. Descendants kept by
+      // the manifest filter are forked at HEAD.
       //
       // Pointer→position translation: the runtime mints pointers as
       // `{ offset: previousBatchOffset, subOffset: itemIndex+1 }`, where
@@ -953,16 +1011,32 @@ export class EntityManager {
             sharedStateIds: Set<string>
           }
         | undefined
-      if (opts.forkPointer) {
+      let effectiveForkPointer: EventPointer | undefined = opts.forkPointer
+      if (usePointerPath) {
         const sourceEvents = await this.streamClient.readJson<
           Record<string, unknown>
         >(sourceRoot.streams.main)
         const flat = sourceEvents.flatMap((item) =>
           Array.isArray(item) ? item : [item]
         ) as Array<Record<string, unknown>>
+        if (!effectiveForkPointer && opts.anchor === `latest_completed_run`) {
+          effectiveForkPointer = this.resolveLatestCompletedRunPointer(
+            flat,
+            sourceRoot.streams.main
+          )
+        }
+        if (!effectiveForkPointer) {
+          // Defensive — would only fire on a future anchor variant we
+          // forget to handle above.
+          throw new ElectricAgentsError(
+            ErrCodeInvalidRequest,
+            `Internal: pointer-path fork with no resolved pointer`,
+            500
+          )
+        }
         const target = this.resolveForkPointerTarget(
           flat,
-          opts.forkPointer,
+          effectiveForkPointer,
           sourceRoot.streams.main
         )
         const filteredEvents = flat.slice(0, target)
@@ -994,7 +1068,7 @@ export class EntityManager {
       // subtree except the root) are HEAD-cloned, so they must be idle
       // before we read their snapshots. Wait+lock only those — the root
       // was skipped above.
-      if (opts.forkPointer) {
+      if (usePointerPath) {
         const descendants = effectiveSubtree.filter(
           (entity) => entity.url !== sourceRoot.url
         )
@@ -1047,6 +1121,28 @@ export class EntityManager {
         opts.createdBy
       )
 
+      // Override fields on the new root fork's plan from caller opts.
+      // Plumbed through from `forkBodySchema` — descendants in
+      // `effectiveSubtree` keep what `buildForkEntityPlans` copied.
+      //
+      // - `parent`: child-fork relationship (vs the default inheritance
+      //   from the source, which is `null` for a top-level source).
+      // - `tags`: merged on top of source tags (caller-supplied wins).
+      const rootPlanForOverrides = entityPlans.find(
+        (plan) => plan.source.url === rootUrl
+      )
+      if (rootPlanForOverrides) {
+        if (opts.parent !== undefined) {
+          rootPlanForOverrides.fork.parent = opts.parent
+        }
+        if (opts.tags !== undefined) {
+          rootPlanForOverrides.fork.tags = {
+            ...(rootPlanForOverrides.fork.tags ?? {}),
+            ...opts.tags,
+          }
+        }
+      }
+
       this.addForkLocks(
         this.forkWriteLockedEntities,
         effectiveSubtree.map((entity) => entity.url),
@@ -1071,8 +1167,8 @@ export class EntityManager {
           await this.streamClient.fork(
             plan.fork.streams.main,
             plan.source.streams.main,
-            isRoot && opts.forkPointer
-              ? { forkPointer: opts.forkPointer }
+            isRoot && effectiveForkPointer
+              ? { forkPointer: effectiveForkPointer }
               : undefined
           )
           createdStreams.push(plan.fork.streams.main)
@@ -1127,6 +1223,30 @@ export class EntityManager {
           createdEntities.push(plan.fork.url)
         }
 
+        // Register a wake subscription on the new root fork when the
+        // caller asked for one. Mirrors the spawn flow's wake handling
+        // (entity-manager.spawnInner). Rollback below already calls
+        // `wakeRegistry.unregisterBySource(forkUrl)` for every created
+        // entity, so this cleans up automatically on failure.
+        if (opts.wake !== undefined) {
+          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()
@@ -1442,6 +1562,58 @@ export class EntityManager {
     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.
+   */
+  private resolveLatestCompletedRunPointer(
+    events: ReadonlyArray<Record<string, unknown>>,
+    streamPath: string
+  ): EventPointer {
+    let priorEntryOffset: string | null = null
+    let currentEntryOffset: string | null = null
+    let positionInEntry = 0
+    let latest: EventPointer | null = null
+
+    for (const event of events) {
+      const headers = isRecord(event.headers) ? event.headers : undefined
+      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
@@ -3512,7 +3684,9 @@ export class EntityManager {
       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,
@@ -3601,6 +3775,20 @@ export class EntityManager {
     }
   }
 
+  private validateSlashCommands(input: unknown): void {
+    const validationError = validateSlashCommandDefinitions(input)
+    if (!validationError) {
+      return
+    }
+
+    throw new ElectricAgentsError(
+      ErrCodeSchemaValidationFailed,
+      validationError.message,
+      422,
+      validationError.details
+    )
+  }
+
   private async validateSendRequest(
     entityUrl: string,
     req: SendRequest
@@ -3617,7 +3805,17 @@ export class EntityManager {
       )
     }
 
-    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]

package/src/entity-registry.ts

@@ -633,6 +633,7 @@ export class PostgresRegistry {
         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,
@@ -646,6 +647,7 @@ export class PostgresRegistry {
           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,
@@ -668,6 +670,7 @@ export class PostgresRegistry {
         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,
@@ -709,6 +712,7 @@ export class PostgresRegistry {
         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,
@@ -1829,6 +1833,9 @@ export class PostgresRegistry {
       state_schemas: row.stateSchemas as
         | Record<string, Record<string, unknown>>
         | undefined,
+      slash_commands:
+        (row.slashCommands as ElectricAgentsEntityType[`slash_commands`]) ??
+        undefined,
       serve_endpoint: row.serveEndpoint ?? undefined,
       default_dispatch_policy:
         (row.defaultDispatchPolicy as ElectricAgentsEntityType[`default_dispatch_policy`]) ??

package/src/routing/entities-router.ts

@@ -135,6 +135,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(),
@@ -186,6 +187,19 @@ function agentUrlPath(value: string): string {
   }
 }
 
+async function hasValidAgentWriteToken(
+  request: AgentsRouteRequest,
+  ctx: TenantContext,
+  fromAgent: string
+): Promise<boolean> {
+  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()),
@@ -218,6 +232,41 @@ const forkBodySchema = Type.Object({
       sub_offset: Type.Number(),
     })
   ),
+  // Named server-resolved anchor. Resolves to a concrete fork pointer on
+  // the source root's `main` server-side, so callers don't need access
+  // to the source's per-row pointer side-table. Mutually exclusive with
+  // `fork_pointer`.
+  anchor: Type.Optional(Type.Literal(`latest_completed_run`)),
+  // Optional parent URL. When set, the new root fork is a CHILD of this
+  // URL (rather than inheriting the source's parent, which is `null`
+  // for the only allowed source — a top-level entity). Used by the
+  // agent `fork` tool to make a forking entity own its forks the same
+  // way a spawning entity owns its workers.
+  parent: Type.Optional(Type.String()),
+  // Optional wake subscription registered on the new root fork at fork
+  // time. Mirrors the `wake` field on spawn — the subscriber URL gets
+  // woken when the fork meets the named condition, with the response
+  // optionally inlined. Used to wire fork-as-child reply delivery
+  // through the same manifest-anchored mechanism spawn uses.
+  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()),
+    })
+  ),
+  // Optional initial inbox message for the new root fork. Folds
+  // fork+send into one round-trip for the caller. Not atomic with
+  // fork creation: the server sends it after the fork is created
+  // and dispatch-linked (see the `entityManager.send` call below),
+  // so a failed send can leave an idle dispatched fork.
+  initialMessage: Type.Optional(Type.Unknown()),
+  // Optional tags stamped on the new root fork entity in addition to
+  // those copied from the source. Mirrors spawn's `tags`.
+  tags: Type.Optional(stringRecordSchema),
 })
 
 const setTagBodySchema = Type.Object({
@@ -1087,8 +1136,57 @@ async function forkEntity(
   if (principalMutationError) return principalMutationError
 
   const parsed = routeBody<ForkBody>(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)
+
+  // Validate `parent` and `wake.subscriberUrl` before forking — mirrors
+  // the spawn route's parent-validation flow. Without these checks, a
+  // direct HTTP caller could attach a fork under an arbitrary parent or
+  // register a wake firing to an arbitrary subscriber.
+  if (parsed.parent !== undefined) {
+    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 as Request))) {
+      return apiError(
+        401,
+        ErrCodeUnauthorized,
+        `Principal is not allowed to spawn children from ${parent.url}`
+      )
+    }
+  }
+  if (parsed.wake !== undefined) {
+    // The only sensible target for a fork's wake is the new fork's
+    // parent (so the parent gets woken when the fork's run finishes
+    // — same model as spawn). Require parent + matching subscriber to
+    // prevent a caller from registering a wake firing to an entity
+    // they don't own. If subscriber-flexibility ever becomes a real
+    // use case, replace this with a proper canAccessEntity check on
+    // the subscriber.
+    if (parsed.parent === undefined) {
+      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,
@@ -1099,10 +1197,24 @@ async function forkEntity(
         subOffset: parsed.fork_pointer.sub_offset,
       },
     }),
+    ...(parsed.anchor && { anchor: parsed.anchor }),
+    ...(parsed.parent !== undefined && { parent: parsed.parent }),
+    ...(parsed.wake !== undefined && { wake: parsed.wake }),
+    ...(parsed.tags !== undefined && { tags: parsed.tags }),
   })
   for (const forkedEntity of result.entities) {
     await linkEntityDispatchSubscription(ctx, forkedEntity)
   }
+  // Deliver the initial message via entityManager.send AFTER the
+  // dispatch subscription is linked — same ordering spawn uses. Sending
+  // before linking would land the inbox row on the stream before the
+  // dispatcher is subscribed, and the dispatcher would never pick it up.
+  if (parsed.initialMessage !== undefined) {
+    await ctx.entityManager.send(result.root.url, {
+      from: parsed.parent ?? ctx.principal.url,
+      payload: parsed.initialMessage,
+    })
+  }
   return json(
     {
       root: toPublicEntity(result.root),
@@ -1137,7 +1249,14 @@ async function sendEntity(
   }
   if (parsed.from_agent !== undefined) {
     const principalAgentUrl = agentUrlForPrincipal(principal)
-    if (agentUrlPath(parsed.from_agent) !== principalAgentUrl) {
+    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,
@@ -1293,6 +1412,7 @@ async function spawnEntity(
     dispatch_policy: dispatchPolicy,
     sandbox: parsed.sandbox,
     initialMessage: undefined,
+    initialMessageType: undefined,
     wake: parsed.wake,
     created_by: principal.url,
   })
@@ -1325,6 +1445,7 @@ async function spawnEntity(
     await ctx.entityManager.send(entity.url, {
       from: principal.url,
       payload: parsed.initialMessage,
+      type: parsed.initialMessageType,
     })
   }
   if (!linkBeforeInitialMessage) {

package/src/routing/entity-types-router.ts

@@ -45,6 +45,27 @@ type PublicEntityTypeResponse = ElectricAgentsEntityType & {
 
 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(
   {
@@ -66,6 +87,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(
@@ -433,6 +455,7 @@ function normalizeEntityTypeRequest(
     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 ??

package/src/utils/server-utils.ts

@@ -135,7 +135,7 @@ export function buildElectricProxyTarget(options: {
   } 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"`
+      `"tenant_id","name","description","creation_schema","inbox_schemas","state_schemas","slash_commands","serve_endpoint","default_dispatch_policy","revision","created_at","updated_at"`
     )
     applyShapeWhere(
       target,