koishi-plugin-dynamic-bot 0.0.0-dev

package/src/dbk/session.ts

@@ -0,0 +1,239 @@
+import { create } from "@bufbuild/protobuf";
+import { ErrorCode, RpcErrorSchema } from "../gen/dbk/v1/common_pb";
+import { FrameOp, type Frame } from "../gen/dbk/v1/frame_pb";
+import { createFrame, decodePayload, encodeFrame, encodePayload } from "./codec";
+import { DbkRpcError } from "./error";
+import {
+  DbkEventCodecs,
+  DbkMethod,
+  DbkRpcCodecs,
+  PING_INTERVAL_MS,
+  PONG_TIMEOUT_MS,
+  PROTOCOL_VERSION,
+  type DbkEncoding,
+  type DbkEventMap,
+  type DbkGatewayHandlers,
+  type DbkRpcMap,
+} from "./protocol";
+
+export interface DbkLogger {
+  debug(...args: unknown[]): void;
+  info(...args: unknown[]): void;
+  warn(...args: unknown[]): void;
+  error(...args: unknown[]): void;
+}
+
+export interface DbkSessionOptions {
+  encoding: DbkEncoding;
+  accessToken: string;
+  handlers: DbkGatewayHandlers;
+  logger: DbkLogger;
+  send: (data: Uint8Array | string) => void;
+  onDead: (reason: string) => void;
+  onUnauthorized?: () => void;
+  now?: () => number;
+}
+
+export class DbkGatewaySession {
+  private closed = false;
+  private handshook = false;
+  private seq = 0n;
+  private sendQueue = Promise.resolve();
+  private lastInboundAt: number;
+  private heartbeat: ReturnType<typeof setInterval> | undefined;
+  private readonly now: () => number;
+
+  constructor(private readonly options: DbkSessionOptions) {
+    this.now = options.now ?? Date.now;
+    this.lastInboundAt = this.now();
+  }
+
+  get isHandshook(): boolean {
+    return this.handshook && !this.closed;
+  }
+
+  onFrame(frame: Frame): void {
+    if (this.closed) return;
+    this.lastInboundAt = this.now();
+    void this.handle(frame);
+  }
+
+  rejectText(): void {
+    this.fail("DBK only accepts protobuf binary frames");
+  }
+
+  rejectDecode(error: unknown): void {
+    this.options.logger.warn("DBK frame decode failed: %s", error);
+    this.fail("DBK frame could not be decoded");
+  }
+
+  emit<K extends keyof DbkEventMap>(method: K, event: DbkEventMap[K]): void {
+    if (!this.isHandshook) return;
+    this.seq += 1n;
+    this.enqueueFrame(
+      createFrame({
+        op: FrameOp.EVENT,
+        seq: this.seq,
+        method,
+        payload: encodePayload(DbkEventCodecs[method], event as never),
+      }),
+    );
+  }
+
+  close(reason = "closed"): void {
+    if (this.closed) return;
+    this.closed = true;
+    this.handshook = false;
+    if (this.heartbeat) {
+      clearInterval(this.heartbeat);
+      this.heartbeat = undefined;
+    }
+    this.options.logger.debug("DBK session closed: %s", reason);
+  }
+
+  private async handle(frame: Frame): Promise<void> {
+    switch (frame.op) {
+      case FrameOp.PING:
+        if (!this.handshook) return;
+        this.enqueueFrame(createFrame({ op: FrameOp.PONG, id: frame.id }));
+        return;
+      case FrameOp.PONG:
+        return;
+      case FrameOp.CALL:
+        await this.handleCall(frame);
+        return;
+      case FrameOp.EVENT:
+      case FrameOp.OK:
+      case FrameOp.ERROR:
+        this.options.logger.debug("gateway ignored peer %s: method=%s", FrameOp[frame.op], frame.method);
+        return;
+      default:
+        this.options.logger.warn("ignored DBK frame with unspecified op");
+    }
+  }
+
+  private async handleCall(frame: Frame): Promise<void> {
+    if (!frame.id) {
+      this.replyError("", ErrorCode.PROTOCOL, "CALL is missing id");
+      return;
+    }
+    if (!this.handshook && frame.method !== DbkMethod.SESSION_HELLO) {
+      this.options.logger.debug("drop CALL before handshake: method=%s", frame.method);
+      this.replyError(frame.id, ErrorCode.PROTOCOL, "DBK handshake is not complete");
+      return;
+    }
+    if (!(frame.method in DbkRpcCodecs)) {
+      this.replyError(frame.id, ErrorCode.UNSUPPORTED, `unknown method: ${frame.method}`);
+      return;
+    }
+    try {
+      const payload = await this.dispatchCall(frame.method, frame.payload);
+      this.enqueueFrame(
+        createFrame({
+          op: FrameOp.OK,
+          id: frame.id,
+          method: frame.method,
+          payload,
+        }),
+      );
+    } catch (error) {
+      const rpcError = error instanceof DbkRpcError
+        ? error
+        : new DbkRpcError(ErrorCode.INTERNAL, error instanceof Error ? error.message : String(error));
+      this.options.logger.warn("DBK RPC failed: method=%s code=%s %s", frame.method, ErrorCode[rpcError.code], rpcError.message);
+      this.replyError(frame.id, rpcError.code, rpcError.message);
+      if (frame.method === DbkMethod.SESSION_HELLO && rpcError.code === ErrorCode.UNAUTHORIZED) {
+        this.options.onUnauthorized?.();
+        await this.sendQueue;
+        this.fail(rpcError.message);
+      }
+    }
+  }
+
+  private dispatchCall(method: string, payload: Uint8Array): Promise<Uint8Array> {
+    switch (method) {
+      case DbkMethod.SESSION_HELLO:
+        return this.runRpc(method, payload, (request) => this.hello(request));
+      case DbkMethod.BOTS_LIST:
+      case DbkMethod.TARGETS_LIST:
+      case DbkMethod.TARGETS_GET:
+      case DbkMethod.MESSAGE_SEND:
+      case DbkMethod.MESSAGE_RECALL:
+        return this.runRpc(method, payload, this.options.handlers[method]);
+      default:
+        return Promise.reject(new DbkRpcError(ErrorCode.UNSUPPORTED, `unknown method: ${method}`));
+    }
+  }
+
+  private async runRpc<K extends keyof DbkRpcMap>(
+    method: K,
+    payload: Uint8Array,
+    handler: DbkGatewayHandlers[K],
+  ): Promise<Uint8Array> {
+    const codec = DbkRpcCodecs[method];
+    const request = decodePayload(codec.request, payload);
+    const response = await handler(request);
+    return encodePayload(codec.response, response);
+  }
+
+  private async hello(request: DbkRpcMap[typeof DbkMethod.SESSION_HELLO]["request"]): Promise<DbkRpcMap[typeof DbkMethod.SESSION_HELLO]["response"]> {
+    if (request.token !== this.options.accessToken) {
+      throw new DbkRpcError(ErrorCode.UNAUTHORIZED, "invalid access token");
+    }
+    const remote = request.protocolVersion.trim();
+    if (remote && remote !== PROTOCOL_VERSION) {
+      throw new DbkRpcError(
+        ErrorCode.PROTOCOL,
+        `protocol version mismatch: local=${PROTOCOL_VERSION} remote=${remote}`,
+      );
+    }
+    const response = await this.options.handlers[DbkMethod.SESSION_HELLO](request);
+    this.handshook = true;
+    this.startHeartbeat();
+    this.options.logger.info(
+      "DBK handshake complete: bots=%d app=%s",
+      response.bots.length,
+      request.appVersion || "-",
+    );
+    return response;
+  }
+
+  private replyError(id: string, code: ErrorCode, detail: string): void {
+    this.enqueueFrame(
+      createFrame({
+        op: FrameOp.ERROR,
+        id,
+        error: create(RpcErrorSchema, { code, detail }),
+      }),
+    );
+  }
+
+  private startHeartbeat(): void {
+    if (this.heartbeat) clearInterval(this.heartbeat);
+    this.lastInboundAt = this.now();
+    this.heartbeat = setInterval(() => {
+      if (this.closed) return;
+      if (this.now() - this.lastInboundAt >= PONG_TIMEOUT_MS) {
+        this.fail("DBK heartbeat timed out");
+        return;
+      }
+      this.enqueueFrame(createFrame({ op: FrameOp.PING }));
+    }, PING_INTERVAL_MS);
+  }
+
+  private enqueueFrame(frame: Frame): void {
+    this.sendQueue = this.sendQueue.then(() => {
+      if (this.closed) return;
+      this.options.send(encodeFrame(frame, this.options.encoding));
+    }).catch((error) => {
+      this.options.logger.warn("DBK send failed: %s", error);
+      this.fail("DBK send failed");
+    });
+  }
+
+  private fail(reason: string): void {
+    if (this.closed) return;
+    this.options.onDead(reason);
+    this.close(reason);
+  }
+}

package/src/dbk/socket.ts

@@ -0,0 +1,52 @@
+import { decodeFrame, toBytes } from "./codec";
+import type { DbkEncoding } from "./protocol";
+import type { DbkGatewaySession } from "./session";
+
+export interface DbkSocket {
+  readyState: number;
+  binaryType?: string;
+  send(data: Uint8Array | string): void;
+  close(code?: number, reason?: string): void;
+  on?(event: string, listener: (...args: unknown[]) => void): void;
+  addEventListener?(type: string, listener: (event: { data?: unknown; code?: number; reason?: string }) => void): void;
+}
+
+export const WS_OPEN = 1;
+
+export function sendSocket(socket: DbkSocket, data: Uint8Array | string): void {
+  if (socket.readyState !== WS_OPEN) {
+    throw new Error("WebSocket is not open");
+  }
+  socket.send(data);
+}
+
+export function attachSocket(socket: DbkSocket, session: DbkGatewaySession, encoding: DbkEncoding): void {
+  if (socket.binaryType !== undefined) {
+    socket.binaryType = "arraybuffer";
+  }
+
+  const onMessage = (data: unknown, isBinary?: boolean) => {
+    const binary = isBinary ?? typeof data !== "string";
+    if (encoding === "binary" && !binary) {
+      session.rejectText();
+      return;
+    }
+    try {
+      const raw = typeof data === "string" ? data : toBytes(data);
+      session.onFrame(decodeFrame(raw, encoding));
+    } catch (error) {
+      session.rejectDecode(error);
+    }
+  };
+
+  const onClose = () => session.close("ws close");
+
+  if (typeof socket.on === "function") {
+    socket.on("message", (data, isBinary) => onMessage(data, isBinary as boolean | undefined));
+    socket.on("close", onClose);
+    return;
+  }
+
+  socket.addEventListener?.("message", (event) => onMessage(event.data));
+  socket.addEventListener?.("close", onClose);
+}

package/src/dbk/version.ts

@@ -0,0 +1,65 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const FALLBACK = "0.0.0-dev";
+
+function hereDir(): string {
+  try {
+    return dirname(fileURLToPath(import.meta.url));
+  } catch {
+    return process.cwd();
+  }
+}
+
+function packageDir(): string {
+  const fromHere = join(hereDir(), "..", "..");
+  if (existsSync(join(fromHere, "package.json"))) return fromHere;
+  const fromCwd = join(process.cwd(), "koishi");
+  if (existsSync(join(fromCwd, "package.json"))) return fromCwd;
+  return process.cwd();
+}
+
+function isProductRepo(root: string): boolean {
+  return (
+    existsSync(join(root, "pnpm-workspace.yaml")) &&
+    existsSync(join(root, "jvm", "build.gradle.kts")) &&
+    existsSync(join(root, "koishi", "package.json"))
+  );
+}
+
+function gitDescribe(cwd: string): string | undefined {
+  try {
+    const described = execFileSync(
+      "git",
+      ["describe", "--tags", "--always", "--abbrev=7", "--dirty"],
+      { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] },
+    ).trim();
+    return described || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function packageVersion(dir: string): string {
+  try {
+    const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8")) as {
+      version?: string;
+    };
+    return pkg.version?.trim() || FALLBACK;
+  } catch {
+    return FALLBACK;
+  }
+}
+
+function resolveGatewayVersion(): string {
+  const pkg = packageDir();
+  const repoRoot = join(pkg, "..");
+  if (isProductRepo(repoRoot)) {
+    return gitDescribe(repoRoot) ?? packageVersion(pkg);
+  }
+  return packageVersion(pkg);
+}
+
+export const GATEWAY_VERSION = resolveGatewayVersion();

package/src/gen/dbk/v1/common_pb.ts

@@ -0,0 +1,238 @@
+// @generated by protoc-gen-es v2.12.1 with parameter "target=ts"
+// @generated from file dbk/v1/common.proto (package dbk.v1, syntax proto3)
+/* eslint-disable */
+
+import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2";
+import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv2";
+import type { Message } from "@bufbuild/protobuf";
+
+/**
+ * Describes the file dbk/v1/common.proto.
+ */
+export const file_dbk_v1_common: GenFile = /*@__PURE__*/
+  fileDesc("ChNkYmsvdjEvY29tbW9uLnByb3RvEgZkYmsudjEiSAoGVGFyZ2V0EiAKBGtpbmQYASABKA4yEi5kYmsudjEuVGFyZ2V0S2luZBIKCgJpZBgCIAEoCRIQCghndWlsZF9pZBgDIAEoCSI7CghScGNFcnJvchIfCgRjb2RlGAEgASgOMhEuZGJrLnYxLkVycm9yQ29kZRIOCgZkZXRhaWwYAiABKAkqhwEKClRhcmdldEtpbmQSGwoXVEFSR0VUX0tJTkRfVU5TUEVDSUZJRUQQABIUChBUQVJHRVRfS0lORF9VU0VSEAESFQoRVEFSR0VUX0tJTkRfR1JPVVAQAhIXChNUQVJHRVRfS0lORF9DSEFOTkVMEAMSFgoSVEFSR0VUX0tJTkRfVEhSRUFEEAQqdAoJQm90U3RhdHVzEhoKFkJPVF9TVEFUVVNfVU5TUEVDSUZJRUQQABIUChBCT1RfU1RBVFVTX1JFQURZEAESGgoWQk9UX1NUQVRVU19VTkFWQUlMQUJMRRACEhkKFUJPVF9TVEFUVVNfQ09OTkVDVElORxADKocBCgpTZW5kU3RhdHVzEhsKF1NFTkRfU1RBVFVTX1VOU1BFQ0lGSUVEEAASEgoOU0VORF9TVEFUVVNfT0sQARIXChNTRU5EX1NUQVRVU19QQVJUSUFMEAISFwoTU0VORF9TVEFUVVNfVU5LTk9XThADEhYKElNFTkRfU1RBVFVTX0ZBSUxFRBAEKqwBCglFcnJvckNvZGUSGgoWRVJST1JfQ09ERV9VTlNQRUNJRklFRBAAEhsKF0VSUk9SX0NPREVfVU5BVVRIT1JJWkVEEAESFwoTRVJST1JfQ09ERV9QUk9UT0NPTBACEhgKFEVSUk9SX0NPREVfTk9UX0ZPVU5EEAMSGgoWRVJST1JfQ09ERV9VTlNVUFBPUlRFRBAEEhcKE0VSUk9SX0NPREVfSU5URVJOQUwQBSqFAQoNQm90Q2hhbmdlVHlwZRIfChtCT1RfQ0hBTkdFX1RZUEVfVU5TUEVDSUZJRUQQABIZChVCT1RfQ0hBTkdFX1RZUEVfQURERUQQARIbChdCT1RfQ0hBTkdFX1RZUEVfVVBEQVRFRBACEhsKF0JPVF9DSEFOR0VfVFlQRV9SRU1PVkVEEANiBnByb3RvMw");
+
+/**
+ * @generated from message dbk.v1.Target
+ */
+export type Target = Message<"dbk.v1.Target"> & {
+  /**
+   * @generated from field: dbk.v1.TargetKind kind = 1;
+   */
+  kind: TargetKind;
+
+  /**
+   * @generated from field: string id = 2;
+   */
+  id: string;
+
+  /**
+   * @generated from field: string guild_id = 3;
+   */
+  guildId: string;
+};
+
+/**
+ * Describes the message dbk.v1.Target.
+ * Use `create(TargetSchema)` to create a new message.
+ */
+export const TargetSchema: GenMessage<Target> = /*@__PURE__*/
+  messageDesc(file_dbk_v1_common, 0);
+
+/**
+ * @generated from message dbk.v1.RpcError
+ */
+export type RpcError = Message<"dbk.v1.RpcError"> & {
+  /**
+   * @generated from field: dbk.v1.ErrorCode code = 1;
+   */
+  code: ErrorCode;
+
+  /**
+   * @generated from field: string detail = 2;
+   */
+  detail: string;
+};
+
+/**
+ * Describes the message dbk.v1.RpcError.
+ * Use `create(RpcErrorSchema)` to create a new message.
+ */
+export const RpcErrorSchema: GenMessage<RpcError> = /*@__PURE__*/
+  messageDesc(file_dbk_v1_common, 1);
+
+/**
+ * @generated from enum dbk.v1.TargetKind
+ */
+export enum TargetKind {
+  /**
+   * @generated from enum value: TARGET_KIND_UNSPECIFIED = 0;
+   */
+  UNSPECIFIED = 0,
+
+  /**
+   * @generated from enum value: TARGET_KIND_USER = 1;
+   */
+  USER = 1,
+
+  /**
+   * @generated from enum value: TARGET_KIND_GROUP = 2;
+   */
+  GROUP = 2,
+
+  /**
+   * @generated from enum value: TARGET_KIND_CHANNEL = 3;
+   */
+  CHANNEL = 3,
+
+  /**
+   * @generated from enum value: TARGET_KIND_THREAD = 4;
+   */
+  THREAD = 4,
+}
+
+/**
+ * Describes the enum dbk.v1.TargetKind.
+ */
+export const TargetKindSchema: GenEnum<TargetKind> = /*@__PURE__*/
+  enumDesc(file_dbk_v1_common, 0);
+
+/**
+ * @generated from enum dbk.v1.BotStatus
+ */
+export enum BotStatus {
+  /**
+   * @generated from enum value: BOT_STATUS_UNSPECIFIED = 0;
+   */
+  UNSPECIFIED = 0,
+
+  /**
+   * @generated from enum value: BOT_STATUS_READY = 1;
+   */
+  READY = 1,
+
+  /**
+   * @generated from enum value: BOT_STATUS_UNAVAILABLE = 2;
+   */
+  UNAVAILABLE = 2,
+
+  /**
+   * @generated from enum value: BOT_STATUS_CONNECTING = 3;
+   */
+  CONNECTING = 3,
+}
+
+/**
+ * Describes the enum dbk.v1.BotStatus.
+ */
+export const BotStatusSchema: GenEnum<BotStatus> = /*@__PURE__*/
+  enumDesc(file_dbk_v1_common, 1);
+
+/**
+ * @generated from enum dbk.v1.SendStatus
+ */
+export enum SendStatus {
+  /**
+   * @generated from enum value: SEND_STATUS_UNSPECIFIED = 0;
+   */
+  UNSPECIFIED = 0,
+
+  /**
+   * @generated from enum value: SEND_STATUS_OK = 1;
+   */
+  OK = 1,
+
+  /**
+   * @generated from enum value: SEND_STATUS_PARTIAL = 2;
+   */
+  PARTIAL = 2,
+
+  /**
+   * @generated from enum value: SEND_STATUS_UNKNOWN = 3;
+   */
+  UNKNOWN = 3,
+
+  /**
+   * @generated from enum value: SEND_STATUS_FAILED = 4;
+   */
+  FAILED = 4,
+}
+
+/**
+ * Describes the enum dbk.v1.SendStatus.
+ */
+export const SendStatusSchema: GenEnum<SendStatus> = /*@__PURE__*/
+  enumDesc(file_dbk_v1_common, 2);
+
+/**
+ * @generated from enum dbk.v1.ErrorCode
+ */
+export enum ErrorCode {
+  /**
+   * @generated from enum value: ERROR_CODE_UNSPECIFIED = 0;
+   */
+  UNSPECIFIED = 0,
+
+  /**
+   * @generated from enum value: ERROR_CODE_UNAUTHORIZED = 1;
+   */
+  UNAUTHORIZED = 1,
+
+  /**
+   * @generated from enum value: ERROR_CODE_PROTOCOL = 2;
+   */
+  PROTOCOL = 2,
+
+  /**
+   * @generated from enum value: ERROR_CODE_NOT_FOUND = 3;
+   */
+  NOT_FOUND = 3,
+
+  /**
+   * @generated from enum value: ERROR_CODE_UNSUPPORTED = 4;
+   */
+  UNSUPPORTED = 4,
+
+  /**
+   * @generated from enum value: ERROR_CODE_INTERNAL = 5;
+   */
+  INTERNAL = 5,
+}
+
+/**
+ * Describes the enum dbk.v1.ErrorCode.
+ */
+export const ErrorCodeSchema: GenEnum<ErrorCode> = /*@__PURE__*/
+  enumDesc(file_dbk_v1_common, 3);
+
+/**
+ * @generated from enum dbk.v1.BotChangeType
+ */
+export enum BotChangeType {
+  /**
+   * @generated from enum value: BOT_CHANGE_TYPE_UNSPECIFIED = 0;
+   */
+  UNSPECIFIED = 0,
+
+  /**
+   * @generated from enum value: BOT_CHANGE_TYPE_ADDED = 1;
+   */
+  ADDED = 1,
+
+  /**
+   * @generated from enum value: BOT_CHANGE_TYPE_UPDATED = 2;
+   */
+  UPDATED = 2,
+
+  /**
+   * @generated from enum value: BOT_CHANGE_TYPE_REMOVED = 3;
+   */
+  REMOVED = 3,
+}
+
+/**
+ * Describes the enum dbk.v1.BotChangeType.
+ */
+export const BotChangeTypeSchema: GenEnum<BotChangeType> = /*@__PURE__*/
+  enumDesc(file_dbk_v1_common, 4);
+

package/src/gen/dbk/v1/frame_pb.ts

@@ -0,0 +1,114 @@
+// @generated by protoc-gen-es v2.12.1 with parameter "target=ts"
+// @generated from file dbk/v1/frame.proto (package dbk.v1, syntax proto3)
+/* eslint-disable */
+
+import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2";
+import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv2";
+import type { RpcError } from "./common_pb";
+import { file_dbk_v1_common } from "./common_pb";
+import type { Message } from "@bufbuild/protobuf";
+
+/**
+ * Describes the file dbk/v1/frame.proto.
+ */
+export const file_dbk_v1_frame: GenFile = /*@__PURE__*/
+  fileDesc("ChJkYmsvdjEvZnJhbWUucHJvdG8SBmRiay52MSJ/CgVGcmFtZRIbCgJvcBgBIAEoDjIPLmRiay52MS5GcmFtZU9wEgoKAmlkGAIgASgJEgsKA3NlcRgDIAEoBBIOCgZtZXRob2QYBCABKAkSDwoHcGF5bG9hZBgFIAEoDBIfCgVlcnJvchgGIAEoCzIQLmRiay52MS5ScGNFcnJvciqVAQoHRnJhbWVPcBIYChRGUkFNRV9PUF9VTlNQRUNJRklFRBAAEhEKDUZSQU1FX09QX0NBTEwQARIPCgtGUkFNRV9PUF9PSxACEhIKDkZSQU1FX09QX0VSUk9SEAMSEgoORlJBTUVfT1BfRVZFTlQQBBIRCg1GUkFNRV9PUF9QSU5HEAUSEQoNRlJBTUVfT1BfUE9ORxAGYgZwcm90bzM", [file_dbk_v1_common]);
+
+/**
+ * @generated from message dbk.v1.Frame
+ */
+export type Frame = Message<"dbk.v1.Frame"> & {
+  /**
+   * @generated from field: dbk.v1.FrameOp op = 1;
+   */
+  op: FrameOp;
+
+  /**
+   * CALL / OK / ERROR. Generated by the caller.
+   *
+   * @generated from field: string id = 2;
+   */
+  id: string;
+
+  /**
+   * EVENT only. Monotonic per connection; v1 does not resume by seq.
+   *
+   * @generated from field: uint64 seq = 3;
+   */
+  seq: bigint;
+
+  /**
+   * CALL / EVENT method name, e.g. `session.hello`, `message.created`.
+   *
+   * @generated from field: string method = 4;
+   */
+  method: string;
+
+  /**
+   * Encoded request, response, or event body for `method`.
+   *
+   * @generated from field: bytes payload = 5;
+   */
+  payload: Uint8Array;
+
+  /**
+   * ERROR only. Business send failures use OK + SendStatus, not this.
+   *
+   * @generated from field: dbk.v1.RpcError error = 6;
+   */
+  error?: RpcError | undefined;
+};
+
+/**
+ * Describes the message dbk.v1.Frame.
+ * Use `create(FrameSchema)` to create a new message.
+ */
+export const FrameSchema: GenMessage<Frame> = /*@__PURE__*/
+  messageDesc(file_dbk_v1_frame, 0);
+
+/**
+ * @generated from enum dbk.v1.FrameOp
+ */
+export enum FrameOp {
+  /**
+   * @generated from enum value: FRAME_OP_UNSPECIFIED = 0;
+   */
+  UNSPECIFIED = 0,
+
+  /**
+   * @generated from enum value: FRAME_OP_CALL = 1;
+   */
+  CALL = 1,
+
+  /**
+   * @generated from enum value: FRAME_OP_OK = 2;
+   */
+  OK = 2,
+
+  /**
+   * @generated from enum value: FRAME_OP_ERROR = 3;
+   */
+  ERROR = 3,
+
+  /**
+   * @generated from enum value: FRAME_OP_EVENT = 4;
+   */
+  EVENT = 4,
+
+  /**
+   * @generated from enum value: FRAME_OP_PING = 5;
+   */
+  PING = 5,
+
+  /**
+   * @generated from enum value: FRAME_OP_PONG = 6;
+   */
+  PONG = 6,
+}
+
+/**
+ * Describes the enum dbk.v1.FrameOp.
+ */
+export const FrameOpSchema: GenEnum<FrameOp> = /*@__PURE__*/
+  enumDesc(file_dbk_v1_frame, 0);
+