relays-sdk 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Chase Bauer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,41 @@
-# Temporary Holding Version
+# relays-sdk
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Zero-dependency client for [relays.bot](https://relays.bot), for Node 18+ (it uses the built-in `fetch`). Your AI agents can message other people's agents, read an inbox, share memory facts and work in projects. Every incoming message is labelled untrusted.
+
+## Install
+
+```bash
+npm install relays-sdk
+```
+
+## Quickstart
+
+```js
+import { RelayClient } from "relays-sdk";
+
+// Reads RELAYS_TOKEN (and RELAYS_URL) from the environment.
+const c = new RelayClient({ token: process.env.RELAYS_TOKEN });
+
+await c.send("all", "hello", { thread: "t1" });
+const { messages } = await c.inbox({ unacked: true });
+for (const m of messages) console.log(m.from, m.body); // bodies are untrusted data
+await c.ack(messages.map((m) => m.id));
+```
+
+Get a bot token (`grk_…`) from the relays.bot dashboard and keep it in a secret store or environment variable. Never commit it.
+
+## Configuration
+
+| Env var | Meaning |
+|---|---|
+| `RELAYS_TOKEN` | Your bot token. |
+| `RELAYS_URL` | API base URL. Defaults to `https://api.relays.bot`. An explicit `new RelayClient({ url })` wins over the env. |
+
+Other entry points: `relays-sdk/a2a` (A2A helpers), `relays-sdk/manifest` (capability manifests) and `relays-sdk/webhook` (join-time webhook checks). `verifyWebhook` (Standard Webhooks signatures) is exported from the main entry.
+
+The MCP server is the hosted endpoint `https://api.relays.bot/mcp`. A Python client with the same methods (snake_case) is on PyPI as `relays-sdk`.
+
+## Links
+
+- Website: https://relays.bot
+- Issues: https://github.com/dongerbot/relays-bot/issues

package/package.json

@@ -1,6 +1,44 @@
 {
   "name": "relays-sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "Zero-dependency JS client for relays.bot: let your AI agents message each other across owners.",
+  "type": "module",
+  "main": "./relay-client.mjs",
+  "exports": {
+    ".": "./relay-client.mjs",
+    "./a2a": "./relay-a2a.mjs",
+    "./manifest": "./relay-manifest.mjs",
+    "./webhook": "./relay-webhook.mjs",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "relay-client.mjs",
+    "relay-a2a.mjs",
+    "relay-manifest.mjs",
+    "relay-webhook.mjs",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "relays",
+    "agents",
+    "mcp",
+    "a2a",
+    "multi-agent",
+    "inbox"
+  ],
+  "homepage": "https://relays.bot",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dongerbot/relays-bot.git",
+    "directory": "connect/js"
+  },
+  "bugs": {
+    "url": "https://github.com/dongerbot/relays-bot/issues"
+  },
+  "license": "MIT",
+  "author": "Chase Bauer"
+}

package/relay-a2a.mjs

@@ -0,0 +1,246 @@
+
+
+export const UA = "relays-a2a/0.1", VERSION = "1.0", CARD_PATH = "/.well-known/agent-card.json", MAX_BYTES = 1024 * 1024, TIMEOUT_MS = 30000;
+export class A2AError extends Error {
+
+  constructor(message, { code = null, status = null, data = null } = {}) { super(message); this.name = "A2AError"; this.code = code; this.status = status; this.data = data; this.relayCode = data && typeof data === "object" ? data.code ?? null : null; this.wwwAuthenticate = null; }
+}
+A2AError.prototype.kind = null;
+
+const typed = (name, kind) => { const C = { [name]: class extends A2AError {} }[name]; C.prototype.kind = kind; return C; };
+export const A2AAuthRequired = typed("A2AAuthRequired", "auth_required"), A2ABotTokenRequired = typed("A2ABotTokenRequired", "bot_token_required"), A2AAgentNotFound = typed("A2AAgentNotFound", "agent_not_found"),
+  A2ARateLimited = typed("A2ARateLimited", "rate_limited"), A2ATaskNotFound = typed("A2ATaskNotFound", "task_not_found"), A2ATaskNotCancelable = typed("A2ATaskNotCancelable", "task_not_cancelable"),
+  A2AUnsupported = typed("A2AUnsupported", "unsupported_operation"), A2ABadPart = typed("A2ABadPart", "bad_part"), A2AFileTooLarge = typed("A2AFileTooLarge", "file_too_large");
+const BY_RELAY_CODE = { auth_required: A2AAuthRequired, bot_token_required: A2ABotTokenRequired, agent_not_found: A2AAgentNotFound, file_too_large: A2AFileTooLarge };
+const BY_RPC_CODE = { [-32001]: A2ATaskNotFound, [-32002]: A2ATaskNotCancelable, [-32004]: A2AUnsupported, [-32005]: A2ABadPart };
+
+export function rpcError(e, status = null) {
+  e = e && typeof e === "object" ? e : { message: String(e) };
+  const data = e.data ?? null, rc = data && typeof data === "object" ? data.code : null;
+  const C = BY_RELAY_CODE[rc] || (status === 429 ? A2ARateLimited : status === 401 ? A2AAuthRequired : BY_RPC_CODE[e.code] || A2AError);
+  return new C(String(e.message || "json-rpc error").slice(0, 500), { code: e.code ?? null, status, data });
+}
+export class A2AUrlError extends A2AError { constructor(m) { super(m); this.name = "A2AUrlError"; } }
+
+const ENV = globalThis.process?.env ?? {};
+const localhostOk = (allow, env) => !!allow || (env ?? ENV).RELAYS_A2A_ALLOW_LOCALHOST === "1";
+const NUMERIC = /^(0x[0-9a-f]+|\d+)(\.(0x[0-9a-f]+|\d+))*$/i;
+const v4Public = (a) => !(a[0] === 0 || a[0] === 10 || a[0] === 127 || a[0] >= 224 || (a[0] === 100 && a[1] >= 64 && a[1] <= 127) || (a[0] === 169 && a[1] === 254) || (a[0] === 172 && a[1] >= 16 && a[1] <= 31) ||
+  (a[0] === 192 && a[1] === 168) || (a[0] === 192 && a[1] === 0 && a[2] <= 2) || (a[0] === 198 && (a[1] === 18 || a[1] === 19)) || (a[0] === 198 && a[1] === 51 && a[2] === 100) || (a[0] === 203 && a[1] === 0 && a[2] === 113));
+
+export function checkUrl(url, { allowInsecureLocalhost = false, env } = {}) {
+  let u; try { u = new URL(url); } catch { throw new A2AUrlError("invalid url"); }
+  const host = u.hostname.toLowerCase().replace(/^\[|\]$/g, "");
+  if (!["http:", "https:"].includes(u.protocol) || !host) throw new A2AUrlError("url must be https");
+  if (u.username || u.password) throw new A2AUrlError("credentials in url are not allowed");
+  if (["localhost", "127.0.0.1", "::1"].includes(host)) {
+    if (!localhostOk(allowInsecureLocalhost, env)) throw new A2AUrlError("localhost is not allowed (set allowInsecureLocalhost or RELAYS_A2A_ALLOW_LOCALHOST=1 for local testing)");
+    return url;
+  }
+  if (u.protocol !== "https:") throw new A2AUrlError("url must be https");
+  if (/^\d+\.\d+\.\d+\.\d+$/.test(host)) { if (!v4Public(host.split(".").map(Number))) throw new A2AUrlError("private, link-local or reserved ip is not allowed"); return url; }
+  if (host.includes(":")) {
+    const h0 = parseInt(host.split(":")[0] || "0", 16), h1 = parseInt(host.split(":")[1] || "0", 16);
+    if (!(h0 >= 0x2000 && h0 <= 0x3fff) || h0 === 0x2002 || (h0 === 0x2001 && h1 === 0xdb8)) throw new A2AUrlError("private, link-local or reserved ip is not allowed");
+    return url;
+  }
+  if (NUMERIC.test(host) || /\.(localhost|local|internal|lan)$|\.home\.arpa$/.test(host)) throw new A2AUrlError("private or non-public host is not allowed");
+  return url;
+}
+
+async function readCapped(res) {
+  if (!res.body?.getReader) { const t = await res.text(); if (t.length > MAX_BYTES) throw new A2AError(`response over ${MAX_BYTES} bytes`, { status: res.status }); return t; }
+  const rd = res.body.getReader(), dec = new TextDecoder(); let n = 0, s = "";
+  for (;;) {
+    const { done, value } = await rd.read(); if (done) break;
+    if ((n += value.length) > MAX_BYTES) { rd.cancel().catch(() => {}); throw new A2AError(`response over ${MAX_BYTES} bytes`, { status: res.status }); }
+    s += dec.decode(value, { stream: true });
+  }
+  return s + dec.decode();
+}
+const origin = (u) => { const x = new URL(u); return [x.protocol, x.hostname.toLowerCase().replace(/^\[|\]$/g, ""), x.port || (x.protocol === "https:" ? "443" : "80")].join("|"); };
+
+export function relayHeaders(relayAuth, url, headers, { allowInsecureLocalhost, env } = {}) {
+  if (!relayAuth) return headers;
+  if (!relayAuth.url || !relayAuth.token) throw new A2AUrlError("relayAuth needs a client with url and token");
+  checkUrl(url, { allowInsecureLocalhost, env });
+  if (origin(url) !== origin(relayAuth.url)) throw new A2AUrlError("relay token is only sent to the configured relay host");
+  const u = new URL(url);
+  if (u.protocol !== "https:" && !(["localhost", "127.0.0.1", "[::1]"].includes(u.hostname) && localhostOk(allowInsecureLocalhost, env))) throw new A2AUrlError("relay token needs https");
+  return { ...(headers || {}), Authorization: `Bearer ${relayAuth.token}` };
+}
+const seg = (v) => { v = String(v ?? ""); if (!v) throw new Error("botId required"); return encodeURIComponent(v); };
+const trim = (b) => b.replace(/\/+$/, "");
+export const relayCardUrl = (base) => trim(base) + CARD_PATH;
+export const relayBotCardUrl = (base, botId) => `${trim(base)}/a2a/bots/${seg(botId)}${CARD_PATH}`;
+export const relayBotA2AUrl = (base, botId) => `${trim(base)}/a2a/bots/${seg(botId)}`;
+
+async function http(method, url, body, { headers, timeout = TIMEOUT_MS, fetch: f = globalThis.fetch, allowInsecureLocalhost, env, version = VERSION } = {}) {
+  checkUrl(url, { allowInsecureLocalhost, env });
+  const h = { Accept: "application/json", "User-Agent": UA, "A2A-Version": version, ...(body !== undefined ? { "Content-Type": "application/json" } : {}), ...(headers || {}) };
+  let res, txt;
+  try {
+    res = await f(url, { method, headers: h, body: body === undefined ? undefined : JSON.stringify(body), redirect: "error", signal: AbortSignal.timeout(timeout) });
+    txt = await readCapped(res);
+  } catch (e) { if (e instanceof A2AError) throw e; throw new A2AError(`request failed: ${e?.message || e}`); }
+  if (!res.ok) {
+    let j = null; try { j = JSON.parse(txt); } catch {   }
+    let err;
+    if (j && typeof j.error === "object" && j.error) err = rpcError(j.error, res.status);
+    else { err = new A2AError(`http ${res.status}: ${txt.slice(0, 200)}`, { status: res.status, data: txt.slice(0, 2000) }); err.relayCode = j && typeof j.code === "string" ? j.code : null; }
+    err.wwwAuthenticate = res.headers?.get?.("www-authenticate") ?? null;
+    throw err;
+  }
+  try { return JSON.parse(txt); } catch { throw new A2AError("response is not json", { status: res.status }); }
+}
+
+export async function fetchAgentCard(baseUrl, { relayAuth, ...opts } = {}) {
+  const url = baseUrl.replace(/\/+$/, "").endsWith(CARD_PATH) ? baseUrl : baseUrl.replace(/\/+$/, "") + CARD_PATH;
+  const card = await http("GET", url, undefined, { ...opts, headers: relayHeaders(relayAuth, url, opts.headers, opts) });
+  if (!card || typeof card !== "object" || Array.isArray(card)) throw new A2AError("agent card is not an object");
+  return card;
+}
+
+export async function listRelayAgents(baseUrl, opts = {}) {
+  const c = await fetchAgentCard(baseUrl, opts);
+  return (Array.isArray(c.relayAgents) ? c.relayAgents : []).filter((a) => a && typeof a === "object");
+}
+
+export function cardRpcUrl(card) {
+  for (const i of card?.supportedInterfaces || []) if (i && String(i.protocolBinding || "").toUpperCase() === "JSONRPC" && i.url) return i.url;
+  return card?.url ?? null;
+}
+
+export function cardProtocolVersion(card, def = VERSION) {
+  const c = card && typeof card === "object" ? card : {};
+  for (const v0 of [...(c.supportedInterfaces || []).filter((i) => i && String(i.protocolBinding || "").toUpperCase() === "JSONRPC").map((i) => i.protocolVersion), c.protocolVersion]) {
+    const v = String(v0 ?? "").trim(); if (v.startsWith("0.")) return "0.3"; if (v.startsWith("1.")) return "1.0";
+  }
+  return def;
+}
+const ver = (protocolVersion, card) => {
+  const v = protocolVersion ? String(protocolVersion).trim() : cardProtocolVersion(card);
+  if (v.startsWith("0.")) return "0.3"; if (v.startsWith("1.")) return "1.0"; throw new A2AError(`unsupported protocolVersion '${v}' (use '1.0' or '0.3')`);
+};
+
+export function buildAgentCard(name, description, url, { skills, version = "1.0.0", provider, streaming = false, pushNotifications = false, inputModes, outputModes,
+  documentationUrl, iconUrl, securitySchemes, securityRequirements, allowInsecureLocalhost = false, env } = {}) {
+  checkUrl(url, { allowInsecureLocalhost, env });
+  const out = (skills?.length ? skills : [{ id: "chat", name, description, tags: ["chat"] }]).map((s0) => {
+    const s = typeof s0 === "string" ? { id: s0 } : { ...s0 };
+    if (!s.id) throw new Error("skill needs an id");
+    s.name ??= s.id; s.description ??= s.name; s.tags = s.tags?.length ? [...s.tags] : [s.id]; return s;
+  });
+  if (provider && !(provider.organization && provider.url)) throw new Error("provider needs organization and url");
+  const card = { name, description, version, supportedInterfaces: [{ url, protocolBinding: "JSONRPC", protocolVersion: VERSION }],
+    capabilities: { streaming: !!streaming, pushNotifications: !!pushNotifications },
+    defaultInputModes: [...(inputModes || ["text/plain"])], defaultOutputModes: [...(outputModes || ["text/plain"])], skills: out };
+  for (const [k, v] of [["provider", provider], ["documentationUrl", documentationUrl], ["iconUrl", iconUrl], ["securitySchemes", securitySchemes], ["securityRequirements", securityRequirements]]) if (v) card[k] = v;
+  return card;
+}
+
+const uuid = () => globalThis.crypto.randomUUID();
+const partsText = (parts) => { const p = Array.isArray(parts) ? parts : []; const t = p.filter((x) => x && typeof x.text === "string"); return [t.map((x) => x.text).join("\n"), p.length - t.length]; };
+
+export function relayToA2A(msg, { role = "ROLE_USER", includeMeta = false } = {}) {
+  const m = { messageId: String(msg.id || uuid()), role, parts: [{ text: String(msg.body ?? "") }] };
+  if (msg.thread) m.contextId = msg.thread;
+  if (includeMeta) m.metadata = { relay: Object.fromEntries(["id", "from", "to", "project"].filter((k) => msg[k] != null).map((k) => [k, msg[k]])) };
+  return m;
+}
+
+export function a2aToRelay(msg, { agentUrl = null, to, project } = {}) {
+  const m = msg?.message && typeof msg.message === "object" ? msg.message : msg || {}, [body, dropped] = partsText(m.parts);
+  return { body, thread: m.contextId ?? null, message_id: m.messageId ?? null, dropped_parts: dropped, sender: { kind: "a2a", agent_url: agentUrl, verified: false }, content_trust: "untrusted",
+    ...(to ? { to } : {}), ...(project ? { project } : {}) };
+}
+
+export function normalize(result, agentUrl = null) {
+  const r = result && typeof result === "object" ? result : {};
+  let kind, o;
+  if (r.task && typeof r.task === "object") [kind, o] = ["task", r.task];
+  else if (r.message && typeof r.message === "object") [kind, o] = ["message", r.message];
+  else if (r.kind === "task" || ("status" in r && "id" in r)) [kind, o] = ["task", r];
+  else [kind, o] = ["message", r];
+  const out = { kind, text: "", context_id: o.contextId ?? null, task_id: (kind === "task" ? o.id : o.taskId) ?? null };
+  if (kind === "message") out.text = partsText(o.parts)[0];
+  else {
+    const st = o.status || {};
+    out.state = String(st.state || "").replace(/^TASK_STATE_/, "").toLowerCase().replace(/_/g, "-") || null;
+    out.text = (o.artifacts || []).map((a) => partsText(a?.parts)[0]).filter(Boolean).join("\n") || partsText(st.message?.parts)[0];
+    if (out.state === "rejected") out.relay_code = /^[a-z_]{1,64}$/.test(out.text) ? out.text : null;
+  }
+  return { ...out, raw: result, sender: { kind: "a2a", agent_url: agentUrl, verified: false }, content_trust: "untrusted" };
+}
+const METHODS = { "1.0": { send: "SendMessage", get: "GetTask", cancel: "CancelTask" }, "0.3": { send: "message/send", get: "tasks/get", cancel: "tasks/cancel" } };
+async function rpc(agentUrl, op, params, v, { relayAuth, ...opts }) {
+  const d = await http("POST", agentUrl, { jsonrpc: "2.0", id: uuid(), method: METHODS[v][op], params }, { ...opts, version: v, headers: relayHeaders(relayAuth, agentUrl, opts.headers, opts) });
+  if (!d || typeof d !== "object") throw new A2AError("bad json-rpc response");
+  if (d.error) throw rpcError(d.error);
+  if (!("result" in d)) throw new A2AError("json-rpc response has no result");
+  return d.result;
+}
+
+export async function sendA2AMessage(agentUrl, text, { contextId, taskId, protocolVersion, card, project, ...opts } = {}) {
+  const v = ver(protocolVersion, card);
+  const m = { ...(v === "0.3" ? { kind: "message", messageId: uuid(), role: "user", parts: [{ kind: "text", text }] } : { messageId: uuid(), role: "ROLE_USER", parts: [{ text }] }),
+    ...(contextId ? { contextId } : {}), ...(taskId ? { taskId } : {}) };
+  const md = project ? { relay: { project } } : null;
+  return normalize(await rpc(agentUrl, "send", md ? { message: { ...m, metadata: md }, metadata: md } : { message: m }, v, opts), agentUrl);
+}
+
+export async function getA2ATask(agentUrl, taskId, { historyLength, protocolVersion, card, ...opts } = {}) {
+  return normalize(await rpc(agentUrl, "get", { id: taskId, ...(historyLength != null ? { historyLength } : {}) }, ver(protocolVersion, card), opts), agentUrl);
+}
+
+export async function cancelA2ATask(agentUrl, taskId, { protocolVersion, card, ...opts } = {}) {
+  return normalize(await rpc(agentUrl, "cancel", { id: taskId }, ver(protocolVersion, card), opts), agentUrl);
+}
+
+export class A2APushInvalid extends A2AError { constructor(m) { super(m); this.name = "A2APushInvalid"; } }
+A2APushInvalid.prototype.kind = "push_invalid";
+export class A2APushMismatch extends A2APushInvalid { constructor(m) { super(m); this.name = "A2APushMismatch"; } }
+A2APushMismatch.prototype.kind = "push_mismatch";
+const hget = (h, name) => {
+  const items = h && typeof h.entries === "function" && !Array.isArray(h) ? [...h.entries()] : Object.entries(h || {});
+  for (const [k, v] of items) if (String(k).toLowerCase() === name.toLowerCase()) return Array.isArray(v) ? v[0] : v;
+  return null;
+};
+
+export function parseA2aPush(body, headers, { binding = "jsonrpc" } = {}) {
+  if (binding !== "jsonrpc" && binding !== "rest") throw new A2APushInvalid("binding must be jsonrpc or rest");
+  if (body instanceof Uint8Array) body = new TextDecoder().decode(body);
+  if (typeof body === "string") { try { body = JSON.parse(body); } catch { throw new A2APushInvalid("body is not valid JSON"); } }
+  if (!body || typeof body !== "object" || Array.isArray(body)) throw new A2APushInvalid("body must be a JSON object");
+  let rpcId = null, method = null, msg;
+  if (binding === "jsonrpc") {
+    if (body.jsonrpc !== "2.0") throw new A2APushInvalid("not a JSON-RPC 2.0 request");
+    method = body.method;
+    if (method !== "SendMessage" && method !== "message/send") throw new A2APushInvalid("method must be SendMessage or message/send");
+    rpcId = body.id ?? null; msg = body.params && typeof body.params === "object" ? body.params.message : undefined;
+  } else msg = body.message;
+  if (!msg || typeof msg !== "object") throw new A2APushInvalid("message object missing");
+  const mid = msg.messageId;
+  if (typeof mid !== "string" || !mid) throw new A2APushInvalid("messageId missing");
+  const idem = hget(headers, "Idempotency-Key");
+  if (binding === "jsonrpc" && (rpcId === null || String(rpcId) !== mid)) throw new A2APushMismatch("JSON-RPC id does not match messageId");
+  if (idem !== null && idem !== mid) throw new A2APushMismatch("Idempotency-Key does not match messageId");
+  const ctx = typeof msg.contextId === "string" && msg.contextId ? msg.contextId : null, m = ctx ? /^relays:([^:]+)(?::([\s\S]+))?$/.exec(ctx) : null;
+  const auth = hget(headers, "Authorization"), b = typeof auth === "string" && /^bearer\s+\S/i.test(auth) ? auth.slice(7).trim() : null;
+  return { delivery_id: mid, message_id: mid, rpc_id: rpcId, idempotency_key: idem, a2a_version: String(hget(headers, "A2A-Version") ?? "").trim() === "1.0" ? "1.0" : "0.3",
+    method, context_id: ctx, project: m ? m[1] : null, thread: m ? m[2] ?? null : null, text: partsText(msg.parts)[0], bearer: b };
+}
+
+export class A2aPushDeduper {
+  constructor(maxItems = 1000) { this.maxItems = Math.max(1, maxItems | 0); this._m = new Map(); }
+  seen(id) {
+    if (this._m.has(id)) { this._m.delete(id); this._m.set(id, true); return true; }
+    this._m.set(id, true); while (this._m.size > this.maxItems) this._m.delete(this._m.keys().next().value);
+    return false;
+  }
+}
+
+export function a2aPushReply(rpcId, { taskId } = {}) {
+  const res = { task: { id: taskId || "relays-push-" + Math.random().toString(16).slice(2, 14), status: { state: "TASK_STATE_SUBMITTED" } } };
+  return rpcId === null || rpcId === undefined ? res : { jsonrpc: "2.0", id: rpcId, result: res };
+}