Only Hermes cron creation and editing are supported.

Error message

Only Hermes cron creation and editing are supported.

What it means

Thrown by normalizeHermesCronMutationInput() when input.provider is not 'hermes'. The create/edit path currently implements only Hermes cron mutations; any other provider value is rejected before argument building. This is a capability guard, not a runtime/network condition.

Source

Thrown at src/main/automations/external-manager.ts:413

    case 'pause':
      return 'disable'
    case 'resume':
      return 'enable'
    case 'run':
      return 'run'
    case 'delete':
      return 'rm'
  }
}

function normalizeHermesCronMutationInput(input: ExternalAutomationCreateInput): {
  name: string
  prompt: string
  schedule: string
  workdir: string | null
} {
  if (input.provider !== 'hermes') {
    throw new Error('Only Hermes cron creation and editing are supported.')
  }
  const name = input.name.trim()
  const prompt = input.prompt.trim()
  const schedule = input.schedule.trim()
  const workdir = input.workdir?.trim() || null
  if (!prompt) {
    throw new Error('Hermes cron requires a prompt.')
  }
  if (!schedule) {
    throw new Error('Hermes cron requires a schedule.')
  }
  return {
    name: name || prompt.slice(0, 50).trim() || 'Hermes cron',
    prompt,
    schedule,
    workdir
  }
}

View on GitHub (pinned to 1136503c6a)

Solutions

Only invoke create/update with provider: 'hermes'; gate or hide other providers in the UI until they are supported.
If you need another provider, implement and register its normalization/args branch first, then widen this guard.
Validate input.provider against the supported set ('hermes') before calling.

Example fix

// before
createExternalAutomation({ provider: 'openclaw', ... }) // throws

// after
if (input.provider !== 'hermes') {
  throw new UserError('Only Hermes cron automation is supported.')
}
createExternalAutomation({ provider: 'hermes', ... })

Defensive patterns

Strategy: validation

Validate before calling

const SUPPORTED_AUTOMATION_PROVIDERS = ['hermes'] as const

function isSupportedAutomationProvider(p: string): boolean {
  return (SUPPORTED_AUTOMATION_PROVIDERS as readonly string[]).includes(p)
}

if (!isSupportedAutomationProvider(input.provider)) {
  throw new UserError('Only Hermes cron automation is currently supported.')
}
createExternalAutomation(input)

Type guard

type SupportedAutomationProvider = 'hermes'
function isSupportedAutomationProvider(p: unknown): p is SupportedAutomationProvider {
  return p === 'hermes'
}

Try / catch

try {
  await createExternalAutomation(input)
} catch (e) {
  if ((e as Error).message === 'Only Hermes cron creation and editing are supported.') {
    throw new UserError('Only Hermes cron automation is supported right now.')
  }
  throw e
}

Prevention

Restrict the provider picker in the UI to supported values; hide unimplemented providers.
Centralize the supported-provider list in one constant shared by UI and manager.
Widen this guard only after the new provider's normalize/args branch is implemented and tested.

When it happens

Trigger: Calling createExternalAutomation or updateExternalAutomation with provider set to anything other than 'hermes' (e.g. 'openclaw', an empty string, or a typo).

Common situations: A UI dropdown offers multiple providers but only Hermes is wired; a caller forwards a stale/default provider value; OpenClaw support is half-implemented and the create path was reached before its branch existed.

Related errors

AI-assisted analysis of stablyai/orca@1136503c6a (2026-08-12). Data as JSON: /api/errors/19a995d803f4f101. Report an issue: GitHub.