@ryubyte/dsh-a2a 0.1.0

package/src/jsonrpc.ts

@@ -0,0 +1,185 @@
+/**
+ * A2A (Agent2Agent) Protocol v1.0 — JSON-RPC 2.0 transport client.
+ *
+ * Implements the JSONRPC protocol binding of A2A v1.0: a thin JSON-RPC 2.0
+ * client for unary calls plus an SSE reader for `SendStreamingMessage`.
+ */
+
+import type { JsonRpcRequest, JsonRpcResponse, JsonRpcSuccess, StreamResponse } from './protocol.js';
+import { A2AError } from './errors.js';
+
+export interface JsonRpcClientOptions {
+  /** Timeout (ms) for a single unary call. Default 60000. */
+  timeoutMs?: number;
+  /** Optional bearer token. */
+  bearerToken?: string;
+  /** Custom fetch (tests). */
+  fetchImpl?: typeof fetch;
+}
+
+export interface JsonRpcCallOptions {
+  signal?: AbortSignal;
+  timeoutMs?: number;
+}
+
+export class JsonRpcClient {
+  readonly url: string;
+  private readonly timeoutMs: number;
+  private readonly bearerToken?: string;
+  private readonly fetchImpl: typeof fetch;
+  private seq = 0;
+
+  constructor(url: string, options: JsonRpcClientOptions = {}) {
+    this.url = url;
+    this.timeoutMs = options.timeoutMs ?? 60000;
+    this.bearerToken = options.bearerToken;
+    this.fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  }
+
+  private headers(extra?: Record<string, string>): Record<string, string> {
+    const h: Record<string, string> = {
+      'content-type': 'application/json',
+      accept: 'application/json',
+      ...extra,
+    };
+    if (this.bearerToken) h.authorization = `Bearer ${this.bearerToken}`;
+    return h;
+  }
+
+  /** Perform a unary JSON-RPC call. */
+  async call<T>(method: string, params: unknown, options: JsonRpcCallOptions = {}): Promise<T> {
+    const req: JsonRpcRequest = {
+      jsonrpc: '2.0',
+      id: ++this.seq,
+      method,
+      params,
+    };
+    const ctrl = options.signal ? new AbortController() : undefined;
+    const onAbort = () => ctrl?.abort();
+    options.signal?.addEventListener('abort', onAbort);
+    const timeout = setTimeout(
+      () => ctrl?.abort(),
+      options.timeoutMs ?? this.timeoutMs,
+    );
+    try {
+      const res = await this.fetchImpl(this.url, {
+        method: 'POST',
+        headers: this.headers(),
+        body: JSON.stringify(req),
+        signal: ctrl?.signal,
+      });
+      if (!res.ok) {
+        throw new A2AError(
+          res.status,
+          `A2A JSON-RPC request failed (HTTP ${res.status}) at ${this.url}`,
+          undefined,
+          true,
+        );
+      }
+      const json = (await res.json()) as JsonRpcResponse;
+      if ('error' in json && json.error) {
+        throw A2AError.fromJsonRpc(json.error);
+      }
+      return (json as JsonRpcSuccess).result as T;
+    } catch (err) {
+      if (err instanceof Error && err.name === 'AbortError') {
+        throw new A2AError(408, `A2A JSON-RPC call "${method}" timed out`, undefined, true);
+      }
+      throw err;
+    } finally {
+      clearTimeout(timeout);
+      options.signal?.removeEventListener('abort', onAbort);
+    }
+  }
+
+  /**
+   * Open a streaming JSON-RPC call (`SendStreamingMessage`) over SSE and
+   * yield the `StreamResponse` events as they arrive. The connection is
+   * closed when the returned async iterator is broken or the request is
+   * cancelled. Events are decoded from SSE `data:` lines (JSON-RPC result
+   * frames); per A2A v1.0 the JSON structure uses member names to
+   * discriminate `task` / `message` / `statusUpdate` / `artifactUpdate`.
+   */
+  async *stream<T = StreamResponse>(
+    method: string,
+    params: unknown,
+    options: JsonRpcCallOptions = {},
+  ): AsyncGenerator<T> {
+    const req: JsonRpcRequest = {
+      jsonrpc: '2.0',
+      id: ++this.seq,
+      method,
+      params,
+    };
+    const ctrl = new AbortController();
+    const onAbort = () => ctrl.abort();
+    options.signal?.addEventListener('abort', onAbort);
+    const timeout = setTimeout(
+      () => ctrl.abort(),
+      options.timeoutMs ?? this.timeoutMs,
+    );
+    let res: Response;
+    try {
+      res = await this.fetchImpl(this.url, {
+        method: 'POST',
+        headers: this.headers({ accept: 'text/event-stream' }),
+        body: JSON.stringify(req),
+        signal: ctrl.signal,
+      });
+    } catch (err) {
+      clearTimeout(timeout);
+      options.signal?.removeEventListener('abort', onAbort);
+      if (err instanceof Error && err.name === 'AbortError') {
+        throw new A2AError(408, `A2A stream "${method}" timed out`, undefined, true);
+      }
+      throw err;
+    }
+    if (!res.ok || !res.body) {
+      clearTimeout(timeout);
+      options.signal?.removeEventListener('abort', onAbort);
+      throw new A2AError(
+        res.status,
+        `A2A stream request failed (HTTP ${res.status}) at ${this.url}`,
+        undefined,
+        true,
+      );
+    }
+
+    try {
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = '';
+      for (;;) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        // SSE frames are separated by a blank line.
+        const frames = buffer.split(/\r?\n\r?\n/);
+        buffer = frames.pop() ?? '';
+        for (const frame of frames) {
+          const data = frame
+            .split(/\r?\n/)
+            .filter((l) => l.startsWith('data:'))
+            .map((l) => l.slice(5).trimStart())
+            .join('\n');
+          if (!data) continue;
+          let payload: unknown;
+          try {
+            payload = JSON.parse(data);
+          } catch {
+            continue; // ignore malformed frames
+          }
+          // A JSON-RPC error frame terminates the stream.
+          const envelope = payload as JsonRpcResponse;
+          if (envelope && 'error' in envelope && envelope.error) {
+            throw A2AError.fromJsonRpc(envelope.error);
+          }
+          yield payload as T;
+        }
+      }
+    } finally {
+      clearTimeout(timeout);
+      options.signal?.removeEventListener('abort', onAbort);
+    }
+  }
+}

package/src/outbound.ts

@@ -0,0 +1,186 @@
+/**
+ * dsh-a2a — outbound half: bridge remote A2A agent skills into DSH's tool
+ * registry (`ctx.tools`).
+ *
+ * Each skill on a remote AgentCard becomes a model-facing tool named
+ * `a2a__<agentName>__<skillId>` (normalized to the DSH function-name
+ * contract: `[A-Za-z0-9_-]`, ≤64 chars; on collision a deterministic hash is
+ * appended, mirroring dsh-mcp-client's naming rule).
+ */
+
+import type { AgentCard, AgentSkill, Message, Part } from './protocol.js';
+import { Role } from './protocol.js';
+import { A2AClient } from './client.js';
+import { A2AError } from './errors.js';
+
+export interface ToolLike {
+  register?(definition: unknown): (() => void) | void;
+}
+
+export interface OutboundOptions {
+  /** Namespace prefix for tool names (lowercase, unique across instances). */
+  name: string;
+  agentCardUrl: string;
+  bearerToken?: string;
+  /** Per-call timeout in ms. Default 60000. */
+  timeoutMs?: number;
+  /** Register one generic tool per skill (default true). */
+  mapSkills?: boolean;
+  /**
+   * Optional connection-lifecycle observation: called once the AgentCard is
+   * fetched and the connection is usable. `connectionId` is the stable id the
+   * dashboard tracks this connection under.
+   */
+  onReady?: (info: { connectionId: string; card: AgentCard }) => void;
+  /** Called when the connection (and its tools) are torn down. */
+  onDispose?: (connectionId: string) => void;
+}
+
+function normalizeToolName(raw: string): string {
+  const norm = raw.replace(/[^A-Za-z0-9_-]/g, '_').slice(0, 64);
+  if (norm.length > 0 && /^[A-Za-z0-9_-]+$/.test(norm)) return norm;
+  // fallback: deterministic hash
+  let h = 0;
+  for (let i = 0; i < raw.length; i++) h = (h * 31 + raw.charCodeAt(i)) >>> 0;
+  return `_${h.toString(16)}`;
+}
+
+function skillToToolName(agentName: string, skill: AgentSkill): string {
+  const raw = `a2a__${agentName}__${skill.id}`;
+  const base = raw.replace(/[^A-Za-z0-9_-]/g, '_').slice(0, 64);
+  if (base === raw || base.length < 64) return base;
+  let h = 0;
+  for (let i = 0; i < raw.length; i++) h = (h * 31 + raw.charCodeAt(i)) >>> 0;
+  return `${base.slice(0, 56)}_${h.toString(16)}`;
+}
+
+/** Extract the first meaningful text from message parts. */
+function partsToText(parts: Part[] | undefined): string {
+  if (!parts) return '';
+  return parts
+    .map((p) => {
+      if ('text' in p && p.text) return p.text;
+      if ('url' in p && p.url) return p.url;
+      if ('data' in p && p.data !== undefined) return JSON.stringify(p.data);
+      if ('raw' in p && p.raw) return `[raw ${p.mediaType ?? 'application/octet-stream'}]`;
+      return '';
+    })
+    .filter(Boolean)
+    .join('\n');
+}
+
+export interface RegisteredTool {
+  name: string;
+  /** Stable id of the client connection this tool belongs to. */
+  connectionId?: string;
+  dispose: () => void;
+}
+
+/**
+ * Register all skills of a remote agent on `ctx.tools` and return disposers.
+ */
+export async function registerAgentTools(
+  tools: ToolLike,
+  options: OutboundOptions,
+): Promise<RegisteredTool[]> {
+  const connectionId = crypto.randomUUID();
+  const client = await A2AClient.connect(options.agentCardUrl, {
+    bearerToken: options.bearerToken,
+    timeoutMs: options.timeoutMs,
+  });
+  const card: AgentCard = client.card;
+  const skills = card.skills ?? [];
+  options.onReady?.({ connectionId, card });
+
+  let disposers: RegisteredTool[] = [];
+  if (options.mapSkills === false || skills.length === 0) {
+    // Fall back to a single generic tool for the whole agent.
+    const name = normalizeToolName(`a2a__${options.name}__agent`);
+    const dispose = tools.register?.(makeTool(name, client, {
+      id: 'agent',
+      name: options.name,
+      description: `${card.name}: ${card.description} (no skills advertised)`,
+    }));
+    if (dispose) disposers = [{ name, dispose }];
+  } else {
+    const out: RegisteredTool[] = [];
+    for (const skill of skills) {
+      const name = skillToToolName(options.name, skill);
+      const dispose = tools.register?.(makeTool(name, client, skill));
+      if (dispose) out.push({ name, dispose });
+    }
+    disposers = out;
+  }
+
+  return disposers.map((r) => ({
+    ...r,
+    connectionId,
+    dispose: () => {
+      r.dispose();
+      options.onDispose?.(connectionId);
+    },
+  }));
+}
+
+function makeTool(name: string, client: A2AClient, skill: Pick<AgentSkill, 'id' | 'name' | 'description' | 'examples'>) {
+  const description = [
+    skill.description,
+    ...(skill.examples?.length ? [`Examples: ${skill.examples.join(' | ')}`] : []),
+  ].filter(Boolean).join('\n');
+
+  return {
+    name,
+    description,
+    parameters: {
+      type: 'object',
+      properties: {
+        prompt: {
+          type: 'string',
+          description: 'The task or instruction to send to the remote agent.',
+        },
+      },
+      required: ['prompt'],
+    },
+    output: {
+      schema: { type: 'string' },
+      render: (_args: unknown, value: unknown) => [
+        { type: 'text', text: String(value) },
+      ],
+    },
+    async execute(args: { prompt: string }, exec: { signal?: AbortSignal }): Promise<string> {
+      const message: Message = {
+        messageId: crypto.randomUUID(),
+        role: Role.USER,
+        parts: [{ text: args.prompt }],
+      };
+      try {
+        const task = await client.sendAndWait(message, {}, { signal: exec.signal });
+        const text = partsToText(task.artifacts?.flatMap((a) => a.parts));
+        const failureMsg =
+          task.status.message?.parts?.find((p) => 'text' in p && p.text);
+        if (task.status.state === 'TASK_STATE_FAILED') {
+          throw new A2AError(
+            -32000,
+            `Remote agent task failed: ${text || (failureMsg && 'text' in failureMsg ? failureMsg.text : 'no detail')}`,
+          );
+        }
+        // INPUT_REQUIRED / AUTH_REQUIRED: surface the remote's clarification
+        // request as a *usable* tool output, so the model can answer and call
+        // the tool again — not as a hard error that stalls the conversation.
+        if (task.status.state === 'TASK_STATE_INPUT_REQUIRED' || task.status.state === 'TASK_STATE_AUTH_REQUIRED') {
+          const ask =
+            (failureMsg && 'text' in failureMsg ? failureMsg.text : '') ||
+            text ||
+            'agent awaits input';
+          return `[remote agent ${task.status.state}] ${ask}`;
+        }
+        return text || '(remote agent returned no output)';
+      } catch (err) {
+        if (err instanceof A2AError && err.code === -32001 && err.message.includes('interrupted')) {
+          throw new Error(`Remote agent requires input: ${err.message}`);
+        }
+        throw err;
+      }
+    },
+  };
+}

package/src/protocol.ts

@@ -0,0 +1,308 @@
+/**
+ * A2A (Agent2Agent) Protocol v1.0 — TypeScript type definitions.
+ *
+ * These types mirror the normative source of truth `specification/a2a.proto`
+ * (package `lf.a2a.v1`) from https://github.com/a2aproject/A2A, v1.0.0.
+ * JSON wire names are camelCase per ProtoJSON serialization; enum values use
+ * SCREAMING_SNAKE_CASE as mandated by A2A v1.0.
+ */
+
+/** The lifecycle states of a Task (a2a.proto `TaskState`). */
+export enum TaskState {
+  UNSPECIFIED = 'TASK_STATE_UNSPECIFIED',
+  SUBMITTED = 'TASK_STATE_SUBMITTED',
+  WORKING = 'TASK_STATE_WORKING',
+  COMPLETED = 'TASK_STATE_COMPLETED',
+  FAILED = 'TASK_STATE_FAILED',
+  CANCELED = 'TASK_STATE_CANCELED',
+  INPUT_REQUIRED = 'TASK_STATE_INPUT_REQUIRED',
+  REJECTED = 'TASK_STATE_REJECTED',
+  AUTH_REQUIRED = 'TASK_STATE_AUTH_REQUIRED',
+}
+
+export type TerminalTaskState =
+  | TaskState.COMPLETED
+  | TaskState.FAILED
+  | TaskState.CANCELED
+  | TaskState.REJECTED;
+
+export type InterruptedTaskState = TaskState.INPUT_REQUIRED | TaskState.AUTH_REQUIRED;
+
+export function isTerminal(state: TaskState): state is TerminalTaskState {
+  return (
+    state === TaskState.COMPLETED ||
+    state === TaskState.FAILED ||
+    state === TaskState.CANCELED ||
+    state === TaskState.REJECTED
+  );
+}
+
+/** The sender of a Message (a2a.proto `Role`). */
+export enum Role {
+  UNSPECIFIED = 'ROLE_UNSPECIFIED',
+  USER = 'ROLE_USER',
+  AGENT = 'ROLE_AGENT',
+}
+
+/**
+ * A section of communication content (a2a.proto `Part`): exactly one of
+ * text / raw / url / data.
+ */
+export type Part =
+  | { text: string; raw?: never; url?: never; data?: never; mediaType?: string; filename?: string; metadata?: Record<string, unknown> }
+  | { raw: string; text?: never; url?: never; data?: never; mediaType?: string; filename?: string; metadata?: Record<string, unknown> }
+  | { url: string; text?: never; raw?: never; data?: never; mediaType?: string; filename?: string; metadata?: Record<string, unknown> }
+  | { data: unknown; text?: never; raw?: never; url?: never; mediaType?: string; filename?: string; metadata?: Record<string, unknown> };
+
+/** One unit of communication between client and server (a2a.proto `Message`). */
+export interface Message {
+  messageId: string;
+  /** Required for server (ROLE_AGENT) messages. */
+  contextId?: string;
+  taskId?: string;
+  role: Role | string;
+  parts: Part[];
+  metadata?: Record<string, unknown>;
+  extensions?: string[];
+  referenceTaskIds?: string[];
+}
+
+/** Task output (a2a.proto `Artifact`). */
+export interface Artifact {
+  artifactId: string;
+  name?: string;
+  parts: Part[];
+  metadata?: Record<string, unknown>;
+  /** Only present in task-artifact-update events. */
+  append?: boolean;
+  lastChunk?: boolean;
+}
+
+/** Status of a task (a2a.proto `TaskStatus`). */
+export interface TaskStatus {
+  state: TaskState | string;
+  message?: Message;
+  /** ISO 8601 timestamp. */
+  timestamp?: string;
+}
+
+/** The core unit of action for A2A (a2a.proto `Task`). */
+export interface Task {
+  id: string;
+  contextId?: string;
+  status: TaskStatus;
+  artifacts?: Artifact[];
+  history?: Message[];
+  metadata?: Record<string, unknown>;
+}
+
+/** Configuration for a send request (a2a.proto `SendMessageConfiguration`). */
+export interface SendMessageConfiguration {
+  acceptedOutputModes?: string[];
+  taskPushNotificationConfig?: TaskPushNotificationConfig;
+  historyLength?: number;
+  returnImmediately?: boolean;
+}
+
+/** Push notification registration (a2a.proto `TaskPushNotificationConfig`). */
+export interface TaskPushNotificationConfig {
+  tenant?: string;
+  id?: string;
+  taskId?: string;
+  url: string;
+  token?: string;
+  authentication?: AuthenticationInfo;
+}
+
+/** Authentication details for push (a2a.proto `AuthenticationInfo`). */
+export interface AuthenticationInfo {
+  scheme: string;
+  credentials?: string;
+}
+
+/** Discriminated stream payloads (a2a.proto `StreamResponse`). */
+export type StreamResponse =
+  | { task: Task; message?: never; statusUpdate?: never; artifactUpdate?: never }
+  | { message: Message; task?: never; statusUpdate?: never; artifactUpdate?: never }
+  | { statusUpdate: TaskStatusUpdateEvent; task?: never; message?: never; artifactUpdate?: never }
+  | { artifactUpdate: TaskArtifactUpdateEvent; task?: never; message?: never; statusUpdate?: never };
+
+export interface TaskStatusUpdateEvent {
+  taskId: string;
+  contextId: string;
+  status: TaskStatus;
+  metadata?: Record<string, unknown>;
+}
+
+export interface TaskArtifactUpdateEvent {
+  taskId: string;
+  contextId: string;
+  artifact: Artifact;
+  append?: boolean;
+  lastChunk?: boolean;
+  metadata?: Record<string, unknown>;
+}
+
+/** Response payload of SendMessage (a2a.proto `SendMessageResponse`). */
+export type SendMessageResponse =
+  | { task: Task; message?: never }
+  | { message: Message; task?: never };
+
+/** A declaration of a protocol extension (a2a.proto `AgentExtension`). */
+export interface AgentExtension {
+  uri: string;
+  description?: string;
+  required?: boolean;
+  params?: Record<string, unknown>;
+}
+
+/** Optional capabilities (a2a.proto `AgentCapabilities`). */
+export interface AgentCapabilities {
+  streaming?: boolean;
+  pushNotifications?: boolean;
+  extensions?: AgentExtension[];
+  extendedAgentCard?: boolean;
+}
+
+/** A distinct capability an agent can perform (a2a.proto `AgentSkill`). */
+export interface AgentSkill {
+  id: string;
+  name: string;
+  description: string;
+  tags?: string[];
+  examples?: string[];
+  inputModes?: string[];
+  outputModes?: string[];
+  securityRequirements?: SecurityRequirement[];
+}
+
+/** OAuth flows supported by an agent (v1.0: code, client-credentials, device-code). */
+export interface OAuthFlows {
+  authorizationCode?: AuthorizationCodeOAuthFlow;
+  clientCredentials?: ClientCredentialsOAuthFlow;
+  deviceCode?: DeviceCodeOAuthFlow;
+}
+
+export interface AuthorizationCodeOAuthFlow {
+  authorizationUrl: string;
+  tokenUrl: string;
+  scopes?: Record<string, string>;
+  refreshUrl?: string;
+  pkceRequired?: boolean;
+}
+
+export interface ClientCredentialsOAuthFlow {
+  tokenUrl: string;
+  scopes?: Record<string, string>;
+}
+
+export interface DeviceCodeOAuthFlow {
+  deviceAuthorizationUrl: string;
+  tokenUrl: string;
+  scopes?: Record<string, string>;
+}
+
+/** Security scheme (v1.0 supports apiKey, http, oauth2, openIdConnect, mutualTls). */
+export type SecurityScheme =
+  | { type: 'apiKey'; name: string; in: 'header' | 'query' | 'cookie'; description?: string }
+  | { type: 'http'; scheme: 'basic' | 'bearer' | 'digest'; bearerFormat?: string; description?: string }
+  | { type: 'oauth2'; flows: OAuthFlows; description?: string }
+  | { type: 'openIdConnect'; openIdConnectUrl: string; description?: string }
+  | { type: 'mutualTls'; description?: string };
+
+export interface SecurityRequirement {
+  /** Map of scheme name → required scopes. */
+  schemes: Record<string, string[]>;
+}
+
+/** The provider of an agent (a2a.proto `AgentProvider`). */
+export interface AgentProvider {
+  url: string;
+  organization: string;
+}
+
+/** JWS signature of an AgentCard (RFC 7515). */
+export interface AgentCardSignature {
+  protected: string;
+  signature: string;
+  header?: Record<string, unknown>;
+}
+
+/** A target URL + transport + protocol version (a2a.proto `AgentInterface`). */
+export interface AgentInterface {
+  url: string;
+  protocolBinding: 'JSONRPC' | 'GRPC' | 'HTTP+JSON' | string;
+  /** Opaque routing value; clients MUST echo it in requests when set. */
+  tenant?: string;
+  protocolVersion: string;
+}
+
+/** Self-describing agent manifest (a2a.proto `AgentCard`). */
+export interface AgentCard {
+  name: string;
+  description: string;
+  version: string;
+  supportedInterfaces: AgentInterface[];
+  provider?: AgentProvider;
+  documentationUrl?: string;
+  capabilities: AgentCapabilities;
+  securitySchemes?: Record<string, SecurityScheme>;
+  securityRequirements?: SecurityRequirement[];
+  defaultInputModes: string[];
+  defaultOutputModes: string[];
+  skills?: AgentSkill[];
+  signatures?: AgentCardSignature[];
+  iconUrl?: string;
+}
+
+/** JSON-RPC 2.0 request/response/error envelopes used by the JSONRPC binding. */
+export interface JsonRpcRequest {
+  jsonrpc: '2.0';
+  id: string | number | null;
+  method: string;
+  params?: unknown;
+}
+
+export interface JsonRpcSuccess {
+  jsonrpc: '2.0';
+  id: string | number | null;
+  result: unknown;
+}
+
+export interface JsonRpcError {
+  jsonrpc: '2.0';
+  id: string | number | null;
+  error: { code: number; message: string; data?: unknown };
+}
+
+export type JsonRpcResponse = JsonRpcSuccess | JsonRpcError;
+
+/** A2A JSON-RPC method names (v1.0 canonical PascalCase as in a2a.proto RPCs). */
+export const A2A_METHODS = {
+  sendMessage: 'SendMessage',
+  sendStreamingMessage: 'SendStreamingMessage',
+  getTask: 'GetTask',
+  listTasks: 'ListTasks',
+  cancelTask: 'CancelTask',
+  subscribeToTask: 'SubscribeToTask',
+  getExtendedAgentCard: 'GetExtendedAgentCard',
+} as const;
+
+/** Standard error codes from the A2A JSON-RPC binding. */
+export const A2A_ERROR_CODES = {
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+  TASK_NOT_FOUND: -32001,
+  TASK_CANCEL_NOT_ALLOWED: -32002,
+  TASK_ALREADY_CANCELED: -32003,
+  AGENT_CARD_NOT_FOUND: -32004,
+  AGENT_CARD_SIGNATURE_INVALID: -32005,
+  CONTEXT_NOT_FOUND: -32006,
+  AUTHENTICATION_REQUIRED: -32007,
+  PUSH_NOTIFICATION_CONFIG_NOT_FOUND: -32008,
+  EXTENSION_NOT_SUPPORTED: -32009,
+  UNSUPPORTED_OPERATION: -32010,
+  VERSION_NOT_SUPPORTED: -32011,
+} as const;