@meistrari/agent-core 0.2.0-experimental.0 → 0.2.0-experimental.2

package/src/agents/codex/lazy-codex-run-auth.ts

@@ -0,0 +1,47 @@
+import type { CodexAuthProvider, CodexAuthRefreshInput, CodexAuthTokenRequest, CodexAuthTokens } from './codex-auth'
+import type { CodexBrowserAuthSource } from './codex-browser-auth-broker'
+import { CodexRunAuth, CodexRunAuthClosedError } from './codex-run-auth'
+
+/**
+ * A `CodexRunAuth` for a run whose own provider is not Codex (Claude Browser Use). The account is
+ * bound only when the first browser connection asks for credentials, so sessions that never use
+ * Browser Use never call `codex.auth.start`. A failed binding is discarded rather than cached, so a
+ * later browser call can bind again once an account is available. Refresh semantics are exactly
+ * those of `CodexRunAuth`.
+ */
+export class LazyCodexRunAuth implements CodexBrowserAuthSource {
+    private current: CodexRunAuth | undefined
+    private closed = false
+
+    constructor(private readonly provider: CodexAuthProvider) {}
+
+    async getCurrentTokens(input: CodexAuthTokenRequest): Promise<CodexAuthTokens> {
+        if (this.closed)
+            throw new CodexRunAuthClosedError()
+        const auth = this.current ??= new CodexRunAuth(this.provider)
+        try {
+            await auth.acquireInitialTokens(input)
+        }
+        catch (error) {
+            if (this.current === auth) {
+                this.current = undefined
+                auth.close()
+            }
+            throw error
+        }
+        return await auth.getCurrentTokens(input)
+    }
+
+    async refreshAuthTokens(input: CodexAuthRefreshInput): Promise<CodexAuthTokens> {
+        const auth = this.current
+        if (this.closed || !auth)
+            throw new CodexRunAuthClosedError()
+        return await auth.refreshAuthTokens(input)
+    }
+
+    close(): void {
+        this.closed = true
+        this.current?.close()
+        this.current = undefined
+    }
+}

package/src/agents/index.ts

@@ -7,8 +7,13 @@ export * from './agent-runtime-error'
 export * from './agent-session-events'
 export * from './agent-tool'
 export * from './agent-tool-runner'
+export * from './input-attachment.errors'
 export * from './instructions'
 export * from './materialized-input-attachment'
 export * from './message-id'
+export * from './sandbox-environment'
+export { sessionContextText, stripSessionContext } from './session-context'
+export type { SessionContextComposer } from './session-context'
+export * from './subscription-token-refresh'
 export * from './tools/ping.tool'
 export * from './user-input-request'

package/src/agents/input-attachment-preparation.ts

@@ -56,6 +56,19 @@ export function nativeAttachmentLabel(attachment: MaterializedAgentInputAttachme
 }
 
 export function filesystemFallbackLabel(attachment: MaterializedAgentInputAttachment): string {
+    if (attachment.mediaType === 'application/gzip' && attachment.filename.endsWith('.tar.gz')) {
+        return `Input attachment (gzip-compressed directory archive):\n${JSON.stringify({
+            attachmentId: attachment.attachmentId,
+            ordinal: attachment.ordinal,
+            filename: attachment.filename,
+            mediaType: attachment.mediaType,
+            byteSize: attachment.byteSize,
+            sha256: attachment.sha256,
+            path: attachment.localPath,
+            archiveFormat: 'tar+gzip',
+            usage: 'Extract or read this archive to access the attached directory files.',
+        })}`
+    }
     return `Input attachment (filesystem fallback):\n${JSON.stringify({
         attachmentId: attachment.attachmentId,
         ordinal: attachment.ordinal,

package/src/agents/mcp-tool-content.ts

@@ -0,0 +1,82 @@
+import type { AgentToolContent, JsonObject, JsonValue } from '../protocol'
+import { agentToolContentSchema, jsonValueSchema } from '../protocol'
+
+export function ownJsonSlot(value: unknown, key: string): JsonValue | undefined {
+    if (typeof value !== 'object' || value === null)
+        return undefined
+    const descriptor = Object.getOwnPropertyDescriptor(value, key)
+    if (!descriptor?.enumerable || !('value' in descriptor) || descriptor.value === undefined)
+        return undefined
+    const parsed = jsonValueSchema.safeParse(descriptor.value)
+    return parsed.success ? parsed.data : undefined
+}
+
+export function mcpToolContent(value: JsonValue): AgentToolContent {
+    const content = publicMcpContent(value)
+    if (!isJsonObject(content))
+        return jsonToolContent(content)
+    const keys = content.type === 'text'
+        ? ['type', 'text']
+        : content.type === 'image' || content.type === 'audio'
+            ? ['type', 'data', 'mimeType']
+            : content.type === 'resource_link'
+                ? ['type', 'name', 'uri', 'mimeType', 'description', 'title', 'size']
+                : content.type === 'resource'
+                    ? ['type', 'resource']
+                    : undefined
+    if (!keys)
+        return jsonToolContent(content)
+    let candidate = withPublicExtras(content, [...keys, 'annotations'])
+    if (content.type === 'resource' && isJsonObject(content.resource)) {
+        candidate = {
+            ...candidate,
+            resource: withPublicExtras(content.resource, [
+                'uri',
+                'mimeType',
+                typeof content.resource.text === 'string' ? 'text' : 'blob',
+            ]),
+        }
+    }
+    const parsed = agentToolContentSchema.safeParse(candidate)
+    return parsed.success ? parsed.data : jsonToolContent(content)
+}
+
+function withPublicExtras(value: JsonObject, knownKeys: string[]): JsonObject {
+    const known = Object.entries(value).filter(([key]) => knownKeys.includes(key))
+    const extra = Object.entries(value).filter(([key]) => !knownKeys.includes(key))
+    return Object.fromEntries(extra.length > 0 ? [...known, ['extras', Object.fromEntries(extra)]] : known)
+}
+
+function publicMcpContent(value: JsonValue): JsonValue {
+    if (!isJsonObject(value))
+        return value
+
+    const entries: Array<[string, JsonValue]> = []
+    for (const key of Object.keys(value)) {
+        if (key === '_meta')
+            continue
+        const entry = value[key]!
+        const publicEntry = key === 'resource' && value.type === 'resource' && isJsonObject(entry)
+            ? jsonObjectWithoutKey(entry, '_meta')
+            : entry
+        entries.push([key, publicEntry])
+    }
+    return Object.fromEntries(entries)
+}
+
+function jsonObjectWithoutKey(value: JsonObject, omittedKey: string): JsonObject {
+    const entries: Array<[string, JsonValue]> = []
+    for (const key of Object.keys(value)) {
+        if (key !== omittedKey)
+            entries.push([key, value[key]!])
+    }
+    return Object.fromEntries(entries)
+}
+
+export function isJsonObject(value: JsonValue | undefined): value is JsonObject {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+export function jsonToolContent(value: JsonValue): AgentToolContent {
+    return { type: 'json', value }
+}

package/src/agents/model-rebinding-run.ts

@@ -1,5 +1,5 @@
 import type { AgentEvent, AgentRunMetadata, SendPromptCommand } from '../protocol'
-import type { AgentOperationOptions } from './agent-operation'
+import type { AgentOperationOptions, AgentPromptOperationOptions } from './agent-operation'
 import type { AgentPromptAcceptance, AgentRun } from './agent-run'
 import { AgentEventStream } from './agent-event-stream'
 import { AgentNotAcceptedError, AgentPromptDeferredError, AgentRunStateError } from './agent-runtime-error'
@@ -44,8 +44,19 @@ export class ModelRebindingRun implements AgentRun {
 
     respondUserInput: AgentRun['respondUserInput'] = async (command, options) => await this.withControl(signal => this.run.respondUserInput(command, { ...options, signal }), options)
     interrupt: AgentRun['interrupt'] = async (command, options) => await this.withControl(signal => this.run.interrupt(command, { ...options, signal }), options)
+    notify: NonNullable<AgentRun['notify']> = async (command, options) => await this.withControl(async (signal) => {
+        if (!this.run.notify)
+            throw new AgentRunStateError({ message: 'The provider run does not support notifications.' })
+        return await this.run.notify(command, { ...options, signal })
+    }, options)
 
-    async sendPrompt(command: SendPromptCommand, options: AgentOperationOptions = {}): Promise<AgentPromptAcceptance> {
+    compactContext: NonNullable<AgentRun['compactContext']> = async (command, options) => await this.withControl(async (signal) => {
+        if (!this.run.compactContext)
+            throw new AgentRunStateError({ message: 'The provider run does not support context compaction.' })
+        return await this.run.compactContext(command, { ...options, signal })
+    }, options)
+
+    async sendPrompt(command: SendPromptCommand, options: AgentPromptOperationOptions = {}): Promise<AgentPromptAcceptance> {
         if (this.dispatching || this.workspaceChanging || this.controls.size)
             throw new AgentPromptDeferredError({ message: 'A prompt admission is already in progress.' })
         const task = this.dispatchPrompt(command, options)
@@ -56,7 +67,7 @@ export class ModelRebindingRun implements AgentRun {
         finally { this.dispatching = undefined }
     }
 
-    private async dispatchPrompt(command: SendPromptCommand, options: AgentOperationOptions): Promise<AgentPromptAcceptance> {
+    private async dispatchPrompt(command: SendPromptCommand, options: AgentPromptOperationOptions): Promise<AgentPromptAcceptance> {
         if (this.stopped)
             throw new AgentRunStateError({ message: 'Cannot send a prompt after the run stopped.' })
         if (command.sessionId !== this.metadata.sessionId || command.providerSessionId !== this.metadata.providerSessionId || command.provider !== this.metadata.provider)

package/src/agents/selected-repository-instructions.ts

@@ -0,0 +1,202 @@
+import type { AgentProviderId } from '../protocol'
+import { randomUUID } from 'node:crypto'
+import { lstat, open, readFile, rename, unlink } from 'node:fs/promises'
+import { basename, dirname, join } from 'node:path'
+import { AgentNotAcceptedError, AgentProviderRuntimeError } from './agent-runtime-error'
+import { stableRepositoryRoots } from './codex/codex-skill-roots'
+
+const managedInstructionsSentinel = '<!-- coding-agent-managed-selected-repository-instructions -->'
+
+// Each provider reads its own repository instruction file first and falls back to AGENTS.md,
+// matching Codex's override precedence and Claude Code's default CLAUDE.md-or-AGENTS.md mode.
+const repositoryInstructionFiles = {
+    codex: { preferred: 'AGENTS.override.md', referencing: 'AGENTS file' },
+    claude: { preferred: 'CLAUDE.md', referencing: 'instruction file' },
+} as const satisfies Record<AgentProviderId, { preferred: string, referencing: string }>
+
+type ManagedFileOwnership = 'missing' | 'managed' | 'unowned'
+
+/**
+ * The runtime-owned discovery guidance each adapter places in its provider's native instruction
+ * file: optional product context, the selected repository roots, and how to find each repository's
+ * own instructions. Deterministic for a given root set. Nothing is published when there is neither
+ * a repository nor product context.
+ */
+export function selectedRepositoryInstructions(input: { provider: AgentProviderId, repositoryRoots: readonly string[], sharedContext?: string }): string | undefined {
+    const files = repositoryInstructionFiles[input.provider]
+    const repositoryRoots = stableRepositoryRoots(input.repositoryRoots)
+    if (repositoryRoots.length === 0 && !input.sharedContext)
+        return undefined
+    const sharedContext = [
+        '# Selected repository instructions',
+        '',
+        ...(input.sharedContext ? [input.sharedContext, ''] : []),
+    ]
+    if (repositoryRoots.length === 0)
+        return sharedContext.join('\n')
+
+    return [
+        ...sharedContext,
+        'Selected repository roots:',
+        ...repositoryRoots.map(root => `- ${JSON.stringify(root)}`),
+        '',
+        'For each repository root, you must:',
+        `- Inspect \`${files.preferred}\` first; if it does not exist, inspect \`AGENTS.md\`.`,
+        `- Follow every documentation file referenced by the applicable ${files.referencing}.`,
+        `- Before editing nested files, re-check for more-local \`${files.preferred}\` or \`AGENTS.md\` files.`,
+        '',
+        'Runtime and developer instructions take precedence over these repository instructions.',
+        'Repository instructions apply only within their own repository.',
+        'If selected repositories contain irreconcilable instructions, report the conflict instead of resolving it by repository input order.',
+        '',
+    ].join('\n')
+}
+
+/**
+ * Publishes the selected-repository instructions at `path`, a file the runtime owns only when its
+ * first line is the managed sentinel. An unowned regular file, symlink, or non-regular entry is
+ * never overwritten: with no selected repository it is left alone, otherwise the operation fails
+ * terminally. Filesystem faults are retryable.
+ */
+export async function reconcileSelectedRepositoryInstructions(input: {
+    provider: AgentProviderId
+    path: string
+    repositoryRoots: readonly string[]
+    sharedContext?: string
+}): Promise<void> {
+    let ownership: ManagedFileOwnership
+    try {
+        ownership = await readManagedFileOwnership(input.path)
+    }
+    catch (error) {
+        if (!(error instanceof AgentProviderRuntimeError))
+            throw error
+        throw repositoryInstructionsUnavailable({ recoveryKind: 'retry', cause: error })
+    }
+
+    const content = selectedRepositoryInstructions(input)
+    if (content === undefined) {
+        // Only a stale managed file is removed; an unowned one is never touched.
+        if (ownership === 'managed')
+            await removeManagedFile(input.path)
+        return
+    }
+
+    if (ownership === 'unowned') {
+        if (input.repositoryRoots.length === 0)
+            return
+        const cause = new AgentProviderRuntimeError({
+            message: `Refusing to overwrite ${basename(input.path)}: it is not owned by the Coding Agent runtime.`,
+            details: { instructionBridgePath: input.path },
+            retryable: false,
+        })
+        throw repositoryInstructionsUnavailable({ recoveryKind: 'terminal', cause })
+    }
+
+    try {
+        await writeManagedFileAtomically({
+            path: input.path,
+            content: `${managedInstructionsSentinel}\n${content}`,
+        })
+    }
+    catch (error) {
+        if (!(error instanceof AgentProviderRuntimeError))
+            throw error
+        throw repositoryInstructionsUnavailable({ recoveryKind: 'retry', cause: error })
+    }
+}
+
+export function repositoryInstructionsUnavailable(input: {
+    recoveryKind: 'retry' | 'terminal'
+    cause: AgentProviderRuntimeError
+}): AgentNotAcceptedError {
+    return new AgentNotAcceptedError({
+        message: 'Selected repository instructions are unavailable.',
+        recovery: { kind: input.recoveryKind, reason: 'repository_instructions_unavailable' },
+        cause: input.cause,
+    })
+}
+
+async function removeManagedFile(path: string): Promise<void> {
+    try {
+        await unlink(path)
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === 'ENOENT')
+            return
+        const cause = new AgentProviderRuntimeError({
+            message: 'Failed to remove the stale selected-repository instruction bridge.',
+            details: { instructionBridgePath: path },
+            retryable: true,
+            cause: error,
+        })
+        throw repositoryInstructionsUnavailable({ recoveryKind: 'retry', cause })
+    }
+}
+
+async function readManagedFileOwnership(path: string): Promise<ManagedFileOwnership> {
+    let entry
+    try {
+        entry = await lstat(path)
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === 'ENOENT')
+            return 'missing'
+        throw new AgentProviderRuntimeError({
+            message: 'Failed to inspect the selected-repository instruction bridge.',
+            details: { instructionBridgePath: path },
+            retryable: true,
+            cause: error,
+        })
+    }
+
+    if (!entry.isFile() || entry.isSymbolicLink())
+        return 'unowned'
+
+    let content: string
+    try {
+        content = await readFile(path, 'utf8')
+    }
+    catch (error) {
+        throw new AgentProviderRuntimeError({
+            message: 'Failed to inspect the selected-repository instruction bridge.',
+            details: { instructionBridgePath: path },
+            retryable: true,
+            cause: error,
+        })
+    }
+
+    return firstLine(content) === managedInstructionsSentinel ? 'managed' : 'unowned'
+}
+
+async function writeManagedFileAtomically(input: { path: string, content: string }): Promise<void> {
+    const tempPath = join(dirname(input.path), `.${basename(input.path)}.${process.pid}.${randomUUID()}.tmp`)
+    let tempFile: Awaited<ReturnType<typeof open>> | undefined
+    try {
+        tempFile = await open(tempPath, 'wx', 0o640)
+        await tempFile.chmod(0o640)
+        await tempFile.writeFile(input.content, 'utf8')
+        await tempFile.close()
+        tempFile = undefined
+        await rename(tempPath, input.path)
+    }
+    catch (error) {
+        await tempFile?.close().catch(() => undefined)
+        await unlink(tempPath).catch(() => undefined)
+        throw new AgentProviderRuntimeError({
+            message: 'Failed to publish the selected-repository instruction bridge.',
+            details: { instructionBridgePath: input.path },
+            retryable: true,
+            cause: error,
+        })
+    }
+}
+
+function firstLine(content: string): string {
+    const lineEnd = content.indexOf('\n')
+    return lineEnd === -1 ? content : content.slice(0, lineEnd)
+}
+
+function isNodeError(error: unknown): error is NodeJS.ErrnoException {
+    return error instanceof Error && 'code' in error
+}

package/src/agents/session-context.ts

@@ -0,0 +1,41 @@
+import { readFile } from 'node:fs/promises'
+
+/** Product text for a session's web page, delivered once inside the session-context block. */
+export type SessionContextComposer = (input: { sessionWebUrl: string }) => string
+
+const openTag = '<coding-agent-session-context>'
+const closeTag = '</coding-agent-session-context>'
+const sessionContextPattern = /^<coding-agent-session-context>[\s\S]*?<\/coding-agent-session-context>\n*/
+
+/**
+ * The per-session paragraph (session page URL and MCP access recovery) is delivered once, in the
+ * session's first user message, instead of the shared instructions, so the instruction block stays
+ * byte-identical across sessions and the provider prompt cache can reuse it.
+ */
+export function sessionContextText(compose: SessionContextComposer, sessionWebUrl: string): string {
+    return `${openTag}\n${compose({ sessionWebUrl })}\n${closeTag}`
+}
+
+/** Removes the leading session-context block from echoed user text. */
+export function stripSessionContext(text: string): string {
+    return text.replace(sessionContextPattern, '')
+}
+
+/**
+ * The session context a run still has to deliver. A new session owes it to its first user message;
+ * a resumed one owes it only when its transcript lacks it (the first message may not have been
+ * delivered before the process stopped).
+ */
+export async function pendingSessionContext(input: {
+    compose: SessionContextComposer | undefined
+    sessionWebUrl: string | undefined
+    resumedTranscriptPath: string | undefined
+}): Promise<string | undefined> {
+    if (!input.compose || !input.sessionWebUrl)
+        return undefined
+    const text = sessionContextText(input.compose, input.sessionWebUrl)
+    if (input.resumedTranscriptPath === undefined)
+        return text
+    const transcript = await readFile(input.resumedTranscriptPath, 'utf8').catch(() => '')
+    return transcript.includes(input.sessionWebUrl) ? undefined : text
+}

package/src/agents/subscription-token-refresh.ts

@@ -0,0 +1,73 @@
+export interface SubscriptionTokenIdentity {
+    accessTokenGeneration: number
+    accessTokenFingerprint: string
+}
+
+export interface RejectedSubscriptionToken {
+    rejectedTokenGeneration: number
+    rejectedTokenFingerprint: string
+}
+
+interface SubscriptionTokenRefreshInput<Tokens extends SubscriptionTokenIdentity> {
+    /** The installed tokens a rejection is compared against. */
+    installed: () => Promise<Tokens>
+    /** The installed tokens after the central refresh returns; throws when the holder has closed. */
+    current: () => Tokens
+    install: (tokens: Tokens) => void
+    refresh: (rejected: RejectedSubscriptionToken) => Promise<Tokens>
+    accountId: (tokens: Tokens) => string
+    conflictingIdentity: () => Error
+}
+
+/**
+ * Central subscription-token refresh shared by Codex and Claude credential holders. Concurrent
+ * rejections of one token share one refresh; decisions are serialized across accounts because
+ * generations are not comparable between them. A rejection of an already-replaced token receives
+ * the replacement instead of a new refresh. A replacement is installed when it switches account or
+ * does not move the generation backwards; the same generation with a different fingerprint is a
+ * conflicting identity.
+ */
+export class SubscriptionTokenRefresh<Tokens extends SubscriptionTokenIdentity> {
+    private readonly pending = new Map<string, Promise<Tokens>>()
+    private queue: Promise<void> = Promise.resolve()
+
+    constructor(private readonly input: SubscriptionTokenRefreshInput<Tokens>) {}
+
+    async refresh(rejected: RejectedSubscriptionToken): Promise<Tokens> {
+        const key = `${rejected.rejectedTokenGeneration}:${rejected.rejectedTokenFingerprint}`
+        const pending = this.pending.get(key)
+        if (pending)
+            return await pending
+        const refresh = this.queue.then(async () => await this.replace(rejected))
+        this.queue = refresh.then(() => undefined, () => undefined)
+        this.pending.set(key, refresh)
+        try {
+            return await refresh
+        }
+        finally {
+            this.pending.delete(key)
+        }
+    }
+
+    clear(): void {
+        this.pending.clear()
+    }
+
+    private async replace(rejected: RejectedSubscriptionToken): Promise<Tokens> {
+        const installed = await this.input.installed()
+        if (rejected.rejectedTokenGeneration !== installed.accessTokenGeneration
+            || rejected.rejectedTokenFingerprint !== installed.accessTokenFingerprint) {
+            return installed
+        }
+        const tokens = await this.input.refresh(rejected)
+        const current = this.input.current()
+        const sameAccount = this.input.accountId(tokens) === this.input.accountId(current)
+        if (sameAccount && tokens.accessTokenGeneration === current.accessTokenGeneration && tokens.accessTokenFingerprint !== current.accessTokenFingerprint)
+            throw this.input.conflictingIdentity()
+        if (!sameAccount || tokens.accessTokenGeneration >= current.accessTokenGeneration) {
+            this.input.install(tokens)
+            return tokens
+        }
+        return current
+    }
+}

package/src/agents/user-input-request.ts

@@ -142,7 +142,11 @@ export class UserInputRequestStore {
     }
 
     shouldHoldIdle(): boolean {
-        return [...this.requests.values()].some(request => request.status === 'pending')
+        return this.hasUnresolvedUserInput()
+    }
+
+    hasUnresolvedUserInput(): boolean {
+        return [...this.requests.values()].some(request => request.status === 'pending' || request.status === 'answered')
     }
 
     resolve(command: RespondUserInputAgentCommand): ResolvedUserInputRequest | null {
@@ -165,10 +169,22 @@ export class UserInputRequestStore {
             return null
 
         if (record.status === 'answered') {
-            assertSameAnswers(record, command.answers)
+            const existingAnswers = record.answers
+            if (!existingAnswers) {
+                throw new AgentRunStateError({
+                    message: `User input request ${record.requestId} is answered without stored answers.`,
+                    details: { requestId: record.requestId },
+                })
+            }
+            if (!sameAnswerValues(existingAnswers, command.answers)) {
+                throw new AgentRunStateError({
+                    message: `User input request ${record.requestId} was already answered with different answers.`,
+                    details: { requestId: record.requestId },
+                })
+            }
             return {
                 record,
-                prompt: promptForResolvedUserInput(record, record.answers),
+                prompt: promptForResolvedUserInput(record, existingAnswers),
             }
         }
 
@@ -399,23 +415,6 @@ function validateAnswers(record: UserInputRequestRecord, answers: AgentUserInput
     }
 }
 
-function assertSameAnswers(record: UserInputRequestRecord, answers: AgentUserInputAnswers): asserts record is UserInputRequestRecord & { answers: AgentUserInputAnswers } {
-    const existing = record.answers
-    if (!existing) {
-        throw new AgentRunStateError({
-            message: `User input request ${record.requestId} is answered without stored answers.`,
-            details: { requestId: record.requestId },
-        })
-    }
-
-    if (!sameAnswerValues(existing, answers)) {
-        throw new AgentRunStateError({
-            message: `User input request ${record.requestId} was already answered with different answers.`,
-            details: { requestId: record.requestId },
-        })
-    }
-}
-
 function sameAnswerValues(left: AgentUserInputAnswers, right: AgentUserInputAnswers): boolean {
     return stableJson(left) === stableJson(right)
 }

package/src/errors/index.ts

@@ -12,5 +12,5 @@ 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 { PayloadTooLargeError, UnprocessableEntityError, ValidationError } from './validation-error'
 export type { ValidationErrorInput } from './validation-error'

package/src/errors/validation-error.ts

@@ -17,3 +17,9 @@ export class UnprocessableEntityError extends ValidationError {
         super(input)
     }
 }
+
+export class PayloadTooLargeError extends ValidationError {
+    constructor(input: ValidationErrorInput) {
+        super(input)
+    }
+}