Function processOne

src/jsonrpc.ts:33–85

(
  entry: unknown,
  methods: Record<string, MethodHandler>,
  onNotification: ((method: string, params: unknown) => void) | undefined,
  req: http.IncomingMessage,
)

}

async function processOne(
  entry: unknown,
  methods: Record<string, MethodHandler>,
  onNotification: ((method: string, params: unknown) => void) | undefined,
  req: http.IncomingMessage,
): Promise<JsonRpcResponse | null> {
  if (!isObject(entry)) {
    return errorResponse(-32600, "Invalid request");
  }

  const { jsonrpc, method, params, id } = entry;

  if (jsonrpc !== "2.0" || typeof method !== "string") {
    const reqId = typeof id === "string" || typeof id === "number" ? id : null;
    return errorResponse(-32600, "Invalid request", reqId);
  }

  // Notification: id is absent/undefined
  const isNotification = !("id" in entry) || id === undefined;

  if (isNotification) {
    if (onNotification) {
      onNotification(method, params);
    }
    // Invoke the method handler for side effects (e.g., MCP notifications/initialized),
    // but discard the result — notifications MUST NOT produce responses per JSON-RPC 2.0.
    const handler = methods[method];
    if (handler) {
      try {
        await handler(params, null as unknown as string | number, req);
      } catch (err: unknown) {
        console.warn("Notification handler error:", err);
      }
    }
    return null;
  }

  const reqId = typeof id === "string" || typeof id === "number" ? id : null;

  const handler = methods[method];
  if (!handler) {
    return errorResponse(-32601, "Method not found", reqId);
  }

  try {
    const result = await handler(params, reqId as string | number, req);
    if (result) return result;
    return { jsonrpc: "2.0", id: reqId, result: null };
  } catch (err: unknown) {
    const msg = err instanceof Error ? err.message : String(err);
    return errorResponse(-32603, `Internal error: ${msg}`, reqId);
  }
}

export function createJsonRpcDispatcher(
  options: JsonRpcDispatcherOptions,