Write a worker

import express from 'express'
import { randomUUID } from 'node:crypto'
import { A2A_PROTOCOL_VERSION, AGENT_CARD_PATH, TaskState } from '@a2a-js/sdk'
import type { AgentCard } from '@a2a-js/sdk'
import {
  AgentEvent, DefaultRequestHandler, InMemoryTaskStore,
  type AgentExecutor, type ExecutionEventBus, type RequestContext,
} from '@a2a-js/sdk/server'
import { agentCardHandler, jsonRpcHandler, UserBuilder } from '@a2a-js/sdk/server/express'
import { duplicateInterfacesForLegacy } from '@a2a-js/sdk/compat/v0_3'

const port = Number(process.env.PORT ?? 41242)
const url = `http://127.0.0.1:${port}`

const now = () => new Date().toISOString()

class Shout implements AgentExecutor {
  cancelTask = async () => {}

  async execute(ctx: RequestContext, bus: ExecutionEventBus): Promise<void> {
    const { taskId, contextId, userMessage } = ctx
    // The first event is the task itself. The handler answers the caller
    // as soon as it sees it, which is what lets send return at once.
    bus.publish(AgentEvent.task({
      id: taskId, contextId, artifacts: [], history: [userMessage], metadata: undefined,
      status: { state: TaskState.TASK_STATE_SUBMITTED, message: undefined, timestamp: now() },
    }))
    bus.publish(AgentEvent.statusUpdate({
      taskId, contextId, metadata: {},
      status: { state: TaskState.TASK_STATE_WORKING, message: undefined, timestamp: now() },
    }))

    await new Promise(resolve => setTimeout(resolve, 15_000))

    const input = userMessage.parts.map(p => (p.content?.$case === 'text' ? p.content.value : '')).join(' ')
    bus.publish(AgentEvent.artifactUpdate({
      taskId, contextId, append: false, lastChunk: true, metadata: undefined,
      artifact: {
        artifactId: randomUUID(), name: 'result', description: '', metadata: undefined, extensions: [],
        parts: [{ content: { $case: 'text', value: input.toUpperCase() }, metadata: undefined, filename: '', mediaType: 'text/plain' }],
      },
    }))
    bus.publish(AgentEvent.statusUpdate({
      taskId, contextId, metadata: {},
      status: { state: TaskState.TASK_STATE_COMPLETED, message: undefined, timestamp: now() },
    }))
  }
}

const card: AgentCard = {
  name: 'Shout',
  description: 'Shouts your message back after 15 seconds.',
  // Lists the endpoint for A2A 1.0 and again for 0.3, so the mod can use either.
  supportedInterfaces: duplicateInterfacesForLegacy(
    [{ url: `${url}/a2a/jsonrpc`, protocolBinding: 'JSONRPC', tenant: '', protocolVersion: A2A_PROTOCOL_VERSION }],
    ['JSONRPC'],
  ),
  provider: undefined,
  version: '0.1.0',
  capabilities: { streaming: false, pushNotifications: false, extensions: [], extendedAgentCard: false },
  securitySchemes: {}, securityRequirements: [],
  defaultInputModes: ['text'], defaultOutputModes: ['text'],
  skills: [{ id: 'shout', name: 'Shout', description: 'Replies in capitals.', tags: [], examples: ['hello'], inputModes: ['text'], outputModes: ['text'], securityRequirements: [] }],
  signatures: [],
}

const handler = new DefaultRequestHandler(card, new InMemoryTaskStore(), new Shout())
const app = express()
app.use(`/${AGENT_CARD_PATH}`, agentCardHandler({ agentCardProvider: handler, legacyCompat: { enabled: true } }))
app.use('/a2a/jsonrpc', jsonRpcHandler({ requestHandler: handler, userBuilder: UserBuilder.noAuthentication, legacyCompat: { enabled: true } }))
app.listen(port, () => console.log(`shout worker on ${url}`))

node shout-worker.ts

/a2a add http://127.0.0.1:41242 shout