@meistrari/agent-core 0.0.0

package/README.md

@@ -0,0 +1,26 @@
+# @meistrari/agent-core
+
+Shared contracts and runtime modules for Tela coding-agent sandboxes.
+
+| Subpath | What it is |
+| --- | --- |
+| `@meistrari/agent-core/protocol` | Provider-neutral agent commands, events, content, tools, usage, work items (Claude and Codex share it). |
+| `@meistrari/agent-core/supervisor-protocol/*` | Strict wire contracts between a worker runtime and the resident sandbox supervisor: bootstrap, commands, events, reverse RPC, control authority. |
+| `@meistrari/agent-core/errors`, `/logger`, `/provenance` | Shared primitives. |
+| `@meistrari/agent-core/supervisor` | Sandbox-resident supervisor runtime (Bun, SQLite). |
+| `@meistrari/agent-core/worker-runtime-client` | Control-plane WSS client: leases, generation fencing, command pump, durable event acking, reverse RPC dispatch. |
+| `@meistrari/agent-core/claude`, `/codex` | Harness adapters. |
+
+The package ships TypeScript source and targets Bun `>=1.3.10`. There is no wire protocol version: a sandbox keeps the exact agent-core build it was created with for its lifetime (immutable sandbox invariant). Incompatible wire changes require reprovisioning sandboxes, never in-place upgrades.
+
+## Development
+
+```bash
+bun install
+bun run lint
+bun run typecheck
+bun run test        # unit tests (src/**/*.test.ts)
+bun run test:e2e    # loopback worker <-> supervisor e2e
+```
+
+Publishing runs from `main` through `.github/workflows/publish.yml` (conventional commits decide the bump).

package/package.json

@@ -0,0 +1,69 @@
+{
+    "name": "@meistrari/agent-core",
+    "type": "module",
+    "version": "0.0.0",
+    "packageManager": "bun@1.3.12",
+    "description": "Shared contracts and runtime modules for Tela coding-agent sandboxes: agent protocol, supervisor wire protocol, resident supervisor, worker runtime client, and Claude/Codex harness adapters.",
+    "license": "UNLICENSED",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/meistrari/agent-core.git"
+    },
+    "publishConfig": {
+        "access": "public",
+        "registry": "https://registry.npmjs.org"
+    },
+    "exports": {
+        "./errors": "./src/errors/index.ts",
+        "./errors/application-error": "./src/errors/application-error.ts",
+        "./logger": "./src/logger/index.ts",
+        "./provenance": "./src/provenance.ts",
+        "./protocol": "./src/protocol/index.ts",
+        "./protocol/agent-content": "./src/protocol/agent-content.ts",
+        "./protocol/agent-tool-name": "./src/protocol/agent-tool-name.ts",
+        "./protocol/agent-work": "./src/protocol/agent-work.ts",
+        "./supervisor-protocol/agent-event-wrapper": "./src/supervisor-protocol/agent-event-wrapper.ts",
+        "./supervisor-protocol/bootstrap": "./src/supervisor-protocol/bootstrap.ts",
+        "./supervisor-protocol/bootstrap-rejection-receipt": "./src/supervisor-protocol/bootstrap-rejection-receipt.ts",
+        "./supervisor-protocol/command-body": "./src/supervisor-protocol/command-body.ts",
+        "./supervisor-protocol/control-authority": "./src/supervisor-protocol/control-authority.ts",
+        "./supervisor-protocol/context-file-content": "./src/supervisor-protocol/context-file-content.ts",
+        "./supervisor-protocol/durability": "./src/supervisor-protocol/durability.ts",
+        "./supervisor-protocol/envelope": "./src/supervisor-protocol/envelope.ts",
+        "./supervisor-protocol/envelopes/common": "./src/supervisor-protocol/envelopes/common.ts",
+        "./supervisor-protocol/envelopes/control-plane-to-supervisor": "./src/supervisor-protocol/envelopes/control-plane-to-supervisor.ts",
+        "./supervisor-protocol/envelopes/supervisor-to-control-plane": "./src/supervisor-protocol/envelopes/supervisor-to-control-plane.ts",
+        "./supervisor-protocol/event-body": "./src/supervisor-protocol/event-body.ts",
+        "./supervisor-protocol/input-attachment-content": "./src/supervisor-protocol/input-attachment-content.ts",
+        "./supervisor-protocol/payload-overflow": "./src/supervisor-protocol/payload-overflow.ts",
+        "./supervisor-protocol/profile": "./src/supervisor-protocol/profile.ts",
+        "./supervisor-protocol/product-event": "./src/supervisor-protocol/product-event.ts",
+        "./supervisor-protocol/rpc": "./src/supervisor-protocol/rpc.ts",
+        "./supervisor-protocol/supervisor-agent-run-snapshot": "./src/supervisor-protocol/supervisor-agent-run-snapshot.ts",
+        "./supervisor-protocol/supervisor-event": "./src/supervisor-protocol/supervisor-event.ts",
+        "./supervisor-protocol/tela-page-content": "./src/supervisor-protocol/tela-page-content.ts",
+        "./supervisor-protocol/wire-codec": "./src/supervisor-protocol/wire-codec.ts"
+    },
+    "engines": {
+        "bun": ">=1.3.10"
+    },
+    "scripts": {
+        "lint": "eslint .",
+        "lint:fix": "eslint . --fix",
+        "typecheck": "tsc --noEmit",
+        "test": "bun test src/",
+        "test:e2e": "bun test --pass-with-no-tests e2e/",
+        "provenance": "bun scripts/write-provenance.ts",
+        "build": "bun scripts/write-provenance.ts"
+    },
+    "dependencies": {
+        "pino": "^9.7.0",
+        "zod": "^4.1.12"
+    },
+    "devDependencies": {
+        "@antfu/eslint-config": "4.16.2",
+        "@types/bun": "1.3.12",
+        "eslint": "^9.30.0",
+        "typescript": "5.9.3"
+    }
+}

package/scripts/write-provenance.ts

@@ -0,0 +1,74 @@
+#!/usr/bin/env bun
+/**
+ * Writes `src/provenance.gen.ts` with the published version and source sha.
+ *
+ * The publish workflow runs this before packing so every consumer (the sandbox
+ * supervisor, the worker runtime, image builds) can record exactly which
+ * agent-core build it embeds. In development the committed placeholder wins.
+ */
+import { readFile, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+interface Options { version?: string, sha?: string, dryRun: boolean }
+
+function parseArguments(argv: readonly string[]): Options {
+    const options: Options = { dryRun: false }
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index]
+        if (argument === '--version') {
+            options.version = argv[index + 1]
+            index += 1
+        }
+        else if (argument === '--sha') {
+            options.sha = argv[index + 1]
+            index += 1
+        }
+        else if (argument === '--dry-run') {
+            options.dryRun = true
+        }
+        else {
+            throw new Error(`Unknown argument: ${argument}`)
+        }
+    }
+    return options
+}
+
+async function resolveGitSha(): Promise<string> {
+    const process = Bun.spawn(['git', 'rev-parse', 'HEAD'], { stdout: 'pipe', stderr: 'pipe' })
+    const output = (await new Response(process.stdout).text()).trim()
+    const exitCode = await process.exited
+    if (exitCode !== 0 || !/^[0-9a-f]{40}$/u.test(output))
+        throw new Error('Unable to resolve the git HEAD sha; pass --sha explicitly.')
+    return output
+}
+
+async function main(): Promise<void> {
+    const options = parseArguments(Bun.argv.slice(2))
+    const rootDir = join(import.meta.dir, '..')
+    const packageJson = JSON.parse(await readFile(join(rootDir, 'package.json'), 'utf8')) as { version: string }
+    const version = options.version ?? packageJson.version
+    const sha = options.sha ?? await resolveGitSha()
+    if (!/^[0-9a-f]{40}$/u.test(sha))
+        throw new Error(`Invalid source sha: ${sha}`)
+    if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/u.test(version))
+        throw new Error(`Invalid version: ${version}`)
+
+    const content = [
+        '// Generated by scripts/write-provenance.ts. Do not edit by hand.',
+        'export const generatedProvenance = {',
+        `    version: ${JSON.stringify(version)},`,
+        `    sha: ${JSON.stringify(sha)},`,
+        `    buildTime: ${JSON.stringify(new Date().toISOString())},`,
+        '} as const',
+        '',
+    ].join('\n')
+
+    if (options.dryRun) {
+        console.log(content)
+        return
+    }
+    await writeFile(join(rootDir, 'src', 'provenance.gen.ts'), content)
+    console.log(`Wrote src/provenance.gen.ts for ${version}@${sha.slice(0, 12)}`)
+}
+
+await main()

package/src/errors/app-error.ts

@@ -0,0 +1,66 @@
+export type AppErrorCategory = 'application' | 'provider' | 'infrastructure' | 'validation'
+
+export interface AppErrorInput {
+    category: AppErrorCategory
+    code: string
+    message: string
+    publicMessage?: string
+    details?: Record<string, unknown>
+    retryable?: boolean
+    cause?: unknown
+}
+
+export class AppError extends Error {
+    readonly category: AppErrorCategory
+    readonly code: string
+    readonly publicMessage: string
+    readonly details?: Record<string, unknown>
+    readonly retryable: boolean
+    override readonly cause?: unknown
+
+    constructor(input: AppErrorInput) {
+        if (input.cause === undefined)
+            super(input.message)
+        else
+            super(input.message, { cause: input.cause })
+
+        this.name = new.target.name
+        this.category = input.category
+        this.code = input.code
+        this.publicMessage = input.publicMessage ?? input.message
+        this.retryable = input.retryable ?? false
+
+        if (input.details) {
+            this.details = input.details
+        }
+
+        if (input.cause !== undefined) {
+            this.cause = input.cause
+        }
+
+        Error.captureStackTrace?.(this, new.target)
+    }
+
+    toJSON() {
+        return {
+            name: this.name,
+            category: this.category,
+            code: this.code,
+            message: this.message,
+            publicMessage: this.publicMessage,
+            details: this.details,
+            retryable: this.retryable,
+        }
+    }
+
+    getPublicResponseBody() {
+        return {
+            message: this.publicMessage,
+            details: this.details,
+        }
+    }
+}
+
+export function isAppError(error: unknown): error is AppError {
+    return error instanceof AppError
+}

package/src/errors/application-error.ts

@@ -0,0 +1,55 @@
+import type { AppErrorInput } from './app-error'
+import { AppError } from './app-error'
+
+export type ApplicationErrorInput = Omit<AppErrorInput, 'category'>
+
+export class ApplicationError extends AppError {
+    constructor(input: ApplicationErrorInput) {
+        super({
+            ...input,
+            category: 'application',
+        })
+    }
+}
+
+export class RateLimitExceededError extends ApplicationError {
+    readonly retryAfterSeconds: number
+
+    constructor({ retryAfterSeconds, ...input }: Omit<ApplicationErrorInput, 'retryable' | 'details'> & {
+        retryAfterSeconds: number
+    }) {
+        if (!Number.isSafeInteger(retryAfterSeconds) || retryAfterSeconds <= 0)
+            throw new RangeError('retryAfterSeconds must be a positive safe integer')
+
+        super({
+            ...input,
+            retryable: false,
+            details: { retry_after_seconds: retryAfterSeconds },
+        })
+        this.retryAfterSeconds = retryAfterSeconds
+    }
+}
+
+export class NotFoundError extends ApplicationError {
+    constructor(input: ApplicationErrorInput) {
+        super(input)
+    }
+}
+
+export class ConflictError extends ApplicationError {
+    constructor(input: ApplicationErrorInput) {
+        super(input)
+    }
+}
+
+export class ForbiddenError extends ApplicationError {
+    constructor(input: ApplicationErrorInput) {
+        super(input)
+    }
+}
+
+export class UnauthorizedError extends ApplicationError {
+    constructor(input: ApplicationErrorInput) {
+        super(input)
+    }
+}

package/src/errors/index.ts

@@ -0,0 +1,16 @@
+export { AppError, isAppError } from './app-error'
+export type { AppErrorCategory, AppErrorInput } from './app-error'
+export {
+    ApplicationError,
+    ConflictError,
+    ForbiddenError,
+    NotFoundError,
+    UnauthorizedError,
+} from './application-error'
+export type { ApplicationErrorInput } from './application-error'
+export { InfrastructureError } from './infrastructure-error'
+export type { InfrastructureErrorInput } from './infrastructure-error'
+export { ProviderError } from './provider-error'
+export type { ProviderErrorInput } from './provider-error'
+export { UnprocessableEntityError, ValidationError } from './validation-error'
+export type { ValidationErrorInput } from './validation-error'

package/src/errors/infrastructure-error.ts

@@ -0,0 +1,13 @@
+import type { AppErrorInput } from './app-error'
+import { AppError } from './app-error'
+
+export type InfrastructureErrorInput = Omit<AppErrorInput, 'category'>
+
+export class InfrastructureError extends AppError {
+    constructor(input: InfrastructureErrorInput) {
+        super({
+            ...input,
+            category: 'infrastructure',
+        })
+    }
+}

package/src/errors/provider-error.ts

@@ -0,0 +1,13 @@
+import type { AppErrorInput } from './app-error'
+import { AppError } from './app-error'
+
+export type ProviderErrorInput = Omit<AppErrorInput, 'category'>
+
+export class ProviderError extends AppError {
+    constructor(input: ProviderErrorInput) {
+        super({
+            ...input,
+            category: 'provider',
+        })
+    }
+}

package/src/errors/validation-error.ts

@@ -0,0 +1,19 @@
+import type { AppErrorInput } from './app-error'
+import { AppError } from './app-error'
+
+export type ValidationErrorInput = Omit<AppErrorInput, 'category'>
+
+export class ValidationError extends AppError {
+    constructor(input: ValidationErrorInput) {
+        super({
+            ...input,
+            category: 'validation',
+        })
+    }
+}
+
+export class UnprocessableEntityError extends ValidationError {
+    constructor(input: ValidationErrorInput) {
+        super(input)
+    }
+}

package/src/logger/index.ts

@@ -0,0 +1,75 @@
+import type { LoggerOptions, Logger as PinoLogger } from 'pino'
+import pino from 'pino'
+
+/**
+ * Structural logger contract used across agent-core. Pino satisfies it, and so
+ * does any product logger (Datadog-flavoured pino wrappers included), so hosts
+ * inject their own instance and agent-core never owns process-wide logging.
+ */
+export type Logger = PinoLogger<never>
+
+export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal'
+
+interface LoggerBaseFields {
+    readonly [key: string]: string | number | boolean | null | undefined
+}
+
+export interface CreateLoggerInput {
+    level?: LogLevel
+    base?: LoggerBaseFields
+    /** Redirect output (tests, supervisor stderr). Defaults to stdout. */
+    destination?: pino.DestinationStream
+}
+
+type SafeErrorField = 'category' | 'code' | 'publicMessage' | 'retryable' | 'details'
+
+function readErrorField(error: Error, field: SafeErrorField): unknown {
+    return Reflect.get(error, field) as unknown
+}
+
+// Keeps only safe outer fields and never traverses error causes, so a wrapped
+// provider error cannot leak credentials through its cause chain.
+export function serializeError(error: Error) {
+    const category = readErrorField(error, 'category')
+    const code = readErrorField(error, 'code')
+    const publicMessage = readErrorField(error, 'publicMessage')
+    const retryable = readErrorField(error, 'retryable')
+    const details = readErrorField(error, 'details')
+
+    return {
+        type: error.name || error.constructor.name,
+        message: error.message,
+        ...(error.stack ? { stack: error.stack } : {}),
+        ...(typeof category === 'string' ? { category } : {}),
+        ...(typeof code === 'string' ? { code } : {}),
+        ...(typeof publicMessage === 'string' ? { publicMessage } : {}),
+        ...(typeof retryable === 'boolean' ? { retryable } : {}),
+        ...(details ? { details } : {}),
+    }
+}
+
+export function readLogLevelFromEnvironment(environment: Record<string, string | undefined> = process.env): LogLevel {
+    const level = environment.LOG_LEVEL
+    if (level === 'trace' || level === 'debug' || level === 'info' || level === 'warn' || level === 'error' || level === 'fatal')
+        return level
+    return 'info'
+}
+
+export function createLogger(input: CreateLoggerInput = {}): Logger {
+    const options: LoggerOptions<never> = {
+        level: input.level ?? readLogLevelFromEnvironment(),
+        errorKey: 'err',
+        messageKey: 'message',
+        timestamp: pino.stdTimeFunctions.isoTime,
+        serializers: { err: serializeError },
+        formatters: {
+            level: (label: string) => ({ level: label.toUpperCase() }),
+        },
+        ...(input.base ? { base: input.base } : {}),
+    }
+    return input.destination ? pino(options, input.destination) : pino(options)
+}
+
+export function createSilentLogger(): Logger {
+    return pino({ level: 'silent' })
+}

package/src/protocol/agent-command.ts

@@ -0,0 +1,65 @@
+import z from 'zod'
+import { agentPromptSchema } from './agent-content'
+import { agentProviderIdSchema } from './agent-provider'
+import { agentUserInputAnswersSchema } from './agent-user-input'
+
+export const agentReasoningEffortSchema = z.enum(['low', 'medium', 'high', 'xhigh', 'max'])
+export const agentPromptModeSchema = z.enum(['next', 'steer'])
+
+export const agentAuthorSchema = z.object({
+    name: z.string().min(1),
+    email: z.string().min(1).optional(),
+    gitEmail: z.string().min(1).optional(),
+}).strict()
+
+const commandIdSchema = z.string().min(1)
+
+const runningCommandBaseSchema = z.object({
+    provider: agentProviderIdSchema,
+    sessionId: z.string().min(1),
+    providerSessionId: z.string().min(1),
+}).strict()
+
+export const sendPromptCommandSchema = runningCommandBaseSchema.extend({
+    type: z.literal('agent.send-prompt'),
+    mode: agentPromptModeSchema,
+    origin: z.enum(['user', 'supervisor']).default('user'),
+    prompt: agentPromptSchema,
+    commandId: commandIdSchema,
+    author: agentAuthorSchema.optional(),
+}).strict()
+
+export const interruptAgentCommandSchema = runningCommandBaseSchema.extend({
+    type: z.literal('agent.interrupt'),
+    commandId: commandIdSchema,
+    turnId: z.string().min(1).optional(),
+    reason: z.string().min(1).optional(),
+}).strict()
+
+export const stopAgentCommandSchema = runningCommandBaseSchema.extend({
+    type: z.literal('agent.stop'),
+    reason: z.string().min(1).optional(),
+}).strict()
+
+export const respondUserInputAgentCommandSchema = runningCommandBaseSchema.extend({
+    type: z.literal('agent.respond-user-input'),
+    commandId: commandIdSchema,
+    requestId: z.string().min(1),
+    answers: agentUserInputAnswersSchema,
+}).strict()
+
+export const agentCommandSchema = z.union([
+    sendPromptCommandSchema,
+    interruptAgentCommandSchema,
+    stopAgentCommandSchema,
+    respondUserInputAgentCommandSchema,
+])
+
+export type AgentReasoningEffort = z.infer<typeof agentReasoningEffortSchema>
+export type AgentPromptMode = z.infer<typeof agentPromptModeSchema>
+export type AgentAuthor = z.infer<typeof agentAuthorSchema>
+export type SendPromptCommand = z.infer<typeof sendPromptCommandSchema>
+export type InterruptAgentCommand = z.infer<typeof interruptAgentCommandSchema>
+export type StopAgentCommand = z.infer<typeof stopAgentCommandSchema>
+export type RespondUserInputAgentCommand = z.infer<typeof respondUserInputAgentCommandSchema>
+export type AgentCommand = z.infer<typeof agentCommandSchema>

package/src/protocol/agent-content.ts

@@ -0,0 +1,73 @@
+import z from 'zod'
+
+export const textAgentInputBlockSchema = z.object({
+    type: z.literal('text'),
+    text: z.string(),
+}).strict()
+
+export const urlAgentImageSourceSchema = z.object({
+    kind: z.literal('url'),
+    url: z.url(),
+}).strict()
+
+export const base64AgentImageSourceSchema = z.object({
+    kind: z.literal('base64'),
+    data: z.string().min(1),
+    mimeType: z.string().min(1),
+}).strict()
+
+export const agentImageSourceSchema = z.discriminatedUnion('kind', [
+    urlAgentImageSourceSchema,
+    base64AgentImageSourceSchema,
+])
+
+export const imageAgentInputBlockSchema = z.object({
+    type: z.literal('image'),
+    source: agentImageSourceSchema,
+}).strict()
+
+export const textAgentFileSourceSchema = z.object({
+    kind: z.literal('text'),
+    name: z.string().min(1).optional(),
+    text: z.string(),
+    mimeType: z.string().min(1).optional(),
+}).strict()
+
+export const urlAgentFileSourceSchema = z.object({
+    kind: z.literal('url'),
+    url: z.url(),
+    name: z.string().min(1).optional(),
+    mimeType: z.string().min(1).optional(),
+}).strict()
+
+export const agentFileSourceSchema = z.discriminatedUnion('kind', [
+    textAgentFileSourceSchema,
+    urlAgentFileSourceSchema,
+])
+
+export const fileAgentInputBlockSchema = z.object({
+    type: z.literal('file'),
+    source: agentFileSourceSchema,
+}).strict()
+
+export const agentInputBlockSchema = z.discriminatedUnion('type', [
+    textAgentInputBlockSchema,
+    imageAgentInputBlockSchema,
+    fileAgentInputBlockSchema,
+])
+
+export const agentPromptSchema = z.object({
+    blocks: z.array(agentInputBlockSchema).min(1),
+}).strict()
+
+export type TextAgentInputBlock = z.infer<typeof textAgentInputBlockSchema>
+export type UrlAgentImageSource = z.infer<typeof urlAgentImageSourceSchema>
+export type Base64AgentImageSource = z.infer<typeof base64AgentImageSourceSchema>
+export type AgentImageSource = z.infer<typeof agentImageSourceSchema>
+export type ImageAgentInputBlock = z.infer<typeof imageAgentInputBlockSchema>
+export type TextAgentFileSource = z.infer<typeof textAgentFileSourceSchema>
+export type UrlAgentFileSource = z.infer<typeof urlAgentFileSourceSchema>
+export type AgentFileSource = z.infer<typeof agentFileSourceSchema>
+export type FileAgentInputBlock = z.infer<typeof fileAgentInputBlockSchema>
+export type AgentInputBlock = z.infer<typeof agentInputBlockSchema>
+export type AgentPrompt = z.infer<typeof agentPromptSchema>

package/src/protocol/agent-error.ts

@@ -0,0 +1,81 @@
+import type { ApplicationErrorInput, ValidationErrorInput } from '../errors'
+import { ApplicationError, ValidationError } from '../errors'
+
+type AgentProtocolErrorInput = Omit<ApplicationErrorInput, 'code'> & {
+    code?: string
+}
+
+type AgentProtocolValidationErrorInput = Omit<ValidationErrorInput, 'code'> & {
+    code?: string
+}
+
+type AgentProtocolDetails = ValidationErrorInput['details']
+
+interface InvalidAgentCommandErrorInput {
+    message?: string
+    details?: AgentProtocolDetails
+    cause?: unknown
+}
+
+interface InvalidAgentEventErrorInput {
+    message?: string
+    details?: AgentProtocolDetails
+    cause?: unknown
+}
+
+export class AgentProtocolError extends ApplicationError {
+    constructor(input: AgentProtocolErrorInput) {
+        const { code = 'agents-protocol.error', ...rest } = input
+
+        super({
+            ...rest,
+            code,
+        })
+    }
+}
+
+export class AgentProtocolValidationError extends ValidationError {
+    constructor(input: AgentProtocolValidationErrorInput) {
+        const { code = 'agents-protocol.validation-failed', ...rest } = input
+
+        super({
+            ...rest,
+            code,
+        })
+    }
+}
+
+export class UnsupportedAgentProviderError extends AgentProtocolValidationError {
+    constructor({ provider }: { provider: string }) {
+        super({
+            code: 'agents-protocol.unsupported-provider',
+            message: `Unsupported agent provider: ${provider}`,
+            publicMessage: 'Unsupported agent provider.',
+            details: { provider },
+        })
+    }
+}
+
+export class InvalidAgentCommandError extends AgentProtocolValidationError {
+    constructor(input: InvalidAgentCommandErrorInput = {}) {
+        super({
+            code: 'agents-protocol.invalid-command',
+            message: input.message ?? 'Agent command is invalid.',
+            publicMessage: 'Agent command is invalid.',
+            details: input.details,
+            cause: input.cause,
+        })
+    }
+}
+
+export class InvalidAgentEventError extends AgentProtocolValidationError {
+    constructor(input: InvalidAgentEventErrorInput = {}) {
+        super({
+            code: 'agents-protocol.invalid-event',
+            message: input.message ?? 'Agent event is invalid.',
+            publicMessage: 'Agent event is invalid.',
+            details: input.details,
+            cause: input.cause,
+        })
+    }
+}